Cranelift: Add instructions for getting the current stack/frame/return pointers

cranelift/codegen/src/isa/x64/encoding/rex.rs

@@ -298,20 +298,7 @@ pub(crate) fn emit_std_enc_mem(
 
     prefixes.emit(sink);
 
-    let mem_e = match mem_e.clone() {
-        Amode::RbpOffset { simm32, flags } => {
-            let base = regs::rbp();
-            Amode::ImmReg {
-                simm32,
-                base,
-                flags,
-            }
-        }
-        other => other,
-    };
-
-    match mem_e {
-        Amode::RbpOffset { .. } => unreachable!(),
+    match *mem_e {
         Amode::ImmReg { simm32, base, .. } => {
             // If this is an access based off of RSP, it may trap with a stack overflow if it's the
             // first touch of a new stack page.

cranelift/codegen/src/isa/x64/inst.isle

@@ -800,11 +800,7 @@
              ;; pointer). The appropriate relocation is emitted so
              ;; that the resulting immediate makes this Amode refer to
              ;; the given MachLabel.
-             (RipRelative (target MachLabel))
-
-             ;; Load `rbp + sign_extend(simm32)`.
-             (RbpOffset (simm32 u32)
-                        (flags MemFlags))))
+             (RipRelative (target MachLabel))))
 
 ;; Some Amode constructor helpers.
 

cranelift/codegen/src/isa/x64/inst/args.rs

@@ -313,14 +313,16 @@ impl Amode {
     ) {
         match self {
             Amode::ImmReg { base, .. } => {
-                collector.reg_use(*base);
+                if *base != regs::rbp() && *base != regs::rsp() {
+                    collector.reg_use(*base);
+                }
             }
             Amode::ImmRegRegShift { base, index, .. } => {
                 collector.reg_use(base.to_reg());
                 collector.reg_use(index.to_reg());
             }
-            Amode::RipRelative { .. } | Amode::RbpOffset { .. } => {
-                // RIP and RBP aren't involved in regalloc.
+            Amode::RipRelative { .. } => {
+                // RIP isn't involved in regalloc.
             }
         }
     }
@@ -338,17 +340,15 @@ impl Amode {
                 collector.reg_late_use(base.to_reg());
                 collector.reg_late_use(index.to_reg());
             }
-            Amode::RipRelative { .. } | Amode::RbpOffset { .. } => {
-                // RIP and RBP aren't involved in regalloc.
+            Amode::RipRelative { .. } => {
+                // RIP isn't involved in regalloc.
             }
         }
     }
 
     pub(crate) fn get_flags(&self) -> MemFlags {
         match self {
-            Amode::RbpOffset { flags, .. }
-            | Amode::ImmReg { flags, .. }
-            | Amode::ImmRegRegShift { flags, .. } => *flags,
+            Amode::ImmReg { flags, .. } | Amode::ImmRegRegShift { flags, .. } => *flags,
             Amode::RipRelative { .. } => MemFlags::trusted(),
         }
     }
@@ -384,7 +384,6 @@ impl Amode {
                 index: Gpr::new(allocs.next(*index)).unwrap(),
             },
             &Amode::RipRelative { target } => Amode::RipRelative { target },
-            &Amode::RbpOffset { simm32, flags } => Amode::RbpOffset { simm32, flags },
         }
     }
 
@@ -403,12 +402,6 @@ impl Amode {
 impl PrettyPrint for Amode {
     fn pretty_print(&self, _size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
         match self {
-            Amode::RbpOffset { simm32, flags } => Amode::ImmReg {
-                simm32: *simm32,
-                base: regs::rbp(),
-                flags: *flags,
-            }
-            .pretty_print(8, allocs),
             Amode::ImmReg { simm32, base, .. } => {
                 // Note: size is always 8; the address is 64 bits,
                 // even if the addressed operand is smaller.

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

@@ -2853,5 +2853,5 @@
 
 (rule (lower (get_return_address))
       (x64_load $I64
-                (Amode.RbpOffset 8 (mem_flags_trusted))
+                (Amode.ImmReg 8 (preg_rbp) (mem_flags_trusted))
                 (ExtKind.None)))