Add a compile feature to wasmtime-environ

crates/cranelift/Cargo.toml

@@ -16,7 +16,7 @@ workspace = true
 [dependencies]
 anyhow = { workspace = true }
 log = { workspace = true }
-wasmtime-environ = { workspace = true }
+wasmtime-environ = { workspace = true, features = ['compile'] }
 cranelift-wasm = { workspace = true }
 cranelift-codegen = { workspace = true, features = ["host-arch"] }
 cranelift-frontend = { workspace = true }

crates/environ/Cargo.toml

@@ -25,8 +25,8 @@ thiserror = { workspace = true }
 serde = "1.0.188"
 serde_derive = "1.0.188"
 log = { workspace = true }
-gimli = { workspace = true, features = ["write"] }
-object = { workspace = true, features = ['write_core'] }
+gimli = { workspace = true }
+object = { workspace = true }
 rustc-demangle = { version = "0.1.16", optional = true }
 target-lexicon = { workspace = true }
 wasm-encoder = { workspace = true, optional = true }
@@ -50,3 +50,4 @@ component-model = [
 ]
 demangle = ['dep:rustc-demangle', 'dep:cpp_demangle']
 gc = []
+compile = ['gimli/write', 'object/write_core']

crates/environ/src/address_map.rs

@@ -1,10 +1,7 @@
 //! Data structures to provide transformation of the source
 
-use crate::obj::ELF_WASMTIME_ADDRMAP;
-use object::write::{Object, StandardSegment};
-use object::{Bytes, LittleEndian, SectionKind, U32Bytes};
+use object::{Bytes, LittleEndian, U32Bytes};
 use serde_derive::{Deserialize, Serialize};
-use std::ops::Range;
 
 /// Single source location to generated address mapping.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
@@ -52,69 +49,6 @@ impl Default for FilePos {
     }
 }
 
