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 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
//! 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::{code_memory::CodeMemory, profiling_agent::ProfilingAgent};
use anyhow::{Error, Result};
use object::write::WritableBuffer;
use std::str;
use std::sync::Arc;
use wasmtime_environ::{
CompiledFunctionInfo, CompiledModuleInfo, DefinedFuncIndex, FinishedObject, FuncIndex,
FunctionLoc, FunctionName, Metadata, Module, ModuleInternedTypeIndex, ObjectBuilder,
PrimaryMap, StackMapInformation, WasmFunctionInfo,
};
use wasmtime_runtime::{CompiledModuleId, CompiledModuleIdAllocator, MmapVec};
/// A compiled wasm module, ready to be instantiated.
pub struct CompiledModule {
module: Arc<Module>,
funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
wasm_to_native_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
meta: Metadata,
code_memory: Arc<CodeMemory>,
#[cfg(feature = "debug-builtins")]
dbg_jit_registration: Option<wasmtime_runtime::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,
id_allocator: &CompiledModuleIdAllocator,
) -> Result<Self> {
let mut ret = Self {
module: Arc::new(info.module),
funcs: info.funcs,
wasm_to_native_trampolines: info.wasm_to_native_trampolines,
#[cfg(feature = "debug-builtins")]
dbg_jit_registration: None,
code_memory,
meta: info.meta,
unique_id: id_allocator.alloc(),
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 {
use anyhow::Context;
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 = wasmtime_runtime::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 native-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 native callers (e.g. `Func::wrap`)
/// calling Wasm callees.
#[inline]
pub fn native_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<&[u8]> {
let loc = self.funcs[index].native_to_wasm_trampoline?;
Some(&self.text()[loc.start as usize..][..loc.length as usize])
}
/// Get the Wasm-to-native 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_native_trampoline(&self, signature: ModuleInternedTypeIndex) -> &[u8] {
let idx = self
.wasm_to_native_trampolines
.binary_search_by_key(&signature, |entry| entry.0)
.expect("should have a Wasm-to-native trampline for all signatures");
let (_, loc) = self.wasm_to_native_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 anyhow::Context;
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
}
}
/// Write an object out to an [`MmapVec`] so that it can be marked executable
/// before running.
///
/// The returned `MmapVec` will contain the serialized version of `obj`
/// and is sized appropriately to the exact size of the object serialized.
pub fn finish_object(obj: ObjectBuilder<'_>) -> Result<MmapVec> {
Ok(<MmapVecWrapper as FinishedObject>::finish_object(obj)?.0)
}
pub(crate) struct MmapVecWrapper(pub MmapVec);
impl FinishedObject for MmapVecWrapper {
fn finish_object(obj: ObjectBuilder<'_>) -> Result<Self> {
let mut result = ObjectMmap::default();
return match obj.finish(&mut result) {
Ok(()) => {
assert!(result.mmap.is_some(), "no reserve");
let mmap = result.mmap.expect("reserve not called");
assert_eq!(mmap.len(), result.len);
Ok(MmapVecWrapper(mmap))
}
Err(e) => match result.err.take() {
Some(original) => Err(original.context(e)),
None => Err(e.into()),
},
};
/// Helper struct to implement the `WritableBuffer` trait from the `object`
/// crate.
///
/// This enables writing an object directly into an mmap'd memory so it's
/// immediately usable for execution after compilation. This implementation
/// relies on a call to `reserve` happening once up front with all the needed
/// data, and the mmap internally does not attempt to grow afterwards.
#[derive(Default)]
struct ObjectMmap {
mmap: Option<MmapVec>,
len: usize,
err: Option<Error>,
}
impl WritableBuffer for ObjectMmap {
fn len(&self) -> usize {
self.len
}
fn reserve(&mut self, additional: usize) -> Result<(), ()> {
assert!(self.mmap.is_none(), "cannot reserve twice");
self.mmap = match MmapVec::with_capacity(additional) {
Ok(mmap) => Some(mmap),
Err(e) => {
self.err = Some(e);
return Err(());
}
};
Ok(())
}
fn resize(&mut self, new_len: usize) {
// Resizing always appends 0 bytes and since new mmaps start out as 0
// bytes we don't actually need to do anything as part of this other
// than update our own length.
if new_len <= self.len {
return;
}
self.len = new_len;
}
fn write_bytes(&mut self, val: &[u8]) {
let mmap = self.mmap.as_mut().expect("write before reserve");
mmap[self.len..][..val.len()].copy_from_slice(val);
self.len += val.len();
}
}
}
}