pulley: Implement support for symbol_value (#11576)

This commit fills out the Pulley lowerings of the `symbol_value` and
`func_addr` CLIF instructions. Additionally handling of relocations on
Pulley is improved to be more "formal" as opposed to just blindly using
an x64 relocation and assuming it works out. The intention here is to
make Pulley behave more similarly to other platforms in all these
respects while also enabling usage of Wasmtime to eventually use
`symbol_addr` to calculate an address relative to the current PC
(similar to x64).

This includes Cranelift golden tests as well as more filetests being
run, but the actual integration into Wasmtime will be deferred to a
future commit.

Author: alexcrichton

cranelift/codegen/src/binemit/mod.rs

@@ -125,6 +125,9 @@ pub enum Reloc {
     /// s390x TLS GDCall - marker to enable optimization of TLS calls
     S390xTlsGdCall,
 
+    /// Pulley - a relocation which is a pc-relative offset.
+    PulleyPcRel,
+
     /// Pulley - call a host function indirectly where the embedder resolving
     /// this relocation needs to fill the 8-bit immediate that's part of the
     /// `call_indirect_host` opcode (an opaque identifier used by the host).
@@ -164,6 +167,7 @@ impl fmt::Display for Reloc {
             Self::Aarch64AddAbsLo12Nc => write!(f, "Aarch64AddAbsLo12Nc"),
             Self::S390xTlsGd64 => write!(f, "TlsGd64"),
             Self::S390xTlsGdCall => write!(f, "TlsGdCall"),
+            Self::PulleyPcRel => write!(f, "PulleyPcRel"),
             Self::PulleyCallIndirectHost => write!(f, "PulleyCallIndirectHost"),
         }
     }

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

@@ -42,9 +42,8 @@
       (reg XReg))
 
     ;; Load an external symbol's address into a register.
-    (LoadExtName (dst WritableXReg)
-                 (name BoxExternalName)
-                 (offset i64))
+    (LoadExtNameNear (dst WritableXReg) (name BoxExternalName) (offset i64))
+    (LoadExtNameFar (dst WritableXReg) (name BoxExternalName) (offset i64))
 
     ;; A direct call to a known callee.
     (Call (info BoxCallInfo))
@@ -154,6 +153,7 @@
 (convert RawInst MInst raw_inst_to_inst)
 
 (type U6 (primitive U6))
+(type PcRelOffset (primitive PcRelOffset))
 (type BoxCallInfo (primitive BoxCallInfo))
 (type BoxCallIndInfo (primitive BoxCallIndInfo))
 (type BoxReturnCallInfo (primitive BoxReturnCallInfo))
@@ -689,6 +689,27 @@
 (rule (gen_br_table idx default labels)
       (emit (MInst.BrTable idx default labels)))
 
+;; Helper for creating `MInst.LoadExtNameNear` instructions.
+(decl load_ext_name_near (BoxExternalName i64) XReg)
+(rule (load_ext_name_near name offset)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.LoadExtNameNear dst name offset))))
+        dst))
+
+;; Helper for creating `MInst.LoadExtNameFar` instructions.
+(decl load_ext_name_far (BoxExternalName i64) XReg)
+(rule (load_ext_name_far name offset)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.LoadExtNameFar dst name offset))))
+        dst))
+
+;; Helper for creating `MInst.LoadExtName*` instructions.
+(decl load_ext_name (BoxExternalName i64 RelocDistance) XReg)
+(rule 1 (load_ext_name name offset (RelocDistance.Near))
+  (load_ext_name_near name offset))
+(rule 0 (load_ext_name name offset (RelocDistance.Far))
+  (load_ext_name_far name offset))
+
 ;;;; Helpers for Emitting Calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (decl gen_call_info (Sig ExternalName CallArgList CallRetList OptionTryCallInfo) BoxCallInfo)

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

