Avoid dealing with big-endian vectors

* Change wasm `global`s to store `v128` in little-endian format.
* Change pulley stack loads/stores to work with vectors in little-endian
  format.

prtest:full

cranelift/codegen/src/isa/pulley_shared/abi.rs

@@ -160,11 +160,23 @@ where
     }
 
     fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Self::I {
-        Inst::gen_load(into_reg, mem.into(), ty, MemFlags::trusted()).into()
+        let mut flags = MemFlags::trusted();
+        // Stack loads/stores of vectors always use little-endianess to avoid
+        // implementing a byte-swap of vectors on big-endian platforms.
+        if ty.is_vector() {
+            flags.set_endianness(ir::Endianness::Little);
+        }
+        Inst::gen_load(into_reg, mem.into(), ty, flags).into()
     }
 
     fn gen_store_stack(mem: StackAMode, from_reg: Reg, ty: Type) -> Self::I {
-        Inst::gen_store(mem.into(), from_reg, ty, MemFlags::trusted()).into()
+        let mut flags = MemFlags::trusted();
+        // Stack loads/stores of vectors always use little-endianess to avoid
+        // implementing a byte-swap of vectors on big-endian platforms.
+        if ty.is_vector() {
+            flags.set_endianness(ir::Endianness::Little);
+        }
+        Inst::gen_store(mem.into(), from_reg, ty, flags).into()
     }
 
     fn gen_move(to_reg: Writable<Reg>, from_reg: Reg, ty: Type) -> Self::I {

cranelift/codegen/src/isa/pulley_shared/lower.isle

@@ -548,6 +548,9 @@
 (rule (lower (has_type $I64 (bitcast _flags val @ (value_type $F64))))
   (pulley_bitcast_int_from_float_64 val))
 
+(rule 1 (lower (has_type (ty_vec128 _) (bitcast _flags val @ (value_type (ty_vec128 _)))))
+  val)
+
 ;;;; Rules for `fcvt_to_{u,s}int` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type $I32 (fcvt_to_uint val @ (value_type $F32))))

crates/cranelift/src/translate/code_translator.rs

