Add nodes for float extend/truncate operations

These always go between `f32` and `f64`, much like the integer ones.

Author: nmraz

crates/filetests/cases/verify/err/fext_trunc.spdr

@@ -0,0 +1,77 @@
+# run: verify-err
+
+func @fext_bad_input_count:f32() {
+    # check: function `fext_bad_input_count`:
+    # unordered: `$val:f32 = fext $val, $val, $val`: bad input count, expected 1
+    # unordered: `$val:f32 = fext`: bad input count, expected 1
+
+    %0:ctrl = entry
+    %1:f32 = fext
+    %2:f32 = fext %1, %1, %1
+    return %0, %2
+}
+
+func @fext_bad_output_count:f64(f32) {
+    # check: function `fext_bad_output_count`:
+    # unordered: `$val:f64, $val:f64 = fext $val`: bad output count, expected 1
+
+    %0:ctrl, %1:f32 = entry
+    %2:f64, %3:f64 = fext %1
+    return %0, %2
+}
+
+func @fext_bad_output_kind:f32(f32) {
+    # check: function `fext_bad_output_kind`:
+    # unordered: `$val:f32 = fext $val`: bad value kind for output 0, expected one of `f64`, got `f32`
+
+    %0:ctrl, %1:f32 = entry
+    %2:f32 = fext %1
+    return %0, %2
+}
+
+func @fext_bad_input_kind:f64(f64) {
+    # check: function `fext_bad_input_kind`:
+    # unordered: `$val:f64 = fext $val`: bad value kind for input 0, expected one of `f32`, got `f64`
+
+    %0:ctrl, %1:f64 = entry
+    %2:f64 = fext %1
+    return %0, %2
+}
+
+func @ftrunc_bad_input_count:f32() {
+    # check: function `ftrunc_bad_input_count`:
+    # unordered: `$val:f32 = ftrunc $val, $val, $val`: bad input count, expected 1
+    # unordered: `$val:f32 = ftrunc`: bad input count, expected 1
+
+    %0:ctrl = entry
+    %1:f32 = ftrunc
+    %2:f32 = ftrunc %1, %1, %1
+    return %0, %2
+}
+
+func @ftrunc_bad_output_count:f32(f64) {
+    # check: function `ftrunc_bad_output_count`:
+    # unordered: `$val:f32, $val:f32 = ftrunc $val`: bad output count, expected 1
+
+    %0:ctrl, %1:f64 = entry
+    %2:f32, %3:f32 = ftrunc %1
+    return %0, %2
+}
+
+func @ftrunc_bad_output_kind:f64(f64) {
+    # check: function `ftrunc_bad_output_kind`:
+    # unordered: `$val:f64 = ftrunc $val`: bad value kind for output 0, expected one of `f32`, got `f64`
+
+    %0:ctrl, %1:f64 = entry
+    %2:f64 = ftrunc %1
+    return %0, %2
+}
+
+func @ftrunc_bad_input_kind:f32(f32) {
+    # check: function `ftrunc_bad_input_kind`:
+    # unordered: `$val:f32 = ftrunc $val`: bad value kind for input 0, expected one of `f64`, got `f32`
+
+    %0:ctrl, %1:f32 = entry
+    %2:f32 = ftrunc %1
+    return %0, %2
+}

crates/filetests/cases/verify/ok/fext_trunc.spdr

@@ -0,0 +1,15 @@
+# run: verify-ok
+
+# check: $()
+
+func @fext:f64(f32) {
+    %0:ctrl, %1:f32 = entry
+    %2:f64 = fext %1
+    return %0, %2
+}
+
+func @ftrunc:f32(f64) {
+    %0:ctrl, %1:f64 = entry
+    %2:f32 = ftrunc %1
+    return %0, %2
+}

crates/ir/src/node.rs

