cranelift: add support for the Mac aarch64 calling convention

This bumps target-lexicon and adds support for the AppleAarch64 calling
convention. Specifically for WebAssembly support, we only have to worry
about the new stack slots convention. Stack slots don't need to be at
least 8-bytes, they can be as small as the data type's size. For
instance, if we need stack slots for (i32, i32), they can be located at
offsets (+0, +4). Note that they still need to be properly aligned on
the data type they're containing, though, so if we need stack slots for
(i32, i64), we can't start the i64 slot at the +4 offset (it must start
at the +8 offset).

Added one test that was failing on the Mac M1, as well as other tests
stressing different yet similar situations.

cranelift/codegen/meta/src/shared/settings.rs

@@ -192,6 +192,7 @@ pub(crate) fn define() -> SettingGroup {
             "cold",
             "system_v",
             "windows_fastcall",
+            "apple_aarch64",
             "baldrdash_system_v",
             "baldrdash_windows",
             "baldrdash_2020",

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

@@ -171,6 +171,9 @@ impl ABIMachineSpec for AArch64MachineDeps {
         let has_baldrdash_tls = call_conv == isa::CallConv::Baldrdash2020;
 
         // See AArch64 ABI (https://c9x.me/compile/bib/abi-arm64.pdf), sections 5.4.
+        // MacOS aarch64 is slightly different, see also
+        // https://developer.apple.com/documentation/xcode/writing_arm64_code_for_apple_platforms.
+
         let mut next_xreg = 0;
         let mut next_vreg = 0;
         let mut next_stack: u64 = 0;
@@ -264,13 +267,24 @@ impl ABIMachineSpec for AArch64MachineDeps {
                 *next_reg += 1;
                 remaining_reg_vals -= 1;
             } else {
-                // Compute size. Every arg takes a minimum slot of 8 bytes. (16-byte
-                // stack alignment happens separately after all args.)
+                // Compute the stack slot's size.
                 let size = (ty_bits(param.value_type) / 8) as u64;
-                let size = std::cmp::max(size, 8);
-                // Align.
+
+                let size = if call_conv != isa::CallConv::AppleAarch64 {
+                    // Every arg takes a minimum slot of 8 bytes. (16-byte stack
+                    // alignment happens separately after all args.)
+                    std::cmp::max(size, 8)
+                } else {
+                    // MacOS aarch64 allows stack slots with sizes less than 8
+                    // bytes. They still need to be properly aligned on their
+                    // natural data alignment, though.
+                    size
+                };
+
+                // Align the stack slot.
                 debug_assert!(size.is_power_of_two());
                 next_stack = align_to(next_stack, size);
+
                 ret.push(ABIArg::stack(
                     next_stack as i64,
                     param.value_type,

cranelift/codegen/src/isa/call_conv.rs

@@ -10,22 +10,24 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum CallConv {
-    /// Best performance, not ABI-stable
+    /// Best performance, not ABI-stable.
     Fast,
-    /// Smallest caller code size, not ABI-stable
+    /// Smallest caller code size, not ABI-stable.
     Cold,
-    /// System V-style convention used on many platforms
+    /// System V-style convention used on many platforms.
     SystemV,
-    /// Windows "fastcall" convention, also used for x64 and ARM
+    /// Windows "fastcall" convention, also used for x64 and ARM.
     WindowsFastcall,
-    /// SpiderMonkey WebAssembly convention on systems using natively SystemV
+    /// Mac aarch64 calling convention, which is a tweak aarch64 ABI.
+    AppleAarch64,
+    /// SpiderMonkey WebAssembly convention on systems using natively SystemV.
     BaldrdashSystemV,
-    /// SpiderMonkey WebAssembly convention on Windows
+    /// SpiderMonkey WebAssembly convention on Windows.
     BaldrdashWindows,
     /// SpiderMonkey WebAssembly convention for "ABI-2020", with extra TLS
     /// register slots in the frame.
     Baldrdash2020,
-    /// Specialized convention for the probestack function
+    /// Specialized convention for the probestack function.
     Probestack,
 }
 
@@ -36,6 +38,7 @@ impl CallConv {
             // Default to System V for unknown targets because most everything
             // uses System V.
             Ok(CallingConvention::SystemV) | Err(()) => Self::SystemV,
+            Ok(CallingConvention::AppleAarch64) => Self::AppleAarch64,
             Ok(CallingConvention::WindowsFastcall) => Self::WindowsFastcall,
             Ok(unimp) => unimplemented!("calling convention: {:?}", unimp),
         }
@@ -49,6 +52,7 @@ impl CallConv {
             LibcallCallConv::Cold => Self::Cold,
             LibcallCallConv::SystemV => Self::SystemV,
             LibcallCallConv::WindowsFastcall => Self::WindowsFastcall,
+            LibcallCallConv::AppleAarch64 => Self::AppleAarch64,
             LibcallCallConv::BaldrdashSystemV => Self::BaldrdashSystemV,
             LibcallCallConv::BaldrdashWindows => Self::BaldrdashWindows,
             LibcallCallConv::Baldrdash2020 => Self::Baldrdash2020,
@@ -80,6 +84,7 @@ impl fmt::Display for CallConv {
             Self::Cold => "cold",
             Self::SystemV => "system_v",
             Self::WindowsFastcall => "windows_fastcall",
+            Self::AppleAarch64 => "mac_aarch64",
             Self::BaldrdashSystemV => "baldrdash_system_v",
             Self::BaldrdashWindows => "baldrdash_windows",
             Self::Baldrdash2020 => "baldrdash_2020",
@@ -96,6 +101,7 @@ impl str::FromStr for CallConv {
             "cold" => Ok(Self::Cold),
             "system_v" => Ok(Self::SystemV),
             "windows_fastcall" => Ok(Self::WindowsFastcall),
+            "mac_aarch64" => Ok(Self::AppleAarch64),
             "baldrdash_system_v" => Ok(Self::BaldrdashSystemV),
             "baldrdash_windows" => Ok(Self::BaldrdashWindows),
             "baldrdash_2020" => Ok(Self::Baldrdash2020),

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

@@ -907,6 +907,7 @@ fn get_intreg_for_retval(
             _ => None,
         },
         CallConv::BaldrdashWindows | CallConv::Probestack => todo!(),
+        CallConv::AppleAarch64 => unreachable!(),
     }
 }
 
@@ -933,6 +934,7 @@ fn get_fltreg_for_retval(
             _ => None,
         },
         CallConv::BaldrdashWindows | CallConv::Probestack => todo!(),
+        CallConv::AppleAarch64 => unreachable!(),
     }
 }
 
@@ -1001,6 +1003,7 @@ fn get_callee_saves(call_conv: &CallConv, regs: &Set<Writable<RealReg>>) -> Vec<
             .filter(|r| is_callee_save_fastcall(r.to_reg()))
             .collect(),
         CallConv::Probestack => todo!("probestack?"),
+        CallConv::AppleAarch64 => unreachable!(),
     };
     // Sort registers for deterministic code output. We can do an unstable sort because the
     // registers will be unique (there are no dups).

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

@@ -512,6 +512,7 @@ pub fn prologue_epilogue(func: &mut ir::Function, isa: &dyn TargetIsa) -> Codege
         }
         CallConv::Probestack => unimplemented!("probestack calling convention"),
         CallConv::Baldrdash2020 => unimplemented!("Baldrdash ABI 2020"),
+        CallConv::AppleAarch64 => unreachable!(),
     }
 }
 