@@ -177,6 +177,12 @@ pub fn translate_operator(
                 GlobalVariable::Memory { gv, offset, ty } => {
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
                     let mut flags = ir::MemFlags::trusted();
+                    // Store vector globals in little-endian format to avoid
+                    // byte swaps on big-endian platforms since at-rest vectors
+                    // should already be in little-endian format anyway.
+                    if ty.is_vector() {
+                        flags.set_endianness(ir::Endianness::Little);
+                    }
                     // Put globals in the "table" abstract heap category as well.
                     flags.set_alias_region(Some(ir::AliasRegion::Table));
                     builder.ins().load(ty, flags, addr, offset)
@@ -191,6 +197,10 @@ pub fn translate_operator(
                 GlobalVariable::Memory { gv, offset, ty } => {
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
                     let mut flags = ir::MemFlags::trusted();
+                    // Like `global.get`, store globals in little-endian format.
+                    if ty.is_vector() {
+                        flags.set_endianness(ir::Endianness::Little);
+                    }
                     // Put globals in the "table" abstract heap category as well.
                     flags.set_alias_region(Some(ir::AliasRegion::Table));
                     let mut val = state.pop1();

crates/wasmtime/src/runtime/externals/global.rs

@@ -114,7 +114,7 @@ impl Global {
                 ValType::I64 => Val::from(*definition.as_i64()),
                 ValType::F32 => Val::F32(*definition.as_u32()),
                 ValType::F64 => Val::F64(*definition.as_u64()),
-                ValType::V128 => Val::V128((*definition.as_u128()).into()),
+                ValType::V128 => Val::V128(definition.get_u128().into()),
                 ValType::Ref(ref_ty) => {
                     let reference: Ref = match ref_ty.heap_type() {
                         HeapType::Func | HeapType::ConcreteFunc(_) => {
@@ -187,7 +187,7 @@ impl Global {
                 Val::I64(i) => *definition.as_i64_mut() = i,
                 Val::F32(f) => *definition.as_u32_mut() = f,
                 Val::F64(f) => *definition.as_u64_mut() = f,
-                Val::V128(i) => *definition.as_u128_mut() = i.into(),
+                Val::V128(i) => definition.set_u128(i.into()),
                 Val::FuncRef(f) => {
                     *definition.as_func_ref_mut() = f.map_or(ptr::null_mut(), |f| {
                         f.vm_func_ref(&mut store).as_ptr().cast()

crates/wasmtime/src/runtime/trampoline/global.rs

@@ -34,7 +34,7 @@ pub fn generate_global_export(
             Val::I64(x) => *global.as_i64_mut() = x,
             Val::F32(x) => *global.as_f32_bits_mut() = x,
             Val::F64(x) => *global.as_f64_bits_mut() = x,
-            Val::V128(x) => *global.as_u128_mut() = x.into(),
+            Val::V128(x) => global.set_u128(x.into()),
             Val::FuncRef(f) => {
                 *global.as_func_ref_mut() =
                     f.map_or(ptr::null_mut(), |f| f.vm_func_ref(&mut store).as_ptr());

crates/wasmtime/src/runtime/vm/vmcontext.rs

@@ -447,7 +447,7 @@ impl VMGlobalDefinition {
             WasmValType::I64 => *global.as_i64_mut() = raw.get_i64(),
             WasmValType::F32 => *global.as_f32_bits_mut() = raw.get_f32(),
             WasmValType::F64 => *global.as_f64_bits_mut() = raw.get_f64(),
-            WasmValType::V128 => *global.as_u128_mut() = raw.get_v128(),
+            WasmValType::V128 => global.set_u128(raw.get_v128()),
             WasmValType::Ref(r) => match r.heap_type.top() {
                 WasmHeapTopType::Extern => {
                     let r = VMGcRef::from_raw_u32(raw.get_externref());
@@ -478,7 +478,7 @@ impl VMGlobalDefinition {
             WasmValType::I64 => ValRaw::i64(*self.as_i64()),
             WasmValType::F32 => ValRaw::f32(*self.as_f32_bits()),
             WasmValType::F64 => ValRaw::f64(*self.as_f64_bits()),
-            WasmValType::V128 => ValRaw::v128(*self.as_u128()),
+            WasmValType::V128 => ValRaw::v128(self.get_u128()),
             WasmValType::Ref(r) => match r.heap_type.top() {
                 WasmHeapTopType::Extern => ValRaw::externref(match self.as_gc_ref() {
                     Some(r) => store.gc_store_mut()?.clone_gc_ref(r).as_raw_u32(),
@@ -575,14 +575,20 @@ impl VMGlobalDefinition {
         &mut *(self.storage.as_mut().as_mut_ptr().cast::<u64>())
     }
 
-    /// Return a reference to the value as an u128.
-    pub unsafe fn as_u128(&self) -> &u128 {
-        &*(self.storage.as_ref().as_ptr().cast::<u128>())
+    /// Gets the underlying 128-bit vector value.
+    //
+    // Note that vectors are stored in little-endian format while other types
+    // are stored in native-endian format.
+    pub unsafe fn get_u128(&self) -> u128 {
+        u128::from_le(*(self.storage.as_ref().as_ptr().cast::<u128>()))
     }
 
-    /// Return a mutable reference to the value as an u128.
-    pub unsafe fn as_u128_mut(&mut self) -> &mut u128 {
-        &mut *(self.storage.as_mut().as_mut_ptr().cast::<u128>())
+    /// Sets the 128-bit vector values.
+    //
+    // Note that vectors are stored in little-endian format while other types
+    // are stored in native-endian format.
+    pub unsafe fn set_u128(&mut self, val: u128) {
+        *self.storage.as_mut().as_mut_ptr().cast::<u128>() = val.to_le();
     }
 
     /// Return a reference to the value as u128 bits.

crates/wast-util/src/lib.rs

@@ -427,10 +427,8 @@ impl WastTest {
                 "spec_testsuite/proposals/relaxed-simd/relaxed_min_max.wast",
                 "spec_testsuite/proposals/threads/atomic.wast",
                 "spec_testsuite/simd_align.wast",
-                "spec_testsuite/simd_bit_shift.wast",
                 "spec_testsuite/simd_bitwise.wast",
                 "spec_testsuite/simd_boolean.wast",
-                "spec_testsuite/simd_const.wast",
                 "spec_testsuite/simd_conversions.wast",
                 "spec_testsuite/simd_f32x4.wast",
                 "spec_testsuite/simd_f32x4_arith.wast",