-/// Builder for the address map section of a wasmtime compilation image.
-///
-/// This builder is used to conveniently built the `ELF_WASMTIME_ADDRMAP`
-/// section by compilers, and provides utilities to directly insert the results
-/// into an `Object`.
-#[derive(Default)]
-pub struct AddressMapSection {
-    offsets: Vec<U32Bytes<LittleEndian>>,
-    positions: Vec<U32Bytes<LittleEndian>>,
-    last_offset: u32,
-}
-
-impl AddressMapSection {
-    /// Pushes a new set of instruction mapping information for a function added
-    /// in the exectuable.
-    ///
-    /// The `func` argument here is the range of the function, relative to the
-    /// start of the text section in the executable. The `instrs` provided are
-    /// the descriptors for instructions in the function and their various
-    /// mappings back to original source positions.
-    ///
-    /// This is required to be called for `func` values that are strictly
-    /// increasing in addresses (e.g. as the object is built). Additionally the
-    /// `instrs` map must be sorted based on code offset in the native text
-    /// section.
-    pub fn push(&mut self, func: Range<u64>, instrs: &[InstructionAddressMap]) {
-        // NB: for now this only supports <=4GB text sections in object files.
-        // Alternative schemes will need to be created for >32-bit offsets to
-        // avoid making this section overly large.
-        let func_start = u32::try_from(func.start).unwrap();
-        let func_end = u32::try_from(func.end).unwrap();
-
-        self.offsets.reserve(instrs.len());
-        self.positions.reserve(instrs.len());
-        for map in instrs {
-            // Sanity-check to ensure that functions are pushed in-order, otherwise
-            // the `offsets` array won't be sorted which is our goal.
-            let pos = func_start + map.code_offset;
-            assert!(pos >= self.last_offset);
-            self.offsets.push(U32Bytes::new(LittleEndian, pos));
-            self.positions
-                .push(U32Bytes::new(LittleEndian, map.srcloc.0));
-            self.last_offset = pos;
-        }
-        self.last_offset = func_end;
-    }
-
-    /// Finishes encoding this section into the `Object` provided.
-    pub fn append_to(self, obj: &mut Object) {
-        let section = obj.add_section(
-            obj.segment_name(StandardSegment::Data).to_vec(),
-            ELF_WASMTIME_ADDRMAP.as_bytes().to_vec(),
-            SectionKind::ReadOnlyData,
-        );
-
-        // NB: this matches the encoding expected by `lookup` below.
-        let amt = u32::try_from(self.offsets.len()).unwrap();
-        obj.append_section_data(section, &amt.to_le_bytes(), 1);
-        obj.append_section_data(section, object::bytes_of_slice(&self.offsets), 1);
-        obj.append_section_data(section, object::bytes_of_slice(&self.positions), 1);
-    }
-}
-
 /// Parse an `ELF_WASMTIME_ADDRMAP` section, returning the slice of code offsets
 /// and the slice of associated file positions for each offset.
 fn parse_address_map(

crates/environ/src/compile/address_map.rs

@@ -0,0 +1,72 @@
+//! Data structures to provide transformation of the source
+
+use crate::obj::ELF_WASMTIME_ADDRMAP;
+use crate::InstructionAddressMap;
+use object::write::{Object, StandardSegment};
+use object::{LittleEndian, SectionKind, U32Bytes};
+use std::ops::Range;
+
+/// Builder for the address map section of a wasmtime compilation image.
+///
+/// This builder is used to conveniently built the `ELF_WASMTIME_ADDRMAP`
+/// section by compilers, and provides utilities to directly insert the results
+/// into an `Object`.
+#[derive(Default)]
+pub struct AddressMapSection {
+    offsets: Vec<U32Bytes<LittleEndian>>,
+    positions: Vec<U32Bytes<LittleEndian>>,
+    last_offset: u32,
+}
+
+impl AddressMapSection {
+    /// Pushes a new set of instruction mapping information for a function added
+    /// in the exectuable.
+    ///
+    /// The `func` argument here is the range of the function, relative to the
+    /// start of the text section in the executable. The `instrs` provided are
+    /// the descriptors for instructions in the function and their various
+    /// mappings back to original source positions.
+    ///
+    /// This is required to be called for `func` values that are strictly
+    /// increasing in addresses (e.g. as the object is built). Additionally the
+    /// `instrs` map must be sorted based on code offset in the native text
+    /// section.
+    pub fn push(&mut self, func: Range<u64>, instrs: &[InstructionAddressMap]) {
+        // NB: for now this only supports <=4GB text sections in object files.
+        // Alternative schemes will need to be created for >32-bit offsets to
+        // avoid making this section overly large.
+        let func_start = u32::try_from(func.start).unwrap();
+        let func_end = u32::try_from(func.end).unwrap();
+
+        self.offsets.reserve(instrs.len());
+        self.positions.reserve(instrs.len());
+        for map in instrs {
+            // Sanity-check to ensure that functions are pushed in-order, otherwise
+            // the `offsets` array won't be sorted which is our goal.
+            let pos = func_start + map.code_offset;
+            assert!(pos >= self.last_offset);
+            self.offsets.push(U32Bytes::new(LittleEndian, pos));
+            self.positions.push(U32Bytes::new(
+                LittleEndian,
+                map.srcloc.file_offset().unwrap_or(u32::MAX),
+            ));
+            self.last_offset = pos;
+        }
+        self.last_offset = func_end;
+    }
+
+    /// Finishes encoding this section into the `Object` provided.
+    pub fn append_to(self, obj: &mut Object) {
+        let section = obj.add_section(
+            obj.segment_name(StandardSegment::Data).to_vec(),
+            ELF_WASMTIME_ADDRMAP.as_bytes().to_vec(),
+            SectionKind::ReadOnlyData,
+        );
+
+        // NB: this matches the encoding expected by `lookup` below.
+        let amt = u32::try_from(self.offsets.len()).unwrap();
+        obj.append_section_data(section, &amt.to_le_bytes(), 1);
+        obj.append_section_data(section, object::bytes_of_slice(&self.offsets), 1);
+        obj.append_section_data(section, object::bytes_of_slice(&self.positions), 1);
+    }
+}

crates/environ/src/compilation.rs → crates/environ/src/compile/mod.rs

@@ -3,51 +3,27 @@
 
 use crate::{obj, Tunables};
 use crate::{
-    BuiltinFunctionIndex, DefinedFuncIndex, FilePos, FuncIndex, FunctionBodyData,
-    ModuleTranslation, ModuleTypesBuilder, PrimaryMap, StackMap, WasmError, WasmFuncType,
+    BuiltinFunctionIndex, DefinedFuncIndex, FlagValue, FuncIndex, FunctionBodyData, FunctionLoc,
+    ModuleTranslation, ModuleTypesBuilder, ObjectKind, PrimaryMap, WasmError, WasmFuncType,
+    WasmFunctionInfo,
 };
 use anyhow::Result;
 use object::write::{Object, SymbolId};
 use object::{Architecture, BinaryFormat, FileFlags};
-use serde_derive::{Deserialize, Serialize};
 use std::any::Any;
 use std::borrow::Cow;
 use std::fmt;
 use std::path;
 use std::sync::Arc;
 use thiserror::Error;
 
-/// Information about a function, such as trap information, address map,
-/// and stack maps.
-#[derive(Serialize, Deserialize, Default)]
-#[allow(missing_docs)]
-pub struct WasmFunctionInfo {
-    pub start_srcloc: FilePos,
-    pub stack_maps: Box<[StackMapInformation]>,
-}
-
-/// Description of where a function is located in the text section of a
-/// compiled image.
-#[derive(Copy, Clone, Serialize, Deserialize)]
-pub struct FunctionLoc {
-    /// The byte offset from the start of the text section where this
-    /// function starts.
-    pub start: u32,
-    /// The byte length of this function's function body.
-    pub length: u32,
-}
+mod address_map;
+mod module_artifacts;
+mod trap_encoding;
 
-/// The offset within a function of a GC safepoint, and its associated stack
-/// map.
-#[derive(Serialize, Deserialize, Debug)]
-pub struct StackMapInformation {
-    /// The offset of the GC safepoint within the function's native code. It is
-    /// relative to the beginning of the function.
-    pub code_offset: u32,
-
-    /// The stack map for identifying live GC refs at the GC safepoint.
-    pub stack_map: StackMap,
-}
+pub use self::address_map::*;
+pub use self::module_artifacts::*;
+pub use self::trap_encoding::*;
 
 /// An error while compiling WebAssembly to machine code.
 #[derive(Error, Debug)]
@@ -171,14 +147,6 @@ pub enum SettingKind {
     Preset,
 }
 
-/// Types of objects that can be created by `Compiler::object`
-pub enum ObjectKind {
-    /// A core wasm compilation artifact
-    Module,
-    /// A component compilation artifact
-    Component,
-}
-
 /// An implementation of a compiler which can compile WebAssembly functions to
 /// machine code and perform other miscellaneous tasks needed by the JIT runtime.
 pub trait Compiler: Send + Sync {
@@ -419,24 +387,3 @@ pub trait Compiler: Send + Sync {
         None
     }
 }
-
-/// Value of a configured setting for a [`Compiler`]
-#[derive(Serialize, Deserialize, Hash, Eq, PartialEq, Debug)]
-pub enum FlagValue<'a> {
-    /// Name of the value that has been configured for this setting.
-    Enum(&'a str),
-    /// The numerical value of the configured settings.
-    Num(u8),
-    /// Whether the setting is on or off.
-    Bool(bool),
-}
-
-impl fmt::Display for FlagValue<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::Enum(v) => v.fmt(f),
-            Self::Num(v) => v.fmt(f),
-            Self::Bool(v) => v.fmt(f),
-        }
-    }
-}