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 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
//! Define the `instantiate` function, which takes a byte array containing an
//! encoded wasm module and returns a live wasm instance. Also, define
//! `CompiledModule` to allow compiling and instantiating to be done as separate
//! steps.
use crate::prelude::*;
use crate::runtime::vm::{CompiledModuleId, MmapVec};
use crate::{code_memory::CodeMemory, profiling_agent::ProfilingAgent};
use alloc::sync::Arc;
use core::str;
use wasmtime_environ::{
CompiledFunctionInfo, CompiledModuleInfo, DefinedFuncIndex, FuncIndex, FunctionLoc,
FunctionName, Metadata, Module, ModuleInternedTypeIndex, PrimaryMap, StackMapInformation,
WasmFunctionInfo,
};
/// A compiled wasm module, ready to be instantiated.
pub struct CompiledModule {
module: Arc<Module>,
funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
wasm_to_array_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
meta: Metadata,
code_memory: Arc<CodeMemory>,
#[cfg(feature = "debug-builtins")]
dbg_jit_registration: Option<crate::runtime::vm::GdbJitImageRegistration>,
/// A unique ID used to register this module with the engine.
unique_id: CompiledModuleId,
func_names: Vec<FunctionName>,
}
impl CompiledModule {
/// Creates `CompiledModule` directly from a precompiled artifact.
///
/// The `code_memory` argument is expected to be the result of a previous
/// call to `ObjectBuilder::finish` above. This is an ELF image, at this
/// time, which contains all necessary information to create a
/// `CompiledModule` from a compilation.
///
/// This method also takes `info`, an optionally-provided deserialization
/// of the artifacts' compilation metadata section. If this information is
/// not provided then the information will be
/// deserialized from the image of the compilation artifacts. Otherwise it
/// will be assumed to be what would otherwise happen if the section were
/// to be deserialized.
///
/// The `profiler` argument here is used to inform JIT profiling runtimes
/// about new code that is loaded.
pub fn from_artifacts(
code_memory: Arc<CodeMemory>,
info: CompiledModuleInfo,
profiler: &dyn ProfilingAgent,
) -> Result<Self> {
let mut ret = Self {
module: Arc::new(info.module),
funcs: info.funcs,
wasm_to_array_trampolines: info.wasm_to_array_trampolines,
#[cfg(feature = "debug-builtins")]
dbg_jit_registration: None,
code_memory,
meta: info.meta,
unique_id: CompiledModuleId::new(),
func_names: info.func_names,
};
ret.register_debug_and_profiling(profiler)?;
Ok(ret)
}
fn register_debug_and_profiling(&mut self, profiler: &dyn ProfilingAgent) -> Result<()> {
#[cfg(feature = "debug-builtins")]
if self.meta.native_debug_info_present {
let text = self.text();
let bytes = crate::debug::create_gdbjit_image(
self.mmap().to_vec(),
(text.as_ptr(), text.len()),
)
.context("failed to create jit image for gdb")?;
let reg = crate::runtime::vm::GdbJitImageRegistration::register(bytes);
self.dbg_jit_registration = Some(reg);
}
profiler.register_module(&self.code_memory.mmap()[..], &|addr| {
let (idx, _) = self.func_by_text_offset(addr)?;
let idx = self.module.func_index(idx);
let name = self.func_name(idx)?;
let mut demangled = String::new();
wasmtime_environ::demangle_function_name(&mut demangled, name).unwrap();
Some(demangled)
});
Ok(())
}
/// Get this module's unique ID. It is unique with respect to a
/// single allocator (which is ordinarily held on a Wasm engine).
pub fn unique_id(&self) -> CompiledModuleId {
self.unique_id
}
/// Returns the underlying memory which contains the compiled module's
/// image.
pub fn mmap(&self) -> &MmapVec {
self.code_memory.mmap()
}
/// Returns the underlying owned mmap of this compiled image.
pub fn code_memory(&self) -> &Arc<CodeMemory> {
&self.code_memory
}
/// Returns the text section of the ELF image for this compiled module.
///
/// This memory should have the read/execute permissions.
#[inline]
pub fn text(&self) -> &[u8] {
self.code_memory.text()
}
/// Return a reference-counting pointer to a module.
pub fn module(&self) -> &Arc<Module> {
&self.module
}
/// Looks up the `name` section name for the function index `idx`, if one
/// was specified in the original wasm module.
pub fn func_name(&self, idx: FuncIndex) -> Option<&str> {
// Find entry for `idx`, if present.
let i = self.func_names.binary_search_by_key(&idx, |n| n.idx).ok()?;
let name = &self.func_names[i];
// Here we `unwrap` the `from_utf8` but this can theoretically be a
// `from_utf8_unchecked` if we really wanted since this section is
// guaranteed to only have valid utf-8 data. Until it's a problem it's
// probably best to double-check this though.
let data = self.code_memory().func_name_data();
Some(str::from_utf8(&data[name.offset as usize..][..name.len as usize]).unwrap())
}
/// Return a reference to a mutable module (if possible).
pub fn module_mut(&mut self) -> Option<&mut Module> {
Arc::get_mut(&mut self.module)
}
/// Returns an iterator over all functions defined within this module with
/// their index and their body in memory.
#[inline]
pub fn finished_functions(
&self,
) -> impl ExactSizeIterator<Item = (DefinedFuncIndex, &[u8])> + '_ {
self.funcs
.iter()
.map(move |(i, _)| (i, self.finished_function(i)))
}
/// Returns the body of the function that `index` points to.
#[inline]
pub fn finished_function(&self, index: DefinedFuncIndex) -> &[u8] {
let loc = self.funcs[index].wasm_func_loc;
&self.text()[loc.start as usize..][..loc.length as usize]
}
/// Get the array-to-Wasm trampoline for the function `index` points to.
///
/// If the function `index` points to does not escape, then `None` is
/// returned.
///
/// These trampolines are used for array callers (e.g. `Func::new`)
/// calling Wasm callees.
pub fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<&[u8]> {
let loc = self.funcs[index].array_to_wasm_trampoline?;
Some(&self.text()[loc.start as usize..][..loc.length as usize])
}
/// Get the Wasm-to-array trampoline for the given signature.
///
/// These trampolines are used for filling in
/// `VMFuncRef::wasm_call` for `Func::wrap`-style host funcrefs
/// that don't have access to a compiler when created.
pub fn wasm_to_array_trampoline(&self, signature: ModuleInternedTypeIndex) -> &[u8] {
let idx = match self
.wasm_to_array_trampolines
.binary_search_by_key(&signature, |entry| entry.0)
{
Ok(idx) => idx,
Err(_) => panic!("missing trampoline for {signature:?}"),
};
let (_, loc) = self.wasm_to_array_trampolines[idx];
&self.text()[loc.start as usize..][..loc.length as usize]
}
/// Returns the stack map information for all functions defined in this
/// module.
///
/// The iterator returned iterates over the span of the compiled function in
/// memory with the stack maps associated with those bytes.
pub fn stack_maps(&self) -> impl Iterator<Item = (&[u8], &[StackMapInformation])> {
self.finished_functions().map(|(_, f)| f).zip(
self.funcs
.values()
.map(|f| &f.wasm_func_info.stack_maps[..]),
)
}
/// Lookups a defined function by a program counter value.
///
/// Returns the defined function index and the relative address of
/// `text_offset` within the function itself.
pub fn func_by_text_offset(&self, text_offset: usize) -> Option<(DefinedFuncIndex, u32)> {
let text_offset = u32::try_from(text_offset).unwrap();
let index = match self.funcs.binary_search_values_by_key(&text_offset, |e| {
debug_assert!(e.wasm_func_loc.length > 0);
// Return the inclusive "end" of the function
e.wasm_func_loc.start + e.wasm_func_loc.length - 1
}) {
Ok(k) => {
// Exact match, pc is at the end of this function
k
}
Err(k) => {
// Not an exact match, k is where `pc` would be "inserted"
// Since we key based on the end, function `k` might contain `pc`,
// so we'll validate on the range check below
k
}
};
let CompiledFunctionInfo { wasm_func_loc, .. } = self.funcs.get(index)?;
let start = wasm_func_loc.start;
let end = wasm_func_loc.start + wasm_func_loc.length;
if text_offset < start || end < text_offset {
return None;
}
Some((index, text_offset - wasm_func_loc.start))
}
/// Gets the function location information for a given function index.
pub fn func_loc(&self, index: DefinedFuncIndex) -> &FunctionLoc {
&self
.funcs
.get(index)
.expect("defined function should be present")
.wasm_func_loc
}
/// Gets the function information for a given function index.
pub fn wasm_func_info(&self, index: DefinedFuncIndex) -> &WasmFunctionInfo {
&self
.funcs
.get(index)
.expect("defined function should be present")
.wasm_func_info
}
/// Creates a new symbolication context which can be used to further
/// symbolicate stack traces.
///
/// Basically this makes a thing which parses debuginfo and can tell you
/// what filename and line number a wasm pc comes from.
#[cfg(feature = "addr2line")]
pub fn symbolize_context(&self) -> Result<Option<SymbolizeContext<'_>>> {
use gimli::EndianSlice;
if !self.meta.has_wasm_debuginfo {
return Ok(None);
}
let dwarf = gimli::Dwarf::load(|id| -> Result<_> {
// Lookup the `id` in the `dwarf` array prepared for this module
// during module serialization where it's sorted by the `id` key. If
// found this is a range within the general module's concatenated
// dwarf section which is extracted here, otherwise it's just an
// empty list to represent that it's not present.
let data = self
.meta
.dwarf
.binary_search_by_key(&(id as u8), |(id, _)| *id)
.map(|i| {
let (_, range) = &self.meta.dwarf[i];
&self.code_memory().dwarf()[range.start as usize..range.end as usize]
})
.unwrap_or(&[]);
Ok(EndianSlice::new(data, gimli::LittleEndian))
})?;
let cx = addr2line::Context::from_dwarf(dwarf)
.context("failed to create addr2line dwarf mapping context")?;
Ok(Some(SymbolizeContext {
inner: cx,
code_section_offset: self.meta.code_section_offset,
}))
}
/// Returns whether the original wasm module had unparsed debug information
/// based on the tunables configuration.
pub fn has_unparsed_debuginfo(&self) -> bool {
self.meta.has_unparsed_debuginfo
}
/// Indicates whether this module came with n address map such that lookups
/// via `wasmtime_environ::lookup_file_pos` will succeed.
///
/// If this function returns `false` then `lookup_file_pos` will always
/// return `None`.
pub fn has_address_map(&self) -> bool {
!self.code_memory.address_map_data().is_empty()
}
}
#[cfg(feature = "addr2line")]
type Addr2LineContext<'a> = addr2line::Context<gimli::EndianSlice<'a, gimli::LittleEndian>>;
/// A context which contains dwarf debug information to translate program
/// counters back to filenames and line numbers.
#[cfg(feature = "addr2line")]
pub struct SymbolizeContext<'a> {
inner: Addr2LineContext<'a>,
code_section_offset: u64,
}
#[cfg(feature = "addr2line")]
impl<'a> SymbolizeContext<'a> {
/// Returns access to the [`addr2line::Context`] which can be used to query
/// frame information with.
pub fn addr2line(&self) -> &Addr2LineContext<'a> {
&self.inner
}
/// Returns the offset of the code section in the original wasm file, used
/// to calculate lookup values into the DWARF.
pub fn code_section_offset(&self) -> u64 {
self.code_section_offset
}
}