orca_wasm/ir/module/
module_imports.rs

1//! Intermediate Representation of a Module's Imports
2
3use crate::ir::id::{FunctionID, ImportsID};
4use wasmparser::TypeRef;
5
6// TODO: Need to handle the relationship between Functions and Imports
7/// Represents an import in a WebAssembly module.
8#[derive(Debug, Clone)]
9pub struct Import<'a> {
10    /// The module being imported from.
11    pub module: &'a str,
12    /// The name of the imported item.
13    pub name: &'a str,
14    /// The type of the imported item.
15    pub ty: TypeRef,
16    /// The name (in the custom section) of the imported item.
17    pub custom_name: Option<String>,
18    pub(crate) deleted: bool,
19}
20
21impl<'a> From<wasmparser::Import<'a>> for Import<'a> {
22    fn from(import: wasmparser::Import<'a>) -> Self {
23        Import {
24            module: import.module,
25            name: import.name,
26            ty: import.ty,
27            custom_name: None,
28            deleted: false,
29        }
30    }
31}
32
33impl Import<'_> {
34    /// Check whether this is an import for a function.
35    pub fn is_function(&self) -> bool {
36        matches!(self.ty, TypeRef::Func(_))
37    }
38    /// Check whether this is an import for a global.
39    pub fn is_global(&self) -> bool {
40        matches!(self.ty, TypeRef::Global(_))
41    }
42    /// Check whether this is an import for a table.
43    pub fn is_table(&self) -> bool {
44        matches!(self.ty, TypeRef::Table(_))
45    }
46    /// Check whether this is an import for a tag.
47    pub fn is_tag(&self) -> bool {
48        matches!(self.ty, TypeRef::Tag(_))
49    }
50    /// Check whether this is an import for a memory.
51    pub fn is_memory(&self) -> bool {
52        matches!(self.ty, TypeRef::Memory(_))
53    }
54}
55
56/// Represents the Imports Section of a WASM Module
57#[derive(Clone, Debug, Default)]
58pub struct ModuleImports<'a> {
59    /// The imports.
60    imports: Vec<Import<'a>>,
61
62    pub(crate) num_funcs: u32,
63    pub(crate) num_funcs_added: u32,
64    pub(crate) num_globals: u32,
65    pub(crate) num_globals_added: u32,
66    pub(crate) num_tables: u32,
67    pub(crate) num_tables_added: u32,
68    pub(crate) num_tags: u32,
69    pub(crate) num_tags_added: u32,
70    pub(crate) num_memories: u32,
71    pub(crate) num_memories_added: u32,
72}
73
74impl<'a> ModuleImports<'a> {
75    /// Creates a new `ModuleImports` struct given a Vec of Imports
76    pub fn new(imports: Vec<Import<'a>>) -> Self {
77        let mut def = Self::default();
78        for import in imports.iter() {
79            if import.is_function() {
80                def.num_funcs += 1;
81            } else if import.is_global() {
82                def.num_globals += 1;
83            } else if import.is_table() {
84                def.num_tables += 1;
85            } else if import.is_tag() {
86                def.num_tags += 1;
87            } else if import.is_memory() {
88                def.num_memories += 1;
89            }
90        }
91        def.imports = imports;
92        def
93    }
94
95    /// Checks if there are no Imports
96    pub fn is_empty(&self) -> bool {
97        self.imports.is_empty()
98    }
99
100    /// Get an iterator over the imports.
101    pub fn iter(&self) -> std::slice::Iter<'_, Import<'a>> {
102        self.imports.iter()
103    }
104
105    /// Get a mutable iterator over the imports.
106    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, Import<'a>> {
107        self.imports.iter_mut()
108    }
109
110    /// Set the name of a given import using the ImportsID.
111    pub fn set_name(&mut self, name: String, imports_id: ImportsID) {
112        self.imports[*imports_id as usize].custom_name = Some(name)
113    }
114
115    /// Set the name of an imported function, using the FunctionID rather
116    /// than the ImportsID. Note that these are not necessarily equal if
117    /// the module has non-function imports! (It is more efficient to
118    /// do this operation using the ImportsID.)
119    pub fn set_fn_name(&mut self, name: String, func_id: FunctionID) {
120        for (curr_fn_id, import) in (0_u32..).zip(self.imports.iter_mut()) {
121            if import.is_function() && curr_fn_id == *func_id {
122                import.custom_name = Some(name);
123                return;
124            }
125        }
126    }
127
128    /// Returns the number of imports
129    pub fn len(&self) -> usize {
130        self.imports.len()
131    }
132
133    /// Add a new import to the module.
134    pub(crate) fn add<'b>(&'b mut self, import: Import<'a>) -> ImportsID {
135        // using a match instead of import.is_*() to make sure that we're
136        // exhaustive due to the compiler guarantees.
137        match import.ty {
138            TypeRef::Func(..) => {
139                self.num_funcs += 1;
140                self.num_funcs_added += 1;
141            }
142            TypeRef::Global(..) => {
143                self.num_globals += 1;
144                self.num_globals_added += 1;
145            }
146            TypeRef::Table(..) => {
147                self.num_tables += 1;
148                self.num_tables_added += 1;
149            }
150            TypeRef::Tag(..) => {
151                self.num_tags += 1;
152                self.num_tags_added += 1;
153            }
154            TypeRef::Memory(..) => {
155                self.num_memories += 1;
156                self.num_memories_added += 1;
157            }
158        }
159        self.imports.push(import);
160        ImportsID((self.imports.len() - 1) as u32)
161    }
162
163    pub(crate) fn delete(&mut self, imports_id: ImportsID) {
164        self.imports[*imports_id as usize].deleted = true;
165    }
166
167    /// Find an import by the `module` and `name` and return its `ImportsID` if found
168    pub fn find(&self, module: String, name: String) -> Option<ImportsID> {
169        for (id, imp) in self.imports.iter().enumerate() {
170            if imp.module == module.as_str() && imp.name == name.as_str() {
171                return Some(ImportsID(id as u32));
172            }
173        }
174        None
175    }
176
177    /// Get the function ID of an Imported Function
178    pub fn get_func(&self, module: String, name: String) -> Option<FunctionID> {
179        for (idx, imp) in self.imports.iter().enumerate() {
180            if imp.is_function() && imp.module == module.as_str() && *imp.name == name {
181                return Some(FunctionID(idx as u32));
182            }
183        }
184        None
185    }
186
187    /// Get an Import by its `ImportsID`
188    pub fn get(&self, id: ImportsID) -> &Import {
189        &self.imports[*id as usize]
190    }
191
192    /// Get the name of an Import
193    pub fn get_import_name(&self, imports_id: ImportsID) -> &Option<String> {
194        &self.imports[*imports_id as usize].custom_name
195    }
196}
orca_wasm/ir/module/module_imports.rs

orca_wasm/ir/module/
module_imports.rs
