add lucetc flag to select heap pinning

Author: iximeow

lucet-module/src/module_data.rs

@@ -59,6 +59,7 @@ pub struct ModuleFeatures {
     pub lzcnt: bool,
     pub popcnt: bool,
     pub instruction_count: bool,
+    pub pinned_heap: bool,
     _hidden: (),
 }
 
@@ -75,6 +76,7 @@ impl ModuleFeatures {
             lzcnt: false,
             popcnt: false,
             instruction_count: false,
+            pinned_heap: false,
             _hidden: (),
         }
     }

lucet-spectest/src/script.rs

@@ -74,6 +74,7 @@ impl ScriptEnv {
             true,
             &None,
             false,
+            false,
         )
         .map_err(program_error)?;
 

lucetc/lucetc/options.rs

@@ -453,6 +453,12 @@ SSE3 but not AVX:
                     .takes_value(false)
                     .help("Instrument the produced binary to count the number of wasm operations the translated program executes")
             )
+            .arg(
+                Arg::with_name("pinned_heap")
+                    .long("--pinned-heap-reg")
+                    .takes_value(false)
+                    .help("This feature is not stable - it may be removed in the future! Pin a register to use as this module's heap base. Typically improves performance.")
+            )
             .arg(
                 Arg::with_name("error_style")
                     .long("error-style")

lucetc/src/compiler.rs

@@ -56,6 +56,7 @@ pub struct Compiler<'a> {
     count_instructions: bool,
     module_translation_state: ModuleTranslationState,
     canonicalize_nans: bool,
+    pinned_heap: bool,
 }
 
 impl<'a> Compiler<'a> {
@@ -69,8 +70,9 @@ impl<'a> Compiler<'a> {
         count_instructions: bool,
         validator: &Option<Validator>,
         canonicalize_nans: bool,
+        pinned_heap: bool,
     ) -> Result<Self, Error> {
-        let isa = Self::target_isa(target.clone(), opt_level, &cpu_features, canonicalize_nans)?;
+        let isa = Self::target_isa(target.clone(), opt_level, &cpu_features, canonicalize_nans, pinned_heap)?;
 
         let frontend_config = isa.frontend_config();
         let mut module_info = ModuleInfo::new(frontend_config.clone());
@@ -127,12 +129,14 @@ impl<'a> Compiler<'a> {
             module_translation_state,
             target,
             canonicalize_nans,
+            pinned_heap,
         })
     }
 
     pub fn module_features(&self) -> ModuleFeatures {
         let mut mf: ModuleFeatures = (&self.cpu_features).into();
         mf.instruction_count = self.count_instructions;
+        mf.pinned_heap = self.pinned_heap;
         mf
     }
 
@@ -239,6 +243,7 @@ impl<'a> Compiler<'a> {
                 self.opt_level,
                 &self.cpu_features,
                 self.canonicalize_nans,
+                self.pinned_heap,
             )?,
         ))
     }
@@ -248,17 +253,20 @@ impl<'a> Compiler<'a> {
         opt_level: OptLevel,
         cpu_features: &CpuFeatures,
         canonicalize_nans: bool,
+        pinned_heap: bool,
     ) -> Result<Box<dyn TargetIsa>, Error> {
         let mut flags_builder = settings::builder();
         let isa_builder = cpu_features.isa_builder(target)?;
         flags_builder.enable("enable_verifier").unwrap();
         flags_builder.enable("is_pic").unwrap();
-        flags_builder.enable("enable_pinned_reg").unwrap();
-        flags_builder.enable("use_pinned_reg_as_heap_base").unwrap();
         flags_builder.set("opt_level", opt_level.to_flag()).unwrap();
         if canonicalize_nans {
             flags_builder.enable("enable_nan_canonicalization").unwrap();
         }
+        if pinned_heap {
+            flags_builder.enable("enable_pinned_reg").unwrap();
+            flags_builder.enable("use_pinned_reg_as_heap_base").unwrap();
+        }
         Ok(isa_builder.finish(settings::Flags::new(flags_builder)))
     }
 }

lucetc/src/lib.rs

@@ -55,6 +55,7 @@ pub struct Lucetc {
     verify: bool,
     count_instructions: bool,
     canonicalize_nans: bool,
+    pinned_heap: bool,
 }
 
 pub trait AsLucetc {
@@ -116,6 +117,8 @@ pub trait LucetcOpts {
     fn with_count_instructions(self, enable_count: bool) -> Self;
     fn canonicalize_nans(&mut self, enable_canonicalize_nans: bool);
     fn with_canonicalize_nans(self, enable_canonicalize_nans: bool) -> Self;
+    fn pinned_heap(&mut self, enable_pinned_heap: bool);
+    fn with_pinned_heap(self, enable_pinned_heap: bool) -> Self;
 }
 
 impl<T: AsLucetc> LucetcOpts for T {
@@ -265,6 +268,15 @@ impl<T: AsLucetc> LucetcOpts for T {
         self.canonicalize_nans(enable_nans_canonicalization);
         self
     }
+
+    fn pinned_heap(&mut self, enable_pinned_heap: bool) {
+        self.as_lucetc().pinned_heap = enable_pinned_heap;
+    }
+
+    fn with_pinned_heap(mut self, enable_pinned_heap: bool) -> Self {
+        self.pinned_heap(enable_pinned_heap);
+        self
+    }
 }
 
 impl Lucetc {
@@ -285,6 +297,7 @@ impl Lucetc {
             verify: false,
             count_instructions: false,
             canonicalize_nans: false,
+            pinned_heap: false,
         }
     }
 
@@ -305,6 +318,7 @@ impl Lucetc {
             verify: false,
             count_instructions: false,
             canonicalize_nans: false,
+            pinned_heap: false,
         })
     }
 
@@ -349,6 +363,7 @@ impl Lucetc {
             self.count_instructions,
             &self.validator,
             self.canonicalize_nans,
+            self.pinned_heap,
         )?;
         let obj = compiler.object_file()?;
         obj.write(output.as_ref())?;
@@ -369,6 +384,7 @@ impl Lucetc {
             self.count_instructions,
             &self.validator,
             self.canonicalize_nans,
+            self.pinned_heap,
         )?;
 
         compiler.cranelift_funcs()?.write(&output)?;