feat(llvm): Pass global #0 and memory #0 as parameters between guest functions

lib/api/src/backend/js/entities/engine.rs

@@ -5,9 +5,9 @@ use wasmer_types::{target::Target, Features};
 pub struct Engine;
 
 impl Engine {
-    pub(crate) fn deterministic_id(&self) -> &str {
+    pub(crate) fn deterministic_id(&self) -> String {
         // All js engines have the same id
-        "js-generic"
+        String::from("js-generic")
     }
 
     /// Returns the WebAssembly features supported by the JS engine.

lib/api/src/backend/jsc/entities/engine.rs

@@ -166,9 +166,9 @@ impl JSCEngine {
 }
 
 impl Engine {
-    pub(crate) fn deterministic_id(&self) -> &str {
+    pub(crate) fn deterministic_id(&self) -> String {
         // All js engines have the same id
-        "javascriptcore"
+        String::from("javascriptcore")
     }
 
     /// Returns the WebAssembly features supported by the JSC engine for the given target.

lib/api/src/backend/v8/entities/engine.rs

@@ -50,8 +50,8 @@ impl Engine {
         Self::default()
     }
 
-    pub(crate) fn deterministic_id(&self) -> &str {
-        "v8"
+    pub(crate) fn deterministic_id(&self) -> String {
+        String::from("v8")
     }
 
     /// Returns the WebAssembly features supported by the V8 engine.

lib/api/src/backend/wamr/entities/engine.rs

@@ -36,8 +36,8 @@ impl Engine {
         Self::default()
     }
 
-    pub(crate) fn deterministic_id(&self) -> &str {
-        "wamr"
+    pub(crate) fn deterministic_id(&self) -> String {
+        String::from("wamr")
     }
 
     /// Returns the WebAssembly features supported by the WAMR engine.

lib/api/src/backend/wasmi/entities/engine.rs

@@ -36,8 +36,8 @@ impl Engine {
         Self::default()
     }
 
-    pub(crate) fn deterministic_id(&self) -> &str {
-        "wasmi"
+    pub(crate) fn deterministic_id(&self) -> String {
+        String::from("wasmi")
     }
 
     /// Returns the WebAssembly features supported by the WASMI engine.

lib/api/src/entities/engine/inner.rs

@@ -17,7 +17,7 @@ gen_rt_ty!(Engine @derives Debug, Clone);
 impl BackendEngine {
     /// Returns the deterministic id of this engine.
     #[inline]
-    pub fn deterministic_id(&self) -> &str {
+    pub fn deterministic_id(&self) -> String {
         match_rt!(on self  => s {
             s.deterministic_id()
         })

lib/api/src/entities/engine/mod.rs

@@ -2,7 +2,10 @@
 
 use bytes::Bytes;
 use std::{path::Path, sync::Arc};
-use wasmer_types::{target::Target, DeserializeError, Features};
+use wasmer_types::{
+    target::{Target, UserCompilerOptimizations},
+    CompileError, DeserializeError, Features,
+};
 
 #[cfg(feature = "sys")]
 use wasmer_compiler::Artifact;
@@ -51,7 +54,7 @@ impl Engine {
     }
 
     /// Returns the deterministic id of this engine.
-    pub fn deterministic_id(&self) -> &str {
+    pub fn deterministic_id(&self) -> String {
         self.be.deterministic_id()
     }
 
@@ -223,4 +226,22 @@ impl Engine {
     ) -> Result<Arc<Artifact>, DeserializeError> {
         self.be.deserialize_from_file_unchecked(file_ref)
     }
+
+    /// Add suggested optimizations to this engine.
+    ///
+    /// # Note
+    ///
+    /// Not every backend supports every optimization. This function may fail (i.e. not set the
+    /// suggested optimizations) silently if the underlying engine backend does not support one or
+    /// more optimizations.
+    pub fn with_opts(
+        &mut self,
+        suggested_opts: &UserCompilerOptimizations,
+    ) -> Result<(), CompileError> {
+        match self.be {
+            #[cfg(feature = "sys")]
+            BackendEngine::Sys(ref mut e) => e.with_opts(suggested_opts),
+            _ => Ok(()),
+        }
+    }
 }

lib/cli/src/backend.rs

@@ -6,9 +6,9 @@
 // module.
 #![allow(dead_code, unused_imports, unused_variables)]
 
-use std::path::PathBuf;
 use std::string::ToString;
 use std::sync::Arc;
+use std::{path::PathBuf, str::FromStr};
 
 use anyhow::{bail, Result};
 #[cfg(feature = "sys")]
@@ -187,16 +187,44 @@ pub struct RuntimeOptions {
     #[clap(long)]
     enable_verifier: bool,
 
+    /// Enable a profiler.
+    ///
+    /// Available for cranelift, LLVM and singlepass.
+    #[clap(long, value_enum)]
+    profiler: Option<Profiler>,
+
     /// LLVM debug directory, where IR and object files will be written to.
     ///
     /// Only available for the LLVM compiler.
     #[clap(long)]
     llvm_debug_dir: Option<PathBuf>,
 
+    /// Only available for the LLVM compiler. Enable the "pass-params" optimization, where the first (#0)
+    /// global and the first (#0) memory passed between guest functions as explicit parameters.
+    #[clap(long)]
+    enable_pass_params_opt: bool,
+
     #[clap(flatten)]
     features: WasmFeatures,
 }
 
+#[derive(Clone, Debug)]
+pub enum Profiler {
+    /// Perfmap-based profilers.
+    Perfmap,
+}
+
+impl FromStr for Profiler {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "perfmap" => Ok(Self::Perfmap),
+            _ => Err(anyhow::anyhow!("Unrecognized profiler: {s}")),
+        }
+    }
+}
+
 impl RuntimeOptions {
     pub fn get_available_backends(&self) -> Result<Vec<BackendType>> {
         // If a specific backend is explicitly requested, use it
@@ -267,7 +295,7 @@ impl RuntimeOptions {
         let backend = backends.first().unwrap();
         let backend_kind = wasmer::BackendKind::from(backend);
         let required_features = wasmer::Engine::default_features_for_backend(&backend_kind, target);
-        backend.get_engine(target, &required_features)
+        backend.get_engine(target, &required_features, self)
     }
 
     pub fn get_engine_for_module(&self, module_contents: &[u8], target: &Target) -> Result<Engine> {
@@ -310,7 +338,7 @@ impl RuntimeOptions {
         filtered_backends
             .first()
             .unwrap()
-            .get_engine(target, required_features)
+            .get_engine(target, required_features, self)
     }
 
     #[cfg(feature = "compiler")]
@@ -417,6 +445,12 @@ impl RuntimeOptions {
                 if self.enable_verifier {
                     config.enable_verifier();
                 }
+                if let Some(p) = &self.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+
                 Box::new(config)
             }
             #[cfg(feature = "cranelift")]
@@ -425,6 +459,11 @@ impl RuntimeOptions {
                 if self.enable_verifier {
                     config.enable_verifier();
                 }
+                if let Some(p) = &self.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
                 Box::new(config)
             }
             #[cfg(feature = "llvm")]
@@ -436,6 +475,11 @@ impl RuntimeOptions {
                 };
                 use wasmer_types::entity::EntityRef;
                 let mut config = LLVM::new();
+
+                if self.enable_pass_params_opt {
+                    config.enable_pass_params_opt();
+                }
+
                 struct Callbacks {
                     debug_dir: PathBuf,
                 }
@@ -528,6 +572,12 @@ impl RuntimeOptions {
                 if self.enable_verifier {
                     config.enable_verifier();
                 }
+                if let Some(p) = &self.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+
                 Box::new(config)
             }
             BackendType::V8 | BackendType::Wamr | BackendType::Wasmi => unreachable!(),
@@ -592,11 +642,24 @@ impl BackendType {
     }
 
     /// Get an engine for this backend type
-    pub fn get_engine(&self, target: &Target, features: &Features) -> Result<Engine> {
+    pub fn get_engine(
+        &self,
+        target: &Target,
+        features: &Features,
+        runtime_opts: &RuntimeOptions,
+    ) -> Result<Engine> {
         match self {
             #[cfg(feature = "singlepass")]
             Self::Singlepass => {
-                let config = wasmer_compiler_singlepass::Singlepass::new();
+                let mut config = wasmer_compiler_singlepass::Singlepass::new();
+                if runtime_opts.enable_verifier {
+                    config.enable_verifier();
+                }
+                if let Some(p) = &runtime_opts.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
                 let engine = wasmer_compiler::EngineBuilder::new(config)
                     .set_features(Some(features.clone()))
                     .set_target(Some(target.clone()))
@@ -606,7 +669,15 @@ impl BackendType {
             }
             #[cfg(feature = "cranelift")]
             Self::Cranelift => {
-                let config = wasmer_compiler_cranelift::Cranelift::new();
+                let mut config = wasmer_compiler_cranelift::Cranelift::new();
+                if runtime_opts.enable_verifier {
+                    config.enable_verifier();
+                }
+                if let Some(p) = &runtime_opts.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
                 let engine = wasmer_compiler::EngineBuilder::new(config)
                     .set_features(Some(features.clone()))
                     .set_target(Some(target.clone()))
@@ -616,7 +687,118 @@ impl BackendType {
             }
             #[cfg(feature = "llvm")]
             Self::LLVM => {
-                let config = wasmer_compiler_llvm::LLVM::new();
+                use std::{fmt, fs::File, io::Write};
+
+                use wasmer_compiler_llvm::{
+                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
+                };
+                use wasmer_types::entity::EntityRef;
+
+                let mut config = wasmer_compiler_llvm::LLVM::new();
+
+                struct Callbacks {
+                    debug_dir: PathBuf,
+                }
+                impl Callbacks {
+                    fn new(debug_dir: PathBuf) -> Result<Self> {
+                        // Create the debug dir in case it doesn't exist
+                        std::fs::create_dir_all(&debug_dir)?;
+                        Ok(Self { debug_dir })
+                    }
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn types_to_signature(types: &[Type]) -> String {
+                    types
+                        .iter()
+                        .map(|ty| match ty {
+                            Type::I32 => "i".to_string(),
+                            Type::I64 => "I".to_string(),
+                            Type::F32 => "f".to_string(),
+                            Type::F64 => "F".to_string(),
+                            Type::V128 => "v".to_string(),
+                            Type::ExternRef => "e".to_string(),
+                            Type::FuncRef => "r".to_string(),
+                            Type::ExceptionRef => "x".to_string(),
+                        })
+                        .collect::<Vec<_>>()
+                        .join("")
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn function_kind_to_filename(kind: &CompiledKind) -> String {
+                    match kind {
+                        CompiledKind::Local(local_index) => {
+                            format!("function_{}", local_index.index())
+                        }
+                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
+                            "trampoline_call_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
+                            "trampoline_dynamic_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::Module => "module".into(),
+                    }
+                }
+                impl LLVMCallbacks for Callbacks {
+                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping pre optimized LLVM IR");
+                    }
+                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping post optimized LLVM IR");
+                    }
+                    fn obj_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.o", function_kind_to_filename(kind)));
+                        let mem_buf_slice = memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
+                }
+
+                impl fmt::Debug for Callbacks {
+                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                        write!(f, "LLVMCallbacks")
+                    }
+                }
+
+                if let Some(ref llvm_debug_dir) = runtime_opts.llvm_debug_dir {
+                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
+                }
+                if runtime_opts.enable_verifier {
+                    config.enable_verifier();
+                }
+
+                if runtime_opts.enable_pass_params_opt {
+                    config.enable_pass_params_opt();
+                }
+
+                if let Some(p) = &runtime_opts.profiler {
+                    match p {
+                        Profiler::Perfmap => config.enable_perfmap(),
+                    }
+                }
+
                 let engine = wasmer_compiler::EngineBuilder::new(config)
                     .set_features(Some(features.clone()))
                     .set_target(Some(target.clone()))