@@ -289,103 +289,103 @@ impl Cond {
     ///
     /// Note that the offset encoded to jump by is filled in as 0 and it's
     /// assumed `MachBuffer` will come back and clean it up.
-    pub fn encode(&self, sink: &mut impl Extend<u8>) {
+    pub fn encode(&self, sink: &mut impl Extend<u8>, rel: i32) {
         match *self {
-            Cond::If32 { reg } => encode::br_if32(sink, reg, 0),
-            Cond::IfNot32 { reg } => encode::br_if_not32(sink, reg, 0),
-            Cond::IfXeq32 { src1, src2 } => encode::br_if_xeq32(sink, src1, src2, 0),
-            Cond::IfXneq32 { src1, src2 } => encode::br_if_xneq32(sink, src1, src2, 0),
-            Cond::IfXslt32 { src1, src2 } => encode::br_if_xslt32(sink, src1, src2, 0),
-            Cond::IfXslteq32 { src1, src2 } => encode::br_if_xslteq32(sink, src1, src2, 0),
-            Cond::IfXult32 { src1, src2 } => encode::br_if_xult32(sink, src1, src2, 0),
-            Cond::IfXulteq32 { src1, src2 } => encode::br_if_xulteq32(sink, src1, src2, 0),
-            Cond::IfXeq64 { src1, src2 } => encode::br_if_xeq64(sink, src1, src2, 0),
-            Cond::IfXneq64 { src1, src2 } => encode::br_if_xneq64(sink, src1, src2, 0),
-            Cond::IfXslt64 { src1, src2 } => encode::br_if_xslt64(sink, src1, src2, 0),
-            Cond::IfXslteq64 { src1, src2 } => encode::br_if_xslteq64(sink, src1, src2, 0),
-            Cond::IfXult64 { src1, src2 } => encode::br_if_xult64(sink, src1, src2, 0),
-            Cond::IfXulteq64 { src1, src2 } => encode::br_if_xulteq64(sink, src1, src2, 0),
+            Cond::If32 { reg } => encode::br_if32(sink, reg, rel),
+            Cond::IfNot32 { reg } => encode::br_if_not32(sink, reg, rel),
+            Cond::IfXeq32 { src1, src2 } => encode::br_if_xeq32(sink, src1, src2, rel),
+            Cond::IfXneq32 { src1, src2 } => encode::br_if_xneq32(sink, src1, src2, rel),
+            Cond::IfXslt32 { src1, src2 } => encode::br_if_xslt32(sink, src1, src2, rel),
+            Cond::IfXslteq32 { src1, src2 } => encode::br_if_xslteq32(sink, src1, src2, rel),
+            Cond::IfXult32 { src1, src2 } => encode::br_if_xult32(sink, src1, src2, rel),
+            Cond::IfXulteq32 { src1, src2 } => encode::br_if_xulteq32(sink, src1, src2, rel),
+            Cond::IfXeq64 { src1, src2 } => encode::br_if_xeq64(sink, src1, src2, rel),
+            Cond::IfXneq64 { src1, src2 } => encode::br_if_xneq64(sink, src1, src2, rel),
+            Cond::IfXslt64 { src1, src2 } => encode::br_if_xslt64(sink, src1, src2, rel),
+            Cond::IfXslteq64 { src1, src2 } => encode::br_if_xslteq64(sink, src1, src2, rel),
+            Cond::IfXult64 { src1, src2 } => encode::br_if_xult64(sink, src1, src2, rel),
+            Cond::IfXulteq64 { src1, src2 } => encode::br_if_xulteq64(sink, src1, src2, rel),
 
             Cond::IfXeq32I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xeq32_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xeq32_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xeq32_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xeq32_i32(sink, src1, src2, rel),
             },
             Cond::IfXneq32I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xneq32_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xneq32_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xneq32_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xneq32_i32(sink, src1, src2, rel),
             },
             Cond::IfXslt32I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xslt32_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xslt32_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xslt32_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xslt32_i32(sink, src1, src2, rel),
             },
             Cond::IfXslteq32I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xslteq32_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xslteq32_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xslteq32_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xslteq32_i32(sink, src1, src2, rel),
             },
             Cond::IfXsgt32I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xsgt32_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xsgt32_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xsgt32_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xsgt32_i32(sink, src1, src2, rel),
             },
             Cond::IfXsgteq32I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xsgteq32_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xsgteq32_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xsgteq32_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xsgteq32_i32(sink, src1, src2, rel),
             },
             Cond::IfXult32I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xult32_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xult32_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xult32_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xult32_u32(sink, src1, src2, rel),
             },
             Cond::IfXulteq32I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xulteq32_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xulteq32_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xulteq32_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xulteq32_u32(sink, src1, src2, rel),
             },
             Cond::IfXugt32I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xugt32_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xugt32_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xugt32_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xugt32_u32(sink, src1, src2, rel),
             },
             Cond::IfXugteq32I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xugteq32_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xugteq32_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xugteq32_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xugteq32_u32(sink, src1, src2, rel),
             },
 
             Cond::IfXeq64I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xeq64_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xeq64_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xeq64_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xeq64_i32(sink, src1, src2, rel),
             },
             Cond::IfXneq64I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xneq64_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xneq64_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xneq64_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xneq64_i32(sink, src1, src2, rel),
             },
             Cond::IfXslt64I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xslt64_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xslt64_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xslt64_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xslt64_i32(sink, src1, src2, rel),
             },
             Cond::IfXslteq64I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xslteq64_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xslteq64_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xslteq64_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xslteq64_i32(sink, src1, src2, rel),
             },
             Cond::IfXsgt64I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xsgt64_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xsgt64_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xsgt64_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xsgt64_i32(sink, src1, src2, rel),
             },
             Cond::IfXsgteq64I32 { src1, src2 } => match i8::try_from(src2) {
-                Ok(src2) => encode::br_if_xsgteq64_i8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xsgteq64_i32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xsgteq64_i8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xsgteq64_i32(sink, src1, src2, rel),
             },
             Cond::IfXult64I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xult64_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xult64_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xult64_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xult64_u32(sink, src1, src2, rel),
             },
             Cond::IfXulteq64I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xulteq64_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xulteq64_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xulteq64_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xulteq64_u32(sink, src1, src2, rel),
             },
             Cond::IfXugt64I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xugt64_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xugt64_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xugt64_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xugt64_u32(sink, src1, src2, rel),
             },
             Cond::IfXugteq64I32 { src1, src2 } => match u8::try_from(src2) {
-                Ok(src2) => encode::br_if_xugteq64_u8(sink, src1, src2, 0),
-                Err(_) => encode::br_if_xugteq64_u32(sink, src1, src2, 0),
+                Ok(src2) => encode::br_if_xugteq64_u8(sink, src1, src2, rel),
+                Err(_) => encode::br_if_xugteq64_u32(sink, src1, src2, rel),
             },
         }
     }