wasmtime_environ/
vmoffsets.rs

1//! Offsets and sizes of various structs in `wasmtime::runtime::vm::*` that are
2//! accessed directly by compiled Wasm code.
3
4// Currently the `VMContext` allocation by field looks like this:
5//
6// struct VMContext {
7//      // Fixed-width data comes first so the calculation of the offset of
8//      // these fields is a compile-time constant when using `HostPtr`.
9//      magic: u32,
10//      _padding: u32, // (On 64-bit systems)
11//      vm_store_context: *const VMStoreContext,
12//      builtin_functions: *mut VMBuiltinFunctionsArray,
13//      callee: *mut VMFunctionBody,
14//      epoch_ptr: *mut AtomicU64,
15//      gc_heap_base: *mut u8,
16//      gc_heap_bound: *mut u8,
17//      gc_heap_data: *mut T, // Collector-specific pointer
18//      type_ids: *const VMSharedTypeIndex,
19//
20//      // Variable-width fields come after the fixed-width fields above. Place
21//      // memory-related items first as they're some of the most frequently
22//      // accessed items and minimizing their offset in this structure can
23//      // shrink the size of load/store instruction offset immediates on
24//      // platforms like x64 and Pulley (e.g. fit in an 8-bit offset instead
25//      // of needing a 32-bit offset)
26//      imported_memories: [VMMemoryImport; module.num_imported_memories],
27//      memories: [*mut VMMemoryDefinition; module.num_defined_memories],
28//      owned_memories: [VMMemoryDefinition; module.num_owned_memories],
29//      imported_functions: [VMFunctionImport; module.num_imported_functions],
30//      imported_tables: [VMTable; module.num_imported_tables],
31//      imported_globals: [VMGlobalImport; module.num_imported_globals],
32//      imported_tags: [VMTagImport; module.num_imported_tags],
33//      tables: [VMTableDefinition; module.num_defined_tables],
34//      globals: [VMGlobalDefinition; module.num_defined_globals],
35//      tags: [VMTagDefinition; module.num_defined_tags],
36//      func_refs: [VMFuncRef; module.num_escaped_funcs],
37// }
38
39use crate::{
40    DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex, DefinedTagIndex, FuncIndex,
41    FuncRefIndex, GlobalIndex, MemoryIndex, Module, OwnedMemoryIndex, TableIndex, TagIndex,
42};
43use cranelift_entity::packed_option::ReservedValue;
44
45#[cfg(target_pointer_width = "32")]
46fn cast_to_u32(sz: usize) -> u32 {
47    u32::try_from(sz).unwrap()
48}
49#[cfg(target_pointer_width = "64")]
50fn cast_to_u32(sz: usize) -> u32 {
51    u32::try_from(sz).expect("overflow in cast from usize to u32")
52}
53
54/// Align an offset used in this module to a specific byte-width by rounding up
55#[inline]
56fn align(offset: u32, width: u32) -> u32 {
57    (offset + (width - 1)) / width * width
58}
59
60/// This class computes offsets to fields within `VMContext` and other
61/// related structs that JIT code accesses directly.
62#[derive(Debug, Clone, Copy)]
63pub struct VMOffsets<P> {
64    /// The size in bytes of a pointer on the target.
65    pub ptr: P,
66    /// The number of imported functions in the module.
67    pub num_imported_functions: u32,
68    /// The number of imported tables in the module.
69    pub num_imported_tables: u32,
70    /// The number of imported memories in the module.
71    pub num_imported_memories: u32,
72    /// The number of imported globals in the module.
73    pub num_imported_globals: u32,
74    /// The number of imported tags in the module.
75    pub num_imported_tags: u32,
76    /// The number of defined tables in the module.
77    pub num_defined_tables: u32,
78    /// The number of defined memories in the module.
79    pub num_defined_memories: u32,
80    /// The number of memories owned by the module instance.
81    pub num_owned_memories: u32,
82    /// The number of defined globals in the module.
83    pub num_defined_globals: u32,
84    /// The number of defined tags in the module.
85    pub num_defined_tags: u32,
86    /// The number of escaped functions in the module, the size of the func_refs
87    /// array.
88    pub num_escaped_funcs: u32,
89
90    // precalculated offsets of various member fields
91    imported_functions: u32,
92    imported_tables: u32,
93    imported_memories: u32,
94    imported_globals: u32,
95    imported_tags: u32,
96    defined_tables: u32,
97    defined_memories: u32,
98    owned_memories: u32,
99    defined_globals: u32,
100    defined_tags: u32,
101    defined_func_refs: u32,
102    size: u32,
103}
104
105/// Trait used for the `ptr` representation of the field of `VMOffsets`
106pub trait PtrSize {
107    /// Returns the pointer size, in bytes, for the target.
108    fn size(&self) -> u8;
109
110    /// The offset of the `VMContext::store_context` field
111    fn vmcontext_store_context(&self) -> u8 {
112        u8::try_from(align(
113            u32::try_from(core::mem::size_of::<u32>()).unwrap(),
114            u32::from(self.size()),
115        ))
116        .unwrap()
117    }
118
119    /// The offset of the `VMContext::builtin_functions` field
120    fn vmcontext_builtin_functions(&self) -> u8 {
121        self.vmcontext_store_context() + self.size()
122    }
123
124    /// The offset of the `array_call` field.
125    #[inline]
126    fn vm_func_ref_array_call(&self) -> u8 {
127        0 * self.size()
128    }
129
130    /// The offset of the `wasm_call` field.
131    #[inline]
132    fn vm_func_ref_wasm_call(&self) -> u8 {
133        1 * self.size()
134    }
135
136    /// The offset of the `type_index` field.
137    #[inline]
138    fn vm_func_ref_type_index(&self) -> u8 {
139        2 * self.size()
140    }
141
142    /// The offset of the `vmctx` field.
143    #[inline]
144    fn vm_func_ref_vmctx(&self) -> u8 {
145        3 * self.size()
146    }
147
148    /// Return the size of `VMFuncRef`.
149    #[inline]
150    fn size_of_vm_func_ref(&self) -> u8 {
151        4 * self.size()
152    }
153
154    /// Return the size of `VMGlobalDefinition`; this is the size of the largest value type (i.e. a
155    /// V128).
156    #[inline]
157    fn size_of_vmglobal_definition(&self) -> u8 {
158        16
159    }
160
161    /// Return the size of `VMTagDefinition`.
162    #[inline]
163    fn size_of_vmtag_definition(&self) -> u8 {
164        4
165    }
166
167    // Offsets within `VMStoreContext`
168
169    /// Return the offset of the `fuel_consumed` field of `VMStoreContext`
170    #[inline]
171    fn vmstore_context_fuel_consumed(&self) -> u8 {
172        0
173    }
174
175    /// Return the offset of the `epoch_deadline` field of `VMStoreContext`
176    #[inline]
177    fn vmstore_context_epoch_deadline(&self) -> u8 {
178        self.vmstore_context_fuel_consumed() + 8
179    }
180
181    /// Return the offset of the `stack_limit` field of `VMStoreContext`
182    #[inline]
183    fn vmstore_context_stack_limit(&self) -> u8 {
184        self.vmstore_context_epoch_deadline() + 8
185    }
186
187    /// Return the offset of the `last_wasm_exit_fp` field of `VMStoreContext`.
188    fn vmstore_context_last_wasm_exit_fp(&self) -> u8 {
189        self.vmstore_context_stack_limit() + self.size()
190    }
191
192    /// Return the offset of the `last_wasm_exit_pc` field of `VMStoreContext`.
193    fn vmstore_context_last_wasm_exit_pc(&self) -> u8 {
194        self.vmstore_context_last_wasm_exit_fp() + self.size()
195    }
196
197    /// Return the offset of the `last_wasm_entry_fp` field of `VMStoreContext`.
198    fn vmstore_context_last_wasm_entry_fp(&self) -> u8 {
199        self.vmstore_context_last_wasm_exit_pc() + self.size()
200    }
201
202    // Offsets within `VMMemoryDefinition`
203
204    /// The offset of the `base` field.
205    #[inline]
206    fn vmmemory_definition_base(&self) -> u8 {
207        0 * self.size()
208    }
209
210    /// The offset of the `current_length` field.
211    #[inline]
212    fn vmmemory_definition_current_length(&self) -> u8 {
213        1 * self.size()
214    }
215
216    /// Return the size of `VMMemoryDefinition`.
217    #[inline]
218    fn size_of_vmmemory_definition(&self) -> u8 {
219        2 * self.size()
220    }
221
222    /// Return the size of `*mut VMMemoryDefinition`.
223    #[inline]
224    fn size_of_vmmemory_pointer(&self) -> u8 {
225        self.size()
226    }
227
228    // Offsets within `VMArrayCallHostFuncContext`.
229
230    /// Return the offset of `VMArrayCallHostFuncContext::func_ref`.
231    fn vmarray_call_host_func_context_func_ref(&self) -> u8 {
232        u8::try_from(align(
233            u32::try_from(core::mem::size_of::<u32>()).unwrap(),
234            u32::from(self.size()),
235        ))
236        .unwrap()
237    }
238
239    /// Return the offset to the `magic` value in this `VMContext`.
240    #[inline]
241    fn vmctx_magic(&self) -> u8 {
242        // This is required by the implementation of `VMContext::instance` and
243        // `VMContext::instance_mut`. If this value changes then those locations
244        // need to be updated.
245        0
246    }
247
248    /// Return the offset to the `VMStoreContext` structure
249    #[inline]
250    fn vmctx_store_context(&self) -> u8 {
251        self.vmctx_magic() + self.size()
252    }
253
254    /// Return the offset to the `VMBuiltinFunctionsArray` structure
255    #[inline]
256    fn vmctx_builtin_functions(&self) -> u8 {
257        self.vmctx_store_context() + self.size()
258    }
259
260    /// Return the offset to the `callee` member in this `VMContext`.
261    #[inline]
262    fn vmctx_callee(&self) -> u8 {
263        self.vmctx_builtin_functions() + self.size()
264    }
265
266    /// Return the offset to the `*const AtomicU64` epoch-counter
267    /// pointer.
268    #[inline]
269    fn vmctx_epoch_ptr(&self) -> u8 {
270        self.vmctx_callee() + self.size()
271    }
272
273    /// Return the offset to the GC heap base in this `VMContext`.
274    #[inline]
275    fn vmctx_gc_heap_base(&self) -> u8 {
276        self.vmctx_epoch_ptr() + self.size()
277    }
278
279    /// Return the offset to the GC heap bound in this `VMContext`.
280    #[inline]
281    fn vmctx_gc_heap_bound(&self) -> u8 {
282        self.vmctx_gc_heap_base() + self.size()
283    }
284
285    /// Return the offset to the `*mut T` collector-specific data.
286    ///
287    /// This is a pointer that different collectors can use however they see
288    /// fit.
289    #[inline]
290    fn vmctx_gc_heap_data(&self) -> u8 {
291        self.vmctx_gc_heap_bound() + self.size()
292    }
293
294    /// The offset of the `type_ids` array pointer.
295    #[inline]
296    fn vmctx_type_ids_array(&self) -> u8 {
297        self.vmctx_gc_heap_data() + self.size()
298    }
299
300    /// The end of statically known offsets in `VMContext`.
301    ///
302    /// Data after this is dynamically sized.
303    #[inline]
304    fn vmctx_dynamic_data_start(&self) -> u8 {
305        self.vmctx_type_ids_array() + self.size()
306    }
307}
308
309/// Type representing the size of a pointer for the current compilation host
310#[derive(Clone, Copy)]
311pub struct HostPtr;
312
313impl PtrSize for HostPtr {
314    #[inline]
315    fn size(&self) -> u8 {
316        core::mem::size_of::<usize>() as u8
317    }
318}
319
320impl PtrSize for u8 {
321    #[inline]
322    fn size(&self) -> u8 {
323        *self
324    }
325}
326
327/// Used to construct a `VMOffsets`
328#[derive(Debug, Clone, Copy)]
329pub struct VMOffsetsFields<P> {
330    /// The size in bytes of a pointer on the target.
331    pub ptr: P,
332    /// The number of imported functions in the module.
333    pub num_imported_functions: u32,
334    /// The number of imported tables in the module.
335    pub num_imported_tables: u32,
336    /// The number of imported memories in the module.
337    pub num_imported_memories: u32,
338    /// The number of imported globals in the module.
339    pub num_imported_globals: u32,
340    /// The number of imported tags in the module.
341    pub num_imported_tags: u32,
342    /// The number of defined tables in the module.
343    pub num_defined_tables: u32,
344    /// The number of defined memories in the module.
345    pub num_defined_memories: u32,
346    /// The number of memories owned by the module instance.
347    pub num_owned_memories: u32,
348    /// The number of defined globals in the module.
349    pub num_defined_globals: u32,
350    /// The number of defined tags in the module.
351    pub num_defined_tags: u32,
352    /// The number of escaped functions in the module, the size of the function
353    /// references array.
354    pub num_escaped_funcs: u32,
355}
356
357impl<P: PtrSize> VMOffsets<P> {
358    /// Return a new `VMOffsets` instance, for a given pointer size.
359    pub fn new(ptr: P, module: &Module) -> Self {
360        let num_owned_memories = module
361            .memories
362            .iter()
363            .skip(module.num_imported_memories)
364            .filter(|p| !p.1.shared)
365            .count()
366            .try_into()
367            .unwrap();
368        VMOffsets::from(VMOffsetsFields {
369            ptr,
370            num_imported_functions: cast_to_u32(module.num_imported_funcs),
371            num_imported_tables: cast_to_u32(module.num_imported_tables),
372            num_imported_memories: cast_to_u32(module.num_imported_memories),
373            num_imported_globals: cast_to_u32(module.num_imported_globals),
374            num_imported_tags: cast_to_u32(module.num_imported_tags),
375            num_defined_tables: cast_to_u32(module.num_defined_tables()),
376            num_defined_memories: cast_to_u32(module.num_defined_memories()),
377            num_owned_memories,
378            num_defined_globals: cast_to_u32(module.globals.len() - module.num_imported_globals),
379            num_defined_tags: cast_to_u32(module.tags.len() - module.num_imported_tags),
380            num_escaped_funcs: cast_to_u32(module.num_escaped_funcs),
381        })
382    }
383
384    /// Returns the size, in bytes, of the target
385    #[inline]
386    pub fn pointer_size(&self) -> u8 {
387        self.ptr.size()
388    }
389
390    /// Returns an iterator which provides a human readable description and a
391    /// byte size. The iterator returned will iterate over the bytes allocated
392    /// to the entire `VMOffsets` structure to explain where each byte size is
393    /// coming from.
394    pub fn region_sizes(&self) -> impl Iterator<Item = (&str, u32)> {
395        macro_rules! calculate_sizes {
396            ($($name:ident: $desc:tt,)*) => {{
397                let VMOffsets {
398                    // These fields are metadata not talking about specific
399                    // offsets of specific fields.
400                    ptr: _,
401                    num_imported_functions: _,
402                    num_imported_tables: _,
403                    num_imported_memories: _,
404                    num_imported_globals: _,
405                    num_imported_tags: _,
406                    num_defined_tables: _,
407                    num_defined_globals: _,
408                    num_defined_memories: _,
409                    num_defined_tags: _,
410                    num_owned_memories: _,
411                    num_escaped_funcs: _,
412
413                    // used as the initial size below
414                    size,
415
416                    // exhaustively match the rest of the fields with input from
417                    // the macro
418                    $($name,)*
419                } = *self;
420
421                // calculate the size of each field by relying on the inputs to
422                // the macro being in reverse order and determining the size of
423                // the field as the offset from the field to the last field.
424                let mut last = size;
425                $(
426                    assert!($name <= last);
427                    let tmp = $name;
428                    let $name = last - $name;
429                    last = tmp;
430                )*
431                assert_ne!(last, 0);
432                IntoIterator::into_iter([
433                    $(($desc, $name),)*
434                    ("static vmctx data", last),
435                ])
436            }};
437        }
438
439        calculate_sizes! {
440            defined_func_refs: "module functions",
441            defined_tags: "defined tags",
442            defined_globals: "defined globals",
443            defined_tables: "defined tables",
444            imported_tags: "imported tags",
445            imported_globals: "imported globals",
446            imported_tables: "imported tables",
447            imported_functions: "imported functions",
448            owned_memories: "owned memories",
449            defined_memories: "defined memories",
450            imported_memories: "imported memories",
451        }
452    }
453}
454
455impl<P: PtrSize> From<VMOffsetsFields<P>> for VMOffsets<P> {
456    fn from(fields: VMOffsetsFields<P>) -> VMOffsets<P> {
457        let mut ret = Self {
458            ptr: fields.ptr,
459            num_imported_functions: fields.num_imported_functions,
460            num_imported_tables: fields.num_imported_tables,
461            num_imported_memories: fields.num_imported_memories,
462            num_imported_globals: fields.num_imported_globals,
463            num_imported_tags: fields.num_imported_tags,
464            num_defined_tables: fields.num_defined_tables,
465            num_defined_memories: fields.num_defined_memories,
466            num_owned_memories: fields.num_owned_memories,
467            num_defined_globals: fields.num_defined_globals,
468            num_defined_tags: fields.num_defined_tags,
469            num_escaped_funcs: fields.num_escaped_funcs,
470            imported_functions: 0,
471            imported_tables: 0,
472            imported_memories: 0,
473            imported_globals: 0,
474            imported_tags: 0,
475            defined_tables: 0,
476            defined_memories: 0,
477            owned_memories: 0,
478            defined_globals: 0,
479            defined_tags: 0,
480            defined_func_refs: 0,
481            size: 0,
482        };
483
484        // Convenience functions for checked addition and multiplication.
485        // As side effect this reduces binary size by using only a single
486        // `#[track_caller]` location for each function instead of one for
487        // each individual invocation.
488        #[inline]
489        fn cadd(count: u32, size: u32) -> u32 {
490            count.checked_add(size).unwrap()
491        }
492
493        #[inline]
494        fn cmul(count: u32, size: u8) -> u32 {
495            count.checked_mul(u32::from(size)).unwrap()
496        }
497
498        let mut next_field_offset = u32::from(ret.ptr.vmctx_dynamic_data_start());
499
500        macro_rules! fields {
501            (size($field:ident) = $size:expr, $($rest:tt)*) => {
502                ret.$field = next_field_offset;
503                next_field_offset = cadd(next_field_offset, u32::from($size));
504                fields!($($rest)*);
505            };
506            (align($align:expr), $($rest:tt)*) => {
507                next_field_offset = align(next_field_offset, $align);
508                fields!($($rest)*);
509            };
510            () => {};
511        }
512
513        fields! {
514            size(imported_memories)
515                = cmul(ret.num_imported_memories, ret.size_of_vmmemory_import()),
516            size(defined_memories)
517                = cmul(ret.num_defined_memories, ret.ptr.size_of_vmmemory_pointer()),
518            size(owned_memories)
519                = cmul(ret.num_owned_memories, ret.ptr.size_of_vmmemory_definition()),
520            size(imported_functions)
521                = cmul(ret.num_imported_functions, ret.size_of_vmfunction_import()),
522            size(imported_tables)
523                = cmul(ret.num_imported_tables, ret.size_of_vmtable()),
524            size(imported_globals)
525                = cmul(ret.num_imported_globals, ret.size_of_vmglobal_import()),
526            size(imported_tags)
527                = cmul(ret.num_imported_tags, ret.size_of_vmtag_import()),
528            size(defined_tables)
529                = cmul(ret.num_defined_tables, ret.size_of_vmtable_definition()),
530            align(16),
531            size(defined_globals)
532                = cmul(ret.num_defined_globals, ret.ptr.size_of_vmglobal_definition()),
533            size(defined_tags)
534                = cmul(ret.num_defined_tags, ret.ptr.size_of_vmtag_definition()),
535            size(defined_func_refs) = cmul(
536                ret.num_escaped_funcs,
537                ret.ptr.size_of_vm_func_ref(),
538            ),
539        }
540
541        ret.size = next_field_offset;
542
543        return ret;
544    }
545}
546
547impl<P: PtrSize> VMOffsets<P> {
548    /// The offset of the `wasm_call` field.
549    #[inline]
550    pub fn vmfunction_import_wasm_call(&self) -> u8 {
551        0 * self.pointer_size()
552    }
553
554    /// The offset of the `array_call` field.
555    #[inline]
556    pub fn vmfunction_import_array_call(&self) -> u8 {
557        1 * self.pointer_size()
558    }
559
560    /// The offset of the `vmctx` field.
561    #[inline]
562    pub fn vmfunction_import_vmctx(&self) -> u8 {
563        2 * self.pointer_size()
564    }
565
566    /// Return the size of `VMFunctionImport`.
567    #[inline]
568    pub fn size_of_vmfunction_import(&self) -> u8 {
569        3 * self.pointer_size()
570    }
571}
572
573/// Offsets for `*const VMFunctionBody`.
574impl<P: PtrSize> VMOffsets<P> {
575    /// The size of the `current_elements` field.
576    pub fn size_of_vmfunction_body_ptr(&self) -> u8 {
577        1 * self.pointer_size()
578    }
579}
580
581/// Offsets for `VMTable`.
582impl<P: PtrSize> VMOffsets<P> {
583    /// The offset of the `from` field.
584    #[inline]
585    pub fn vmtable_from(&self) -> u8 {
586        0 * self.pointer_size()
587    }
588
589    /// The offset of the `vmctx` field.
590    #[inline]
591    pub fn vmtable_vmctx(&self) -> u8 {
592        1 * self.pointer_size()
593    }
594
595    /// Return the size of `VMTable`.
596    #[inline]
597    pub fn size_of_vmtable(&self) -> u8 {
598        2 * self.pointer_size()
599    }
600}
601
602/// Offsets for `VMTableDefinition`.
603impl<P: PtrSize> VMOffsets<P> {
604    /// The offset of the `base` field.
605    #[inline]
606    pub fn vmtable_definition_base(&self) -> u8 {
607        0 * self.pointer_size()
608    }
609
610    /// The offset of the `current_elements` field.
611    pub fn vmtable_definition_current_elements(&self) -> u8 {
612        1 * self.pointer_size()
613    }
614
615    /// The size of the `current_elements` field.
616    #[inline]
617    pub fn size_of_vmtable_definition_current_elements(&self) -> u8 {
618        self.pointer_size()
619    }
620
621    /// Return the size of `VMTableDefinition`.
622    #[inline]
623    pub fn size_of_vmtable_definition(&self) -> u8 {
624        2 * self.pointer_size()
625    }
626}
627
628/// Offsets for `VMMemoryImport`.
629impl<P: PtrSize> VMOffsets<P> {
630    /// The offset of the `from` field.
631    #[inline]
632    pub fn vmmemory_import_from(&self) -> u8 {
633        0 * self.pointer_size()
634    }
635
636    /// The offset of the `vmctx` field.
637    #[inline]
638    pub fn vmmemory_import_vmctx(&self) -> u8 {
639        1 * self.pointer_size()
640    }
641
642    /// Return the size of `VMMemoryImport`.
643    #[inline]
644    pub fn size_of_vmmemory_import(&self) -> u8 {
645        3 * self.pointer_size()
646    }
647}
648
649/// Offsets for `VMGlobalImport`.
650impl<P: PtrSize> VMOffsets<P> {
651    /// The offset of the `from` field.
652    #[inline]
653    pub fn vmglobal_import_from(&self) -> u8 {
654        0 * self.pointer_size()
655    }
656
657    /// Return the size of `VMGlobalImport`.
658    #[inline]
659    pub fn size_of_vmglobal_import(&self) -> u8 {
660        1 * self.pointer_size()
661    }
662}
663
664/// Offsets for `VMSharedTypeIndex`.
665impl<P: PtrSize> VMOffsets<P> {
666    /// Return the size of `VMSharedTypeIndex`.
667    #[inline]
668    pub fn size_of_vmshared_type_index(&self) -> u8 {
669        4
670    }
671}
672
673/// Offsets for `VMTagImport`.
674impl<P: PtrSize> VMOffsets<P> {
675    /// The offset of the `from` field.
676    #[inline]
677    pub fn vmtag_import_from(&self) -> u8 {
678        0 * self.pointer_size()
679    }
680
681    /// Return the size of `VMTagImport`.
682    #[inline]
683    pub fn size_of_vmtag_import(&self) -> u8 {
684        1 * self.pointer_size()
685    }
686}
687
688/// Offsets for `VMContext`.
689impl<P: PtrSize> VMOffsets<P> {
690    /// The offset of the `tables` array.
691    #[inline]
692    pub fn vmctx_imported_functions_begin(&self) -> u32 {
693        self.imported_functions
694    }
695
696    /// The offset of the `tables` array.
697    #[inline]
698    pub fn vmctx_imported_tables_begin(&self) -> u32 {
699        self.imported_tables
700    }
701
702    /// The offset of the `memories` array.
703    #[inline]
704    pub fn vmctx_imported_memories_begin(&self) -> u32 {
705        self.imported_memories
706    }
707
708    /// The offset of the `globals` array.
709    #[inline]
710    pub fn vmctx_imported_globals_begin(&self) -> u32 {
711        self.imported_globals
712    }
713
714    /// The offset of the `tags` array.
715    #[inline]
716    pub fn vmctx_imported_tags_begin(&self) -> u32 {
717        self.imported_tags
718    }
719
720    /// The offset of the `tables` array.
721    #[inline]
722    pub fn vmctx_tables_begin(&self) -> u32 {
723        self.defined_tables
724    }
725
726    /// The offset of the `memories` array.
727    #[inline]
728    pub fn vmctx_memories_begin(&self) -> u32 {
729        self.defined_memories
730    }
731
732    /// The offset of the `owned_memories` array.
733    #[inline]
734    pub fn vmctx_owned_memories_begin(&self) -> u32 {
735        self.owned_memories
736    }
737
738    /// The offset of the `globals` array.
739    #[inline]
740    pub fn vmctx_globals_begin(&self) -> u32 {
741        self.defined_globals
742    }
743
744    /// The offset of the `tags` array.
745    #[inline]
746    pub fn vmctx_tags_begin(&self) -> u32 {
747        self.defined_tags
748    }
749
750    /// The offset of the `func_refs` array.
751    #[inline]
752    pub fn vmctx_func_refs_begin(&self) -> u32 {
753        self.defined_func_refs
754    }
755
756    /// Return the size of the `VMContext` allocation.
757    #[inline]
758    pub fn size_of_vmctx(&self) -> u32 {
759        self.size
760    }
761
762    /// Return the offset to `VMFunctionImport` index `index`.
763    #[inline]
764    pub fn vmctx_vmfunction_import(&self, index: FuncIndex) -> u32 {
765        assert!(index.as_u32() < self.num_imported_functions);
766        self.vmctx_imported_functions_begin()
767            + index.as_u32() * u32::from(self.size_of_vmfunction_import())
768    }
769
770    /// Return the offset to `VMTable` index `index`.
771    #[inline]
772    pub fn vmctx_vmtable_import(&self, index: TableIndex) -> u32 {
773        assert!(index.as_u32() < self.num_imported_tables);
774        self.vmctx_imported_tables_begin() + index.as_u32() * u32::from(self.size_of_vmtable())
775    }
776
777    /// Return the offset to `VMMemoryImport` index `index`.
778    #[inline]
779    pub fn vmctx_vmmemory_import(&self, index: MemoryIndex) -> u32 {
780        assert!(index.as_u32() < self.num_imported_memories);
781        self.vmctx_imported_memories_begin()
782            + index.as_u32() * u32::from(self.size_of_vmmemory_import())
783    }
784
785    /// Return the offset to `VMGlobalImport` index `index`.
786    #[inline]
787    pub fn vmctx_vmglobal_import(&self, index: GlobalIndex) -> u32 {
788        assert!(index.as_u32() < self.num_imported_globals);
789        self.vmctx_imported_globals_begin()
790            + index.as_u32() * u32::from(self.size_of_vmglobal_import())
791    }
792
793    /// Return the offset to `VMTagImport` index `index`.
794    #[inline]
795    pub fn vmctx_vmtag_import(&self, index: TagIndex) -> u32 {
796        assert!(index.as_u32() < self.num_imported_tags);
797        self.vmctx_imported_tags_begin() + index.as_u32() * u32::from(self.size_of_vmtag_import())
798    }
799
800    /// Return the offset to `VMTableDefinition` index `index`.
801    #[inline]
802    pub fn vmctx_vmtable_definition(&self, index: DefinedTableIndex) -> u32 {
803        assert!(index.as_u32() < self.num_defined_tables);
804        self.vmctx_tables_begin() + index.as_u32() * u32::from(self.size_of_vmtable_definition())
805    }
806
807    /// Return the offset to the `*mut VMMemoryDefinition` at index `index`.
808    #[inline]
809    pub fn vmctx_vmmemory_pointer(&self, index: DefinedMemoryIndex) -> u32 {
810        assert!(index.as_u32() < self.num_defined_memories);
811        self.vmctx_memories_begin()
812            + index.as_u32() * u32::from(self.ptr.size_of_vmmemory_pointer())
813    }
814
815    /// Return the offset to the owned `VMMemoryDefinition` at index `index`.
816    #[inline]
817    pub fn vmctx_vmmemory_definition(&self, index: OwnedMemoryIndex) -> u32 {
818        assert!(index.as_u32() < self.num_owned_memories);
819        self.vmctx_owned_memories_begin()
820            + index.as_u32() * u32::from(self.ptr.size_of_vmmemory_definition())
821    }
822
823    /// Return the offset to the `VMGlobalDefinition` index `index`.
824    #[inline]
825    pub fn vmctx_vmglobal_definition(&self, index: DefinedGlobalIndex) -> u32 {
826        assert!(index.as_u32() < self.num_defined_globals);
827        self.vmctx_globals_begin()
828            + index.as_u32() * u32::from(self.ptr.size_of_vmglobal_definition())
829    }
830
831    /// Return the offset to the `VMTagDefinition` index `index`.
832    #[inline]
833    pub fn vmctx_vmtag_definition(&self, index: DefinedTagIndex) -> u32 {
834        assert!(index.as_u32() < self.num_defined_tags);
835        self.vmctx_tags_begin() + index.as_u32() * u32::from(self.ptr.size_of_vmtag_definition())
836    }
837
838    /// Return the offset to the `VMFuncRef` for the given function
839    /// index (either imported or defined).
840    #[inline]
841    pub fn vmctx_func_ref(&self, index: FuncRefIndex) -> u32 {
842        assert!(!index.is_reserved_value());
843        assert!(index.as_u32() < self.num_escaped_funcs);
844        self.vmctx_func_refs_begin() + index.as_u32() * u32::from(self.ptr.size_of_vm_func_ref())
845    }
846
847    /// Return the offset to the `wasm_call` field in `*const VMFunctionBody` index `index`.
848    #[inline]
849    pub fn vmctx_vmfunction_import_wasm_call(&self, index: FuncIndex) -> u32 {
850        self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_wasm_call())
851    }
852
853    /// Return the offset to the `array_call` field in `*const VMFunctionBody` index `index`.
854    #[inline]
855    pub fn vmctx_vmfunction_import_array_call(&self, index: FuncIndex) -> u32 {
856        self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_array_call())
857    }
858
859    /// Return the offset to the `vmctx` field in `*const VMFunctionBody` index `index`.
860    #[inline]
861    pub fn vmctx_vmfunction_import_vmctx(&self, index: FuncIndex) -> u32 {
862        self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_vmctx())
863    }
864
865    /// Return the offset to the `from` field in the imported `VMTable` at index
866    /// `index`.
867    #[inline]
868    pub fn vmctx_vmtable_from(&self, index: TableIndex) -> u32 {
869        self.vmctx_vmtable_import(index) + u32::from(self.vmtable_from())
870    }
871
872    /// Return the offset to the `base` field in `VMTableDefinition` index `index`.
873    #[inline]
874    pub fn vmctx_vmtable_definition_base(&self, index: DefinedTableIndex) -> u32 {
875        self.vmctx_vmtable_definition(index) + u32::from(self.vmtable_definition_base())
876    }
877
878    /// Return the offset to the `current_elements` field in `VMTableDefinition` index `index`.
879    #[inline]
880    pub fn vmctx_vmtable_definition_current_elements(&self, index: DefinedTableIndex) -> u32 {
881        self.vmctx_vmtable_definition(index) + u32::from(self.vmtable_definition_current_elements())
882    }
883
884    /// Return the offset to the `from` field in `VMMemoryImport` index `index`.
885    #[inline]
886    pub fn vmctx_vmmemory_import_from(&self, index: MemoryIndex) -> u32 {
887        self.vmctx_vmmemory_import(index) + u32::from(self.vmmemory_import_from())
888    }
889
890    /// Return the offset to the `vmctx` field in `VMMemoryImport` index `index`.
891    #[inline]
892    pub fn vmctx_vmmemory_import_vmctx(&self, index: MemoryIndex) -> u32 {
893        self.vmctx_vmmemory_import(index) + u32::from(self.vmmemory_import_vmctx())
894    }
895
896    /// Return the offset to the `base` field in `VMMemoryDefinition` index `index`.
897    #[inline]
898    pub fn vmctx_vmmemory_definition_base(&self, index: OwnedMemoryIndex) -> u32 {
899        self.vmctx_vmmemory_definition(index) + u32::from(self.ptr.vmmemory_definition_base())
900    }
901
902    /// Return the offset to the `current_length` field in `VMMemoryDefinition` index `index`.
903    #[inline]
904    pub fn vmctx_vmmemory_definition_current_length(&self, index: OwnedMemoryIndex) -> u32 {
905        self.vmctx_vmmemory_definition(index)
906            + u32::from(self.ptr.vmmemory_definition_current_length())
907    }
908
909    /// Return the offset to the `from` field in `VMGlobalImport` index `index`.
910    #[inline]
911    pub fn vmctx_vmglobal_import_from(&self, index: GlobalIndex) -> u32 {
912        self.vmctx_vmglobal_import(index) + u32::from(self.vmglobal_import_from())
913    }
914
915    /// Return the offset to the `from` field in `VMTagImport` index `index`.
916    #[inline]
917    pub fn vmctx_vmtag_import_from(&self, index: TagIndex) -> u32 {
918        self.vmctx_vmtag_import(index) + u32::from(self.vmtag_import_from())
919    }
920}
921
922/// Offsets for `VMDrcHeader`.
923///
924/// Should only be used when the DRC collector is enabled.
925impl<P: PtrSize> VMOffsets<P> {
926    /// Return the offset for `VMDrcHeader::ref_count`.
927    #[inline]
928    pub fn vm_drc_header_ref_count(&self) -> u32 {
929        8
930    }
931}
932
933/// Offsets for `VMGcRefActivationsTable`.
934///
935/// These should only be used when the DRC collector is enabled.
936impl<P: PtrSize> VMOffsets<P> {
937    /// Return the offset for `VMGcRefActivationsTable::next`.
938    #[inline]
939    pub fn vm_gc_ref_activation_table_next(&self) -> u32 {
940        0
941    }
942
943    /// Return the offset for `VMGcRefActivationsTable::end`.
944    #[inline]
945    pub fn vm_gc_ref_activation_table_end(&self) -> u32 {
946        self.pointer_size().into()
947    }
948}
949
950/// Magic value for core Wasm VM contexts.
951///
952/// This is stored at the start of all `VMContext` structures.
953pub const VMCONTEXT_MAGIC: u32 = u32::from_le_bytes(*b"core");
954
955/// Equivalent of `VMCONTEXT_MAGIC` except for array-call host functions.
956///
957/// This is stored at the start of all `VMArrayCallHostFuncContext` structures
958/// and double-checked on `VMArrayCallHostFuncContext::from_opaque`.
959pub const VM_ARRAY_CALL_HOST_FUNC_MAGIC: u32 = u32::from_le_bytes(*b"ACHF");
960
961#[cfg(test)]
962mod tests {
963    use crate::vmoffsets::align;
964
965    #[test]
966    fn alignment() {
967        fn is_aligned(x: u32) -> bool {
968            x % 16 == 0
969        }
970        assert!(is_aligned(align(0, 16)));
971        assert!(is_aligned(align(32, 16)));
972        assert!(is_aligned(align(33, 16)));
973        assert!(is_aligned(align(31, 16)));
974    }
975}
wasmtime_environ/vmoffsets.rs

wasmtime_environ/
vmoffsets.rs
