Implement more Bitcast conversions. (bytecodealliance#872)

* Implement more `Bitcast` conversions.

Implement `Bitcast` conversions between more combinations of f32, f64,
pointer, and length types.

* Implement more bitcast cases.

* Add `variants-unioning-types` to the list of tests to skip in the csharp backend.

* Factor out some additional redundancy in the rust generator.

Author: sunfishcode

crates/c/src/lib.rs

@@ -2183,41 +2183,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
             Instruction::Bitcasts { casts } => {
                 for (cast, op) in casts.iter().zip(operands) {
-                    let op = op;
-                    match cast {
-                        Bitcast::I32ToF32 | Bitcast::I64ToF32 => {
-                            results
-                                .push(format!("((union {{ int32_t a; float b; }}){{ {} }}).b", op));
-                        }
-                        Bitcast::F32ToI32 | Bitcast::F32ToI64 => {
-                            results
-                                .push(format!("((union {{ float a; int32_t b; }}){{ {} }}).b", op));
-                        }
-                        Bitcast::I64ToF64 => {
-                            results.push(format!(
-                                "((union {{ int64_t a; double b; }}){{ {} }}).b",
-                                op
-                            ));
-                        }
-                        Bitcast::F64ToI64 => {
-                            results.push(format!(
-                                "((union {{ double a; int64_t b; }}){{ {} }}).b",
-                                op
-                            ));
-                        }
-                        Bitcast::I32ToI64 | Bitcast::PToP64 => {
-                            results.push(format!("(int64_t) {}", op));
-                        }
-                        Bitcast::I64ToI32 | Bitcast::P64ToP => {
-                            results.push(format!("(int32_t) {}", op));
-                        }
-                        Bitcast::I64ToP64 | Bitcast::P64ToI64 => {
-                            results.push(format!("{}", op));
-                        }
-                        Bitcast::I32ToP | Bitcast::PToI32 | Bitcast::None => {
-                            results.push(op.to_string())
-                        }
-                    }
+                    let op = perform_cast(op, cast);
+                    results.push(op);
                 }
             }
 
@@ -2951,6 +2918,44 @@ impl Bindgen for FunctionBindgen<'_, '_> {
     }
 }
 