cranelift/codegen/src/machinst/abi_impl.rs

@@ -646,7 +646,8 @@ impl<M: ABIMachineSpec> ABICalleeImpl<M> {
                 || call_conv == isa::CallConv::Fast
                 || call_conv == isa::CallConv::Cold
                 || call_conv.extends_baldrdash()
-                || call_conv.extends_windows_fastcall(),
+                || call_conv.extends_windows_fastcall()
+                || call_conv == isa::CallConv::AppleAarch64,
             "Unsupported calling convention: {:?}",
             call_conv
         );

tests/all/func.rs

@@ -121,9 +121,6 @@ fn signatures_match() {
 }
 
 #[test]
-// Note: Cranelift only supports refrerence types (used in the wasm in this
-// test) on x64.
-#[cfg(target_arch = "x86_64")]
 fn import_works() -> Result<()> {
     static HITS: AtomicUsize = AtomicUsize::new(0);
 

tests/all/host_funcs.rs

@@ -219,9 +219,6 @@ fn signatures_match() -> Result<()> {
 }
 
 #[test]
-// Note: Cranelift only supports refrerence types (used in the wasm in this
-// test) on x64.
-#[cfg(target_arch = "x86_64")]
 fn import_works() -> Result<()> {
     static HITS: AtomicUsize = AtomicUsize::new(0);
 
@@ -328,6 +325,137 @@ fn import_works() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn call_import_many_args() -> Result<()> {
+    let wasm = wat::parse_str(
+        r#"
+            (import "" "host" (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32)))
+            (func (export "run")
+                i32.const 1
+                i32.const 2
+                i32.const 3
+                i32.const 4
+                i32.const 5
+                i32.const 6
+                i32.const 7
+                i32.const 8
+                i32.const 9
+                i32.const 10
+                call 0
+            )
+        "#,
+    )?;
+
+    let mut config = Config::new();
+
+    config.wrap_host_func(
+        "",
+        "host",
+        |x1: i32,
+         x2: i32,
+         x3: i32,
+         x4: i32,
+         x5: i32,
+         x6: i32,
+         x7: i32,
+         x8: i32,
+         x9: i32,
+         x10: i32| {
+            assert_eq!(x1, 1);
+            assert_eq!(x2, 2);
+            assert_eq!(x3, 3);
+            assert_eq!(x4, 4);
+            assert_eq!(x5, 5);
+            assert_eq!(x6, 6);
+            assert_eq!(x7, 7);
+            assert_eq!(x8, 8);
+            assert_eq!(x9, 9);
+            assert_eq!(x10, 10);
+        },
+    );
+
+    let engine = Engine::new(&config)?;
+    let module = Module::new(&engine, &wasm)?;
+
+    let store = Store::new(&engine);
+    let instance = Instance::new(
+        &store,
+        &module,
+        &[store
+            .get_host_func("", "host")
+            .expect("should be defined")
+            .into()],
+    )?;
+
+    let run = instance.get_func("run").unwrap();
+    run.call(&[])?;
+
+    Ok(())
+}
+
+#[test]
+fn call_wasm_many_args() -> Result<()> {
+    let wasm = wat::parse_str(
+        r#"
+            (func (export "run") (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32)
+                i32.const 1
+                get_local 0
+                i32.ne
+                if
+                    unreachable
+                end
+
+                i32.const 10
+                get_local 9
+                i32.ne
+                if
+                    unreachable
+                end
+            )
+
+            (func (export "test")
+                i32.const 1
+                i32.const 2
+                i32.const 3
+                i32.const 4
+                i32.const 5
+                i32.const 6
+                i32.const 7
+                i32.const 8
+                i32.const 9
+                i32.const 10
+                call 0
+            )
+        "#,
+    )?;
+
+    let config = Config::new();
+    let engine = Engine::new(&config)?;
+    let module = Module::new(&engine, &wasm)?;
+
+    let store = Store::new(&engine);
+    let instance = Instance::new(&store, &module, &[])?;
+
+    let run = instance.get_func("run").unwrap();
+    run.call(&[
+        1.into(),
+        2.into(),
+        3.into(),
+        4.into(),
+        5.into(),
+        6.into(),
+        7.into(),
+        8.into(),
+        9.into(),
+        10.into(),
+    ])?;
+
+    let test = instance.get_func("test").unwrap();
+    test.call(&[])?;
+
+    Ok(())
+}
+
 #[test]
 fn trap_smoke() -> Result<()> {
     let mut config = Config::default();