Add a compiler option to force jump veneers

Only intended to be used during testing/debugging. This also hooks up
the option to fuzzers.

Author: alexcrichton

cranelift/codegen/src/isa/aarch64/inst/emit.rs

@@ -25,10 +25,12 @@ pub fn memlabel_finalize(_insn_off: CodeOffset, label: &MemLabel) -> i32 {
 ///
 /// This generates:
 ///
-///     ldr  x16, 16
-///     adr  x17, 12
-///     add  x16, x16, x17
-///     br   x16
+/// ```ignore
+/// ldr  x16, 16
+/// adr  x17, 12
+/// add  x16, x16, x17
+/// br   x16
+/// ```
 ///
 /// and the expectation is that the 8-byte immediate address to jump to is
 /// located after these instructions are encoded.

crates/cranelift/src/builder.rs

@@ -13,11 +13,20 @@ use wasmtime_environ::{CompilerBuilder, Setting, SettingKind};
 struct Builder {
     flags: settings::Builder,
     isa_flags: isa::Builder,
+    linkopts: LinkOptions,
+}
 
-    // A debug-only setting used to synthetically insert 0-byte padding between
-    // compiled functions to simulate huge compiled artifacts and exercise logic
-    // related to jump veneers.
-    padding_between_functions: usize,
+#[derive(Clone, Default)]
+pub struct LinkOptions {
+    /// A debug-only setting used to synthetically insert 0-byte padding between
+    /// compiled functions to simulate huge compiled artifacts and exercise
+    /// logic related to jump veneers.
+    pub padding_between_functions: usize,
+
+    /// A debug-only setting used to force inter-function calls in a wasm module
+    /// to always go through "jump veneers" which are typically only generated
+    /// when functions are very far from each other.
+    pub force_jump_veneers: bool,
 }
 
 pub fn builder() -> Box<dyn CompilerBuilder> {
@@ -37,7 +46,7 @@ pub fn builder() -> Box<dyn CompilerBuilder> {
     Box::new(Builder {
         flags,
         isa_flags: cranelift_native::builder().expect("host machine is not a supported target"),
-        padding_between_functions: 0,
+        linkopts: LinkOptions::default(),
     })
 }
 
@@ -56,12 +65,17 @@ impl CompilerBuilder for Builder {
     }
 
     fn set(&mut self, name: &str, value: &str) -> Result<()> {
-        // Special wasmtime-cranelift-only setting.
-        if name == "padding_between_functions" {
-            self.padding_between_functions = value.parse()?;
+        // Special wasmtime-cranelift-only settings first
+        if name == "linkopt_padding_between_functions" {
+            self.linkopts.padding_between_functions = value.parse()?;
+            return Ok(());
+        }
+        if name == "linkopt_force_jump_veneer" {
+            self.linkopts.force_jump_veneers = value == "true";
             return Ok(());
         }
 
+        // ... then forward this to Cranelift
         if let Err(err) = self.flags.set(name, value) {
             match err {
                 SetError::BadName(_) => {
@@ -92,10 +106,7 @@ impl CompilerBuilder for Builder {
             .isa_flags
             .clone()
             .finish(settings::Flags::new(self.flags.clone()));
-        Box::new(crate::compiler::Compiler::new(
-            isa,
-            self.padding_between_functions,
-        ))
+        Box::new(crate::compiler::Compiler::new(isa, self.linkopts.clone()))
     }
 
     fn settings(&self) -> Vec<Setting> {

crates/cranelift/src/compiler.rs

@@ -1,3 +1,4 @@
+use crate::builder::LinkOptions;
 use crate::debug::ModuleMemoryOffset;
 use crate::func_environ::{get_func_name, FuncEnvironment};
 use crate::obj::ObjectBuilder;
@@ -36,15 +37,15 @@ use wasmtime_environ::{
 pub(crate) struct Compiler {
     translators: Mutex<Vec<FuncTranslator>>,
     isa: Box<dyn TargetIsa>,
-    padding_between_functions: usize,
+    linkopts: LinkOptions,
 }
 
 impl Compiler {
-    pub(crate) fn new(isa: Box<dyn TargetIsa>, padding_between_functions: usize) -> Compiler {
+    pub(crate) fn new(isa: Box<dyn TargetIsa>, linkopts: LinkOptions) -> Compiler {
         Compiler {
             translators: Default::default(),
             isa,
-            padding_between_functions,
+            linkopts,
         }
     }
 
@@ -254,11 +255,12 @@ impl wasmtime_environ::Compiler for Compiler {
         }
 
         let mut builder = ObjectBuilder::new(obj, &translation.module, &*self.isa);
+        builder.force_jump_veneers = self.linkopts.force_jump_veneers;
 
         for ((i, func), (_, body)) in funcs.iter().zip(bodies) {
             builder.func(i, func, body);
-            if self.padding_between_functions > 0 {
-                builder.append_synthetic_padding(self.padding_between_functions);
+            if self.linkopts.padding_between_functions > 0 {
+                builder.append_synthetic_padding(self.linkopts.padding_between_functions);
             }
         }
         for (i, (body, func)) in trampolines.iter_mut() {

crates/cranelift/src/obj.rs

@@ -162,6 +162,10 @@ pub struct ObjectBuilder<'a> {
     /// call instruction. These relocations will get filled in at the end
     /// with relative offsets to their target.
     relative_relocs: Vec<RelativeReloc>,
+
+    /// A debug-only option to indicate that all inter-function calls should go
+    /// through veneers, ideally testing the veneer emission code.
+    pub force_jump_veneers: bool,
 }
 
 /// A pending relocation against a wasm-defined function that needs to be
@@ -255,6 +259,7 @@ impl<'a> ObjectBuilder<'a> {
             current_text_off: 0,
             text_locations: HashMap::new(),
             relative_relocs: Vec::new(),
+            force_jump_veneers: false,
         }
     }
 
@@ -475,7 +480,7 @@ impl<'a> ObjectBuilder<'a> {
                     // added for a symbol but the symbol was defined very long
                     // ago. The only way to reach the symbol at this point
                     // is via a veneer.
-                    if distance < min_neg {
+                    if distance < min_neg || self.force_jump_veneers {
                         self.emit_jump_veneer(r);
 
                     // This case, if hit, represents a programming error. If

crates/fuzzing/src/generators.rs

@@ -20,6 +20,7 @@ use arbitrary::{Arbitrary, Unstructured};
 pub struct DifferentialConfig {
     strategy: DifferentialStrategy,
     opt_level: OptLevel,
+    force_jump_veneers: bool,
 }
 
 impl DifferentialConfig {
@@ -30,6 +31,11 @@ impl DifferentialConfig {
             DifferentialStrategy::Lightbeam => wasmtime::Strategy::Lightbeam,
         })?;
         config.cranelift_opt_level(self.opt_level.to_wasmtime());
+        if self.force_jump_veneers {
+            unsafe {
+                config.cranelift_flag_set("linkopt_force_jump_veneer", "true")?;
+            }
+        }
         Ok(config)
     }
 }

tests/all/relocs.rs

@@ -14,7 +14,7 @@ fn store_with_padding(padding: usize) -> Result<Store<()>> {
     // This is an internal debug-only setting specifically recognized for
     // basically just this set of tests.
     unsafe {
-        config.cranelift_flag_set("padding_between_functions", &padding.to_string())?;
+        config.cranelift_flag_set("linkopt_padding_between_functions", &padding.to_string())?;
     }
     let engine = Engine::new(&config)?;
     Ok(Store::new(&engine, ()))
@@ -64,8 +64,20 @@ fn backwards_call_works() -> Result<()> {
 
 #[test]
 fn mixed() -> Result<()> {
-    let mut store = store_with_padding(MB)?;
+    test_many_call_module(store_with_padding(MB)?)
+}
+
+#[test]
+fn mixed_forced() -> Result<()> {
+    let mut config = Config::new();
+    unsafe {
+        config.cranelift_flag_set("linkopt_force_jump_veneer", &padding.to_string())?;
+    }
+    let engine = Engine::new(&config)?;
+    test_many_call_module(Store::new(&engine, ()))
+}
 
+fn test_many_call_module(store: Store<()>) -> Result<()> {
     const N: i32 = 200;
 
     let mut wat = String::new();
@@ -96,24 +108,3 @@ fn mixed() -> Result<()> {
     }
     Ok(())
 }
-
-#[test]
-fn forward_huge() -> Result<()> {
-    let mut store = store_with_padding(2 * GB)?;
-    let module = Module::new(
-        store.engine(),
-        r#"
-            (module
-                (func (export "foo") (result i32)
-                    call 1)
-                (func (result i32)
-                    i32.const 4)
-            )
-        "#,
-    )?;
-
-    let i = Instance::new(&mut store, &module, &[])?;
-    let foo = i.get_typed_func::<(), i32, _>(&mut store, "foo")?;
-    assert_eq!(foo.call(&mut store, ())?, 4);
-    Ok(())
-}