+fn perform_cast(op: &str, cast: &Bitcast) -> String {
+    match cast {
+        Bitcast::I32ToF32 | Bitcast::I64ToF32 => {
+            format!("((union {{ int32_t a; float b; }}){{ {} }}).b", op)
+        }
+        Bitcast::F32ToI32 | Bitcast::F32ToI64 => {
+            format!("((union {{ float a; int32_t b; }}){{ {} }}).b", op)
+        }
+        Bitcast::I64ToF64 => {
+            format!("((union {{ int64_t a; double b; }}){{ {} }}).b", op)
+        }
+        Bitcast::F64ToI64 => {
+            format!("((union {{ double a; int64_t b; }}){{ {} }}).b", op)
+        }
+        Bitcast::I32ToI64 | Bitcast::LToI64 | Bitcast::PToP64 => {
+            format!("(int64_t) {}", op)
+        }
+        Bitcast::I64ToI32 | Bitcast::I64ToL | Bitcast::P64ToP => {
+            format!("(int32_t) {}", op)
+        }
+        Bitcast::I64ToP64 | Bitcast::P64ToI64 => {
+            format!("{}", op)
+        }
+        Bitcast::I32ToP
+        | Bitcast::PToI32
+        | Bitcast::I32ToL
+        | Bitcast::LToI32
+        | Bitcast::LToP
+        | Bitcast::PToL
+        | Bitcast::None => op.to_string(),
+
+        Bitcast::Sequence(sequence) => {
+            let [first, second] = &**sequence;
+            perform_cast(&perform_cast(op, first), second)
+        }
+    }
+}
+
 #[derive(Default, Clone, Copy)]
 enum SourceType {
     #[default]

crates/core/src/abi.rs

@@ -536,23 +536,36 @@ pub enum Bitcast {
     I64ToI32,
     I64ToF32,
 
-    // PointerOrI64<->Pointer conversions. These preserve provenance.
+    // PointerOrI64 conversions. These preserve provenance when the source
+    // or destination is a pointer value.
     //
     // These are used when pointer values are being stored in
-    // (PToP64) and loaded out of (P64ToP) PointerOrI64 values, so they
-    // always have to preserve provenance.
+    // (ToP64) and loaded out of (P64To) PointerOrI64 values, so they
+    // always have to preserve provenance when the value being loaded or
+    // stored is a pointer.
+    P64ToI64,
+    I64ToP64,
     P64ToP,
     PToP64,
 
-    // Pointer<->integer conversions. These do not preserve provenance.
+    // Pointer<->number conversions. These do not preserve provenance.
     //
-    // These are used when integer values are being stored in
-    // (I64ToP64 and I32ToP) and loaded out of (P64ToI64 and PToI32) pointer
-    // or PointerOrI64 values, so they never have any provenance to preserve.
-    P64ToI64,
-    I64ToP64,
+    // These are used when integer or floating-point values are being stored in
+    // (I32ToP/etc.) and loaded out of (PToI32/etc.) pointer values, so they
+    // never have any provenance to preserve.
     I32ToP,
     PToI32,
+    PToL,
+    LToP,
+
+    // Number<->Number conversions.
+    I32ToL,
+    LToI32,
+    I64ToL,
+    LToI64,
+
+    // Multiple conversions in sequence.
+    Sequence(Box<[Bitcast; 2]>),
 
     None,
 }
@@ -1895,6 +1908,7 @@ fn cast(from: WasmType, to: WasmType) -> Bitcast {
         | (F32, F32)
         | (F64, F64)
         | (Pointer, Pointer)
+        | (PointerOrI64, PointerOrI64)
         | (Length, Length) => Bitcast::None,
 
         (I32, I64) => Bitcast::I32ToI64,
@@ -1909,19 +1923,33 @@ fn cast(from: WasmType, to: WasmType) -> Bitcast {
         (I64, F32) => Bitcast::I64ToF32,
 
         (I64, PointerOrI64) => Bitcast::I64ToP64,
-        (PointerOrI64, I64) => Bitcast::P64ToI64,
         (Pointer, PointerOrI64) => Bitcast::PToP64,
+        (_, PointerOrI64) => {
+            Bitcast::Sequence(Box::new([cast(from, I64), cast(I64, PointerOrI64)]))
+        }
+
+        (PointerOrI64, I64) => Bitcast::P64ToI64,
         (PointerOrI64, Pointer) => Bitcast::P64ToP,
+        (PointerOrI64, _) => Bitcast::Sequence(Box::new([cast(PointerOrI64, I64), cast(I64, to)])),
 
         (I32, Pointer) => Bitcast::I32ToP,
         (Pointer, I32) => Bitcast::PToI32,
+        (I32, Length) => Bitcast::I32ToL,
+        (Length, I32) => Bitcast::LToI32,
+        (I64, Length) => Bitcast::I64ToL,
+        (Length, I64) => Bitcast::LToI64,
+        (Pointer, Length) => Bitcast::PToL,
+        (Length, Pointer) => Bitcast::LToP,
+
+        (F32, Pointer | Length) => Bitcast::Sequence(Box::new([cast(F32, I32), cast(I32, to)])),
+        (Pointer | Length, F32) => Bitcast::Sequence(Box::new([cast(from, I32), cast(I32, F32)])),
 
-        (Pointer | PointerOrI64 | Length, _)
-        | (_, Pointer | PointerOrI64 | Length)
-        | (F32, F64)
+        (F32, F64)
         | (F64, F32)
         | (F64, I32)
-        | (I32, F64) => {
+        | (I32, F64)
+        | (Pointer | Length, I64 | F64)
+        | (I64 | F64, Pointer | Length) => {
             unreachable!("Don't know how to bitcast from {:?} to {:?}", from, to);
         }
     }

crates/csharp/tests/codegen.rs

@@ -56,6 +56,7 @@ macro_rules! codegen_test {
                         "unused-import",
                         "use-across-interfaces",
                         "variants",
+                        "variants-unioning-types",
                         "worlds-with-types",
                         "zero-size-tuple",
                         "go_params",

crates/rust/src/lib.rs

@@ -1327,48 +1327,64 @@ fn int_repr(repr: Int) -> &'static str {
 
 fn bitcast(casts: &[Bitcast], operands: &[String], results: &mut Vec<String>) {
     for (cast, operand) in casts.iter().zip(operands) {
-        results.push(match cast {
-            Bitcast::None => operand.clone(),
-            Bitcast::I32ToI64 => format!("i64::from({})", operand),
-            Bitcast::F32ToI32 => format!("({}).to_bits() as i32", operand),
-            Bitcast::F64ToI64 => format!("({}).to_bits() as i64", operand),
-            Bitcast::I64ToI32 => format!("{} as i32", operand),
-            Bitcast::I32ToF32 => format!("f32::from_bits({} as u32)", operand),
-            Bitcast::I64ToF64 => format!("f64::from_bits({} as u64)", operand),
-            Bitcast::F32ToI64 => format!("i64::from(({}).to_bits())", operand),
-            Bitcast::I64ToF32 => format!("f32::from_bits({} as u32)", operand),
-
-            // Convert an `i64` into a `MaybeUninit<u64>`.
-            Bitcast::I64ToP64 => format!("::core::mem::MaybeUninit::new({} as u64)", operand),
-            // Convert a `MaybeUninit<u64>` holding an `i64` value back into
-            // the `i64` value.
-            Bitcast::P64ToI64 => format!("{}.assume_init() as i64", operand),
-
-            // Convert a pointer value into a `MaybeUninit<u64>`.
-            Bitcast::PToP64 => {
-                format!(
-                    "{{
-                        let mut t = ::core::mem::MaybeUnunit::<u64>::uninit();
+        results.push(perform_cast(operand, cast));
+    }
+}
+
+fn perform_cast(operand: &str, cast: &Bitcast) -> String {
+    match cast {
+        Bitcast::None => operand.to_owned(),
+        Bitcast::I32ToI64 => format!("i64::from({})", operand),
+        Bitcast::F32ToI32 => format!("({}).to_bits() as i32", operand),
+        Bitcast::F64ToI64 => format!("({}).to_bits() as i64", operand),
+        Bitcast::I64ToI32 => format!("{} as i32", operand),
+        Bitcast::I32ToF32 => format!("f32::from_bits({} as u32)", operand),
+        Bitcast::I64ToF64 => format!("f64::from_bits({} as u64)", operand),
+        Bitcast::F32ToI64 => format!("i64::from(({}).to_bits())", operand),
+        Bitcast::I64ToF32 => format!("f32::from_bits({} as u32)", operand),
+
+        // Convert an `i64` into a `MaybeUninit<u64>`.
+        Bitcast::I64ToP64 => format!("::core::mem::MaybeUninit::new({} as u64)", operand),
+        // Convert a `MaybeUninit<u64>` holding an `i64` value back into
+        // the `i64` value.
+        Bitcast::P64ToI64 => format!("{}.assume_init() as i64", operand),
+
+        // Convert a pointer value into a `MaybeUninit<u64>`.
+        Bitcast::PToP64 => {
+            format!(
+                "{{
+                        let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                         t.as_mut_ptr().cast::<*mut u8>().write({});
                         t
                     }}",
-                    operand
-                )
-            }
-            // Convert a `MaybeUninit<u64>` holding a pointer value back into
-            // the pointer value.
-            Bitcast::P64ToP => {
-                format!("{}.as_mut_ptr().cast::<*mut u8>().read()", operand)
-            }
-            // Convert an `i32` into a pointer.
-            Bitcast::I32ToP => {
-                format!("{} as *mut u8", operand)
-            }
-            // Convert a pointer holding an `i32` value back into the `i32`.
-            Bitcast::PToI32 => {
-                format!("{} as i32", operand)
-            }
-        });
+                operand
+            )
+        }
+        // Convert a `MaybeUninit<u64>` holding a pointer value back into
+        // the pointer value.
+        Bitcast::P64ToP => {
+            format!("{}.as_mut_ptr().cast::<*mut u8>().read()", operand)
+        }
+        // Convert an `i32` or a `usize` into a pointer.
+        Bitcast::I32ToP | Bitcast::LToP => {
+            format!("{} as *mut u8", operand)
+        }
+        // Convert a pointer or length holding an `i32` value back into the `i32`.
+        Bitcast::PToI32 | Bitcast::LToI32 => {
+            format!("{} as i32", operand)
+        }
+        // Convert an `i32`, `i64`, or pointer holding a `usize` value back into the `usize`.
+        Bitcast::I32ToL | Bitcast::I64ToL | Bitcast::PToL => {
+            format!("{} as usize", operand)
+        }
+        // Convert a `usize` into an `i64`.
+        Bitcast::LToI64 => {
+            format!("{} as i64", operand)
+        }
+        Bitcast::Sequence(sequence) => {
+            let [first, second] = &**sequence;
+            perform_cast(&perform_cast(operand, first), second)
+        }
     }
 }
 

crates/teavm-java/src/lib.rs

@@ -1329,23 +1329,12 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::Float32FromF32
             | Instruction::Float64FromF64 => results.push(operands[0].clone()),
 
-            Instruction::Bitcasts { casts } => {
-                results.extend(casts.iter().zip(operands).map(|(cast, op)| match cast {
-                    Bitcast::I32ToF32 => format!("Float.intBitsToFloat({op})"),
-                    Bitcast::I64ToF32 => format!("Float.intBitsToFloat((int) ({op}))"),
-                    Bitcast::F32ToI32 => format!("Float.floatToIntBits({op})"),
-                    Bitcast::F32ToI64 => format!("(long) Float.floatToIntBits({op})"),
-                    Bitcast::I64ToF64 => format!("Double.longBitsToDouble({op})"),
-                    Bitcast::F64ToI64 => format!("Double.doubleToLongBits({op})"),
-                    Bitcast::I32ToI64 => format!("(long) ({op})"),
-                    Bitcast::I64ToI32 => format!("(int) ({op})"),
-                    Bitcast::I64ToP64 => format!("{op}"),
-                    Bitcast::P64ToI64 => format!("{op}"),
-                    Bitcast::PToP64 => format!("(long) ({op})"),
-                    Bitcast::P64ToP => format!("(int) ({op})"),
-                    Bitcast::I32ToP | Bitcast::PToI32 | Bitcast::None => op.to_owned(),
-                }))
-            }
+            Instruction::Bitcasts { casts } => results.extend(
+                casts
+                    .iter()
+                    .zip(operands)
+                    .map(|(cast, op)| perform_cast(op, cast)),
+            ),
 
             Instruction::I32FromBool => {
                 results.push(format!("({} ? 1 : 0)", operands[0]));
@@ -2099,6 +2088,43 @@ impl Bindgen for FunctionBindgen<'_, '_> {
     }
 }
 
+fn perform_cast(op: &str, cast: &Bitcast) -> String {
+    match cast {
+        Bitcast::I32ToF32 => {
+            format!("Float.intBitsToFloat({op})")
+        }
+        Bitcast::I64ToF32 => format!("Float.intBitsToFloat((int) ({op}))"),
+        Bitcast::F32ToI32 => {
+            format!("Float.floatToIntBits({op})")
+        }
+        Bitcast::F32ToI64 => format!("(long) Float.floatToIntBits({op})"),
+        Bitcast::I64ToF64 => {
+            format!("Double.longBitsToDouble({op})")
+        }
+        Bitcast::F64ToI64 => {
+            format!("Double.doubleToLongBits({op})")
+        }
+        Bitcast::I32ToI64 => format!("(long) ({op})"),
+        Bitcast::I64ToI32 => format!("(int) ({op})"),
+        Bitcast::I64ToP64 => format!("{op}"),
+        Bitcast::P64ToI64 => format!("{op}"),
+        Bitcast::LToI64 | Bitcast::PToP64 => format!("(long) ({op})"),
+        Bitcast::I64ToL | Bitcast::P64ToP => format!("(int) ({op})"),
+        Bitcast::I32ToP
+        | Bitcast::PToI32
+        | Bitcast::I32ToL
+        | Bitcast::LToI32
+        | Bitcast::LToP
+        | Bitcast::PToL
+        | Bitcast::None => op.to_owned(),
+
+        Bitcast::Sequence(sequence) => {
+            let [first, second] = &**sequence;
+            perform_cast(&perform_cast(op, first), second)
+        }
+    }
+}
+
 fn int_type(int: Int) -> &'static str {
     match int {
         Int::U8 => "byte",