@@ -239,6 +239,8 @@ pub enum NodeKind {
     Fsub,
     Fmul,
     Fdiv,
+    Fext,
+    Ftrunc,
     Fcmp(FcmpKind),
     SintToFloat,
     UintToFloat,

crates/ir/src/verify/node.rs

@@ -48,6 +48,8 @@ pub fn verify_node_kind(
         NodeKind::Fsub => verify_float_binop(graph, node, errors),
         NodeKind::Fmul => verify_float_binop(graph, node, errors),
         NodeKind::Fdiv => verify_float_binop(graph, node, errors),
+        NodeKind::Fext => verify_fext(graph, node, errors),
+        NodeKind::Ftrunc => verify_ftrunc(graph, node, errors),
         NodeKind::Fcmp(_) => verify_fcmp(graph, node, errors),
         NodeKind::SintToFloat => verify_inttofloat(graph, node, errors),
         NodeKind::UintToFloat => verify_inttofloat(graph, node, errors),
@@ -332,6 +334,22 @@ fn verify_float_binop(graph: &ValGraph, node: Node, errors: &mut Vec<FunctionVer
     let _ = verify_input_kind(graph, node, 1, &[result_kind], errors);
 }
 
+fn verify_fext(graph: &ValGraph, node: Node, errors: &mut Vec<FunctionVerifierError>) {
+    let Ok([result]) = verify_node_arity(graph, node, 1, errors) else {
+        return;
+    };
+    let _ = verify_input_kind(graph, node, 0, &[DepValueKind::Value(Type::F32)], errors);
+    let _ = verify_output_kind(graph, result, &[DepValueKind::Value(Type::F64)], errors);
+}
+
+fn verify_ftrunc(graph: &ValGraph, node: Node, errors: &mut Vec<FunctionVerifierError>) {
+    let Ok([result]) = verify_node_arity(graph, node, 1, errors) else {
+        return;
+    };
+    let _ = verify_input_kind(graph, node, 0, &[DepValueKind::Value(Type::F64)], errors);
+    let _ = verify_output_kind(graph, result, &[DepValueKind::Value(Type::F32)], errors);
+}
+
 fn verify_fcmp(graph: &ValGraph, node: Node, errors: &mut Vec<FunctionVerifierError>) {
     let Ok([result]) = verify_node_arity(graph, node, 2, errors) else {
         return;

crates/ir/src/write.rs

@@ -289,6 +289,8 @@ pub fn write_node_kind(
         NodeKind::Fsub => write!(w, "fsub")?,
         NodeKind::Fmul => write!(w, "fmul")?,
         NodeKind::Fdiv => write!(w, "fdiv")?,
+        NodeKind::Fext => write!(w, "fext")?,
+        NodeKind::Ftrunc => write!(w, "ftrunc")?,
         NodeKind::Fcmp(kind) => write!(w, "fcmp {kind}")?,
         NodeKind::SintToFloat => write!(w, "sinttofloat")?,
         NodeKind::UintToFloat => write!(w, "uinttofloat")?,

crates/parser/src/grammar.pest

@@ -76,6 +76,8 @@ nodekind           =  {
   | "fsub"
   | "fmul"
   | "fdiv"
+  | "fext"
+  | "ftrunc"
   | fcmp_nodekind
   | "sinttofloat"
   | "uinttofloat"

crates/parser/src/lib.rs

@@ -278,6 +278,8 @@ fn extract_node_kind(
         "fsub" => Ok(NodeKind::Fsub),
         "fmul" => Ok(NodeKind::Fmul),
         "fdiv" => Ok(NodeKind::Fdiv),
+        "fext" => Ok(NodeKind::Fext),
+        "ftrunc" => Ok(NodeKind::Ftrunc),
         "sinttofloat" => Ok(NodeKind::SintToFloat),
         "uinttofloat" => Ok(NodeKind::UintToFloat),
         "floattosint" => Ok(NodeKind::FloatToSint),
@@ -702,6 +704,8 @@ mod tests {
             "fsub",
             "fmul",
             "fdiv",
+            "fext",
+            "ftrunc",
             "fcmp oeq",
             "fcmp one",
             "fcmp olt",