Fix remaining failures and re-enable x64 new backend CI

.github/workflows/main.yml

@@ -271,6 +271,32 @@ jobs:
  env:
  RUST_BACKTRACE: 1
 
+ # Perform all tests (debug mode) for `wasmtime` with the experimental x64
+ # backend. This runs on the nightly channel of Rust (because of issues with
+ # unifying Cargo features on stable) on Ubuntu.
+ test_x64:
+ name: Test x64 new backend
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - uses: ./.github/actions/install-rust
+ with:
+ toolchain: nightly-2020-08-25
+ - uses: ./.github/actions/define-llvm-env
+
+ # Install wasm32 targets in order to build various tests throughout the
+ # repo.
+ - run: rustup target add wasm32-wasi
+ - run: rustup target add wasm32-unknown-unknown
+
+ # Run the x64 CI script.
+ - run: ./ci/run-experimental-x64-ci.sh
+ env:
+ CARGO_VERSION: "+nightly-2020-08-25"
+ RUST_BACKTRACE: 1
+
  # Verify that cranelift's code generation is deterministic
  meta_determinist_check:
  name: Meta deterministic check

build.rs

@@ -182,6 +182,10 @@ fn experimental_x64_should_panic(testsuite: &str, testname: &str, strategy: &str
  match (testsuite, testname) {
  ("simd", "simd_address") => return false,
  ("simd", "simd_const") => return false,
+ ("simd", "simd_i8x16_arith") => return false,
+ ("simd", "simd_i16x8_arith") => return false,
+ ("simd", "simd_i32x4_arith") => return false,
+ ("simd", "simd_i64x2_arith") => return false,
  ("simd", "simd_f32x4_arith") => return false,
  ("simd", "simd_f32x4_cmp") => return false,
  ("simd", "simd_f64x2_arith") => return false,

ci/run-experimental-x64-ci.sh

@@ -1,6 +1,11 @@
 #!/bin/bash
 
-cargo +nightly \
+# Use the Nightly variant of the compiler to properly unify the
+# experimental_x64 feature across all crates. Once the feature has stabilized
+# and become the default, we can remove this.
+CARGO_VERSION=${CARGO_VERSION:-"+nightly"}
+
+cargo $CARGO_VERSION \
  -Zfeatures=all -Zpackage-features \
  test \
  --features test-programs/test_programs \
@@ -14,4 +19,5 @@ cargo +nightly \
  --exclude peepmatic-runtime \
  --exclude peepmatic-test \
  --exclude peepmatic-souper \
- --exclude lightbeam
+ --exclude lightbeam \
+ $@

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

@@ -195,65 +195,23 @@ impl ABIMachineSpec for X64ABIMachineSpec {
  }
 
  fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Self::I {
- let (is_int, ext_mode) = match ty {
- types::B1 | types::B8 | types::I8 => (true, Some(ExtMode::BQ)),
- types::B16 | types::I16 => (true, Some(ExtMode::WQ)),
- types::B32 | types::I32 => (true, Some(ExtMode::LQ)),
- types::B64 | types::I64 | types::R64 => (true, None),
- types::F32 | types::F64 => (false, None),
+ let ext_kind = match ty {
+ types::B1
+ | types::B8
+ | types::I8
+ | types::B16
+ | types::I16
+ | types::B32
+ | types::I32 => ExtKind::SignExtend,
+ types::B64 | types::I64 | types::R64 | types::F32 | types::F64 => ExtKind::None,
+ _ if ty.bytes() == 16 => ExtKind::None,
  _ => panic!("load_stack({})", ty),
  };
-
- let mem = SyntheticAmode::from(mem);
-
- if is_int {
- match ext_mode {
- Some(ext_mode) => Inst::movsx_rm_r(
- ext_mode,
- RegMem::mem(mem),
- into_reg,
- /* infallible load */ None,
- ),
- None => Inst::mov64_m_r(mem, into_reg, None /* infallible */),
- }
- } else {
- let sse_op = match ty {
- types::F32 => SseOpcode::Movss,
- types::F64 => SseOpcode::Movsd,
- _ => unreachable!(),
- };
- Inst::xmm_mov(
- sse_op,
- RegMem::mem(mem),
- into_reg,
- None, /* infallible */
- )
- }
+ Inst::load(ty, mem, into_reg, ext_kind, /* infallible */ None)
  }
 
  fn gen_store_stack(mem: StackAMode, from_reg: Reg, ty: Type) -> Self::I {
- let (is_int, size) = match ty {
- types::B1 | types::B8 | types::I8 => (true, 1),
- types::B16 | types::I16 => (true, 2),
- types::B32 | types::I32 => (true, 4),
- types::B64 | types::I64 | types::R64 => (true, 8),
- types::F32 => (false, 4),
- types::F64 => (false, 8),
- _ => unimplemented!("store_stack({})", ty),
- };
-
- let mem = SyntheticAmode::from(mem);
-
- if is_int {
- Inst::mov_r_m(size, from_reg, mem, /* infallible store */ None)
- } else {
- let sse_op = match size {
- 4 => SseOpcode::Movss,
- 8 => SseOpcode::Movsd,
- _ => unreachable!(),
- };
- Inst::xmm_mov_r_m(sse_op, from_reg, mem, /* infallible store */ None)
- }
+ Inst::store(ty, from_reg, mem, /* infallible */ None)
  }
 
  fn gen_move(to_reg: Writable<Reg>, from_reg: Reg, ty: Type) -> Self::I {

crates/runtime/src/libcalls.rs

@@ -88,12 +88,22 @@ pub extern "C" fn wasmtime_f32_trunc(x: f32) -> f32 {
 /// Implementation of f32.nearest
 #[allow(clippy::float_arithmetic, clippy::float_cmp)]
 pub extern "C" fn wasmtime_f32_nearest(x: f32) -> f32 {
- // Rust doesn't have a nearest function, so do it manually.
+ // Rust doesn't have a nearest function; there's nearbyint, but it's not
+ // stabilized, so do it manually.
  // Nearest is either ceil or floor depending on which is nearest or even.
  // This approach exploited round half to even default mode.
  let i = x.to_bits();
  let e = i >> 23 & 0xff;
  if e >= 0x7f_u32 + 23 {
+ // Check for NaNs.
+ if e == 0xff {
+ // Read the 23-bits significand.
+ if i & 0x7fffff != 0 {
+ // Ensure it's arithmetic by setting the significand's most
+ // significant bit to 1; it also works for canonical NaNs.
+ return f32::from_bits(i | (1 << 22));
+ }
+ }
  x
  } else {
  (x.abs() + TOINT_32 - TOINT_32).copysign(x)
@@ -153,12 +163,22 @@ pub extern "C" fn wasmtime_f64_trunc(x: f64) -> f64 {
 /// Implementation of f64.nearest
 #[allow(clippy::float_arithmetic, clippy::float_cmp)]
 pub extern "C" fn wasmtime_f64_nearest(x: f64) -> f64 {
- // Rust doesn't have a nearest function, so do it manually.
+ // Rust doesn't have a nearest function; there's nearbyint, but it's not
+ // stabilized, so do it manually.
  // Nearest is either ceil or floor depending on which is nearest or even.
  // This approach exploited round half to even default mode.
  let i = x.to_bits();
  let e = i >> 52 & 0x7ff;
  if e >= 0x3ff_u64 + 52 {
+ // Check for NaNs.
+ if e == 0x7ff {
+ // Read the 52-bits significand.
+ if i & 0xfffffffffffff != 0 {
+ // Ensure it's arithmetic by setting the significand's most
+ // significant bit to 1; it also works for canonical NaNs.
+ return f64::from_bits(i | (1 << 51));
+ }
+ }
  x
  } else {
  (x.abs() + TOINT_64 - TOINT_64).copysign(x)