github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

[spv-out] Add scalar conversion support

Browse Source
This commit is contained in:
Timo de Kort
2020-10-03 00:47:39 +02:00
committed by Dzmitry Malyshau
parent 98167103c2
commit 90c56aca2f
2 changed files with 115 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/back/spv/instructions.rs
View File

@@ -453,7 +453,49 @@ pub(super) fn instruction_function_call(
//
// Conversion Instructions
//
fn instruction_unary(op: Op, result_type_id: Word, id: Word, value: Word) -> Instruction {
let mut instruction = Instruction::new(op);
instruction.set_type(result_type_id);
instruction.set_result(id);
instruction.add_operand(value);
instruction
}
pub(super) fn instruction_convert_f_to_u(
result_type_id: Word,
id: Word,
float_value: Word,
) -> Instruction {
instruction_unary(Op::ConvertFToU, result_type_id, id, float_value)
}
pub(super) fn instruction_convert_f_to_s(
result_type_id: Word,
id: Word,
float_value: Word,
) -> Instruction {
instruction_unary(Op::ConvertFToS, result_type_id, id, float_value)
}
pub(super) fn instruction_convert_s_to_f(
result_type_id: Word,
id: Word,
signed_value: Word,
) -> Instruction {
instruction_unary(Op::ConvertSToF, result_type_id, id, signed_value)
}
pub(super) fn instruction_convert_u_to_f(
result_type_id: Word,
id: Word,
unsigned_value: Word,
) -> Instruction {
instruction_unary(Op::ConvertUToF, result_type_id, id, unsigned_value)
}
pub(super) fn instruction_bit_cast(result_type_id: Word, id: Word, operand: Word) -> Instruction {
instruction_unary(Op::Bitcast, result_type_id, id, operand)
}
//
// Composite Instructions
//

73
src/back/spv/writer.rs
View File

@@ -1033,6 +1033,79 @@ impl Writer {
}
_ => unimplemented!("{:?}", origin),
},
crate::Expression::As {
expr,
kind,
convert,
} => {
if !convert {
return None;
}
let (expr_id, expr_type) = self
.write_expression(
ir_module,
ir_function,
&ir_function.expressions[*expr],
block,
function,
)
.unwrap();
let id = self.generate_id();
let instruction = match ir_module.types[expr_type.unwrap()].inner {
crate::TypeInner::Scalar {
kind: expr_kind,
width,
} => {
let kind_type_id = self.get_type_id(
&ir_module.types,
LookupType::Local(LocalType::Scalar { kind: *kind, width }),
);
if *convert {
super::instructions::instruction_bit_cast(kind_type_id, id, expr_id)
} else {
match (expr_kind, kind) {
(crate::ScalarKind::Float, crate::ScalarKind::Uint) => {
super::instructions::instruction_convert_f_to_u(
kind_type_id,
id,
expr_id,
)
}
(crate::ScalarKind::Float, crate::ScalarKind::Sint) => {
super::instructions::instruction_convert_f_to_s(
kind_type_id,
id,
expr_id,
)
}
(crate::ScalarKind::Sint, crate::ScalarKind::Float) => {
super::instructions::instruction_convert_s_to_f(
kind_type_id,
id,
expr_id,
)
}
(crate::ScalarKind::Uint, crate::ScalarKind::Float) => {
super::instructions::instruction_convert_u_to_f(
kind_type_id,
id,
expr_id,
)
}
_ => unreachable!(),
}
}
}
_ => unreachable!(),
};
block.body.push(instruction);
Some((id, None))
}
_ => unimplemented!("{:?}", expression),
}
}