wasmtime_environ/module_artifacts.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
//! Definitions of runtime structures and metadata which are serialized into ELF
//! with `bincode` as part of a module's compilation process.
use crate::prelude::*;
use crate::{
DefinedFuncIndex, FilePos, FuncIndex, Module, ModuleInternedTypeIndex, PrimaryMap, StackMap,
};
use core::fmt;
use core::ops::Range;
use core::str;
use serde_derive::{Deserialize, Serialize};
/// Secondary in-memory results of function compilation.
#[derive(Serialize, Deserialize)]
pub struct CompiledFunctionInfo {
/// The [`WasmFunctionInfo`] for this function.
pub wasm_func_info: WasmFunctionInfo,
/// The [`FunctionLoc`] indicating the location of this function in the text
/// section of the competition artifact.
pub wasm_func_loc: FunctionLoc,
/// A trampoline for array callers (e.g. `Func::new`) calling into this function (if needed).
pub array_to_wasm_trampoline: Option<FunctionLoc>,
}
/// 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, Debug, 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,
}
/// 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,
}
/// Secondary in-memory results of module compilation.
///
/// This opaque structure can be optionally passed back to
/// `CompiledModule::from_artifacts` to avoid decoding extra information there.
#[derive(Serialize, Deserialize)]
pub struct CompiledModuleInfo {
/// Type information about the compiled WebAssembly module.
pub module: Module,
/// Metadata about each compiled function.
pub funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
/// Sorted list, by function index, of names we have for this module.
pub func_names: Vec<FunctionName>,
/// Metadata about wasm-to-array trampolines. Used when exposing a native
/// callee (e.g. `Func::wrap`) to a Wasm caller. Sorted by signature index.
pub wasm_to_array_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
/// General compilation metadata.
pub meta: Metadata,
}
/// The name of a function stored in the
/// [`ELF_NAME_DATA`](crate::obj::ELF_NAME_DATA) section.
#[derive(Serialize, Deserialize)]
pub struct FunctionName {
/// The Wasm function index of this function.
pub idx: FuncIndex,
/// The offset of the name in the
/// [`ELF_NAME_DATA`](crate::obj::ELF_NAME_DATA) section.
pub offset: u32,
/// The length of the name in bytes.
pub len: u32,
}
/// Metadata associated with a compiled ELF artifact.
#[derive(Serialize, Deserialize)]
pub struct Metadata {
/// Whether or not the original wasm module contained debug information that
/// we skipped and did not parse.
pub has_unparsed_debuginfo: bool,
/// Offset in the original wasm file to the code section.
pub code_section_offset: u64,
/// Whether or not custom wasm-specific dwarf sections were inserted into
/// the ELF image.
///
/// Note that even if this flag is `true` sections may be missing if they
/// weren't found in the original wasm module itself.
pub has_wasm_debuginfo: bool,
/// Whether this artifact contains Pulley bytecode (instead of machine code)
/// or not.
pub is_pulley: bool,
/// Dwarf sections and the offsets at which they're stored in the
/// ELF_WASMTIME_DWARF
pub dwarf: Vec<(u8, Range<u64>)>,
}
/// Value of a configured setting for a [`Compiler`](crate::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),
}
}
}
/// Types of objects that can be created by `Compiler::object`
pub enum ObjectKind {
/// A core wasm compilation artifact
Module,
/// A component compilation artifact
Component,
}