From 71c0142cd442fede32f15fb2c2bb652e863ba039 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Mon, 24 Dec 2018 18:20:15 -0800 Subject: [PATCH] Rename the `address` field of Table/Memory/Global exports to `definition`. For functions, `address` makes sense because it's the address of the function. Bt for Table/Memory/Global, it points to a `VM*Definition` field. --- lib/execute/src/instance_plus.rs | 14 +++++++------- lib/execute/src/link.rs | 12 ++++++------ lib/runtime/src/export.rs | 22 +++++++++++++--------- lib/runtime/src/instance.rs | 10 +++++----- 4 files changed, 31 insertions(+), 27 deletions(-) diff --git a/lib/execute/src/instance_plus.rs b/lib/execute/src/instance_plus.rs index e22d58fe71..6e5925d921 100644 --- a/lib/execute/src/instance_plus.rs +++ b/lib/execute/src/instance_plus.rs @@ -213,12 +213,12 @@ impl InstancePlus { start: usize, len: usize, ) -> Result<&[u8], ActionError> { - let address = match unsafe { self.instance.lookup_immutable(memory_name) } { + let definition = match unsafe { self.instance.lookup_immutable(memory_name) } { Some(Export::Memory { - address, + definition, memory: _memory, vmctx: _vmctx, - }) => address, + }) => definition, Some(_) => { return Err(ActionError::Kind(format!( "exported item \"{}\" is not a linear memory", @@ -234,15 +234,15 @@ impl InstancePlus { }; Ok(unsafe { - let memory_def = &*address; + let memory_def = &*definition; &slice::from_raw_parts(memory_def.base, memory_def.current_length)[start..start + len] }) } /// Read a global in this `Instance` identified by an export name. pub fn get(&self, global_name: &str) -> Result { - let (address, global) = match unsafe { self.instance.lookup_immutable(global_name) } { - Some(Export::Global { address, global }) => (address, global), + let (definition, global) = match unsafe { self.instance.lookup_immutable(global_name) } { + Some(Export::Global { definition, global }) => (definition, global), Some(_) => { return Err(ActionError::Kind(format!( "exported item \"{}\" is not a global variable", @@ -258,7 +258,7 @@ impl InstancePlus { }; unsafe { - let global_def = &*address; + let global_def = &*definition; Ok(match global.ty { ir::types::I32 => RuntimeValue::I32(*global_def.as_i32()), ir::types::I64 => RuntimeValue::I64(*global_def.as_i64()), diff --git a/lib/execute/src/link.rs b/lib/execute/src/link.rs index 7b1574986d..2f34d39f6d 100644 --- a/lib/execute/src/link.rs +++ b/lib/execute/src/link.rs @@ -71,7 +71,7 @@ pub fn link_module( match resolver.resolve(module_name, field) { Some(export_value) => match export_value { Export::Table { - address, + definition, vmctx, table, } => { @@ -83,7 +83,7 @@ pub fn link_module( ))); } table_imports.push(VMTableImport { - from: address, + from: definition, vmctx, }); } @@ -108,7 +108,7 @@ pub fn link_module( match resolver.resolve(module_name, field) { Some(export_value) => match export_value { Export::Memory { - address, + definition, vmctx, memory, } => { @@ -136,7 +136,7 @@ pub fn link_module( assert!(memory.offset_guard_size >= import_memory.offset_guard_size); memory_imports.push(VMMemoryImport { - from: address, + from: definition, vmctx, }); } @@ -160,7 +160,7 @@ pub fn link_module( for (index, (ref module_name, ref field)) in module.imported_globals.iter() { match resolver.resolve(module_name, field) { Some(export_value) => match export_value { - Export::Global { address, global } => { + Export::Global { definition, global } => { let imported_global = module.globals[index]; if !is_global_compatible(&global, &imported_global) { return Err(LinkError(format!( @@ -168,7 +168,7 @@ pub fn link_module( module_name, field ))); } - global_imports.push(VMGlobalImport { from: address }); + global_imports.push(VMGlobalImport { from: definition }); } Export::Table { .. } | Export::Memory { .. } | Export::Function { .. } => { return Err(LinkError(format!( diff --git a/lib/runtime/src/export.rs b/lib/runtime/src/export.rs index 588523e127..b7be00614b 100644 --- a/lib/runtime/src/export.rs +++ b/lib/runtime/src/export.rs @@ -21,7 +21,7 @@ pub enum Export { /// A table export value. Table { /// The address of the table descriptor. - address: *mut VMTableDefinition, + definition: *mut VMTableDefinition, /// Pointer to the containing VMContext. vmctx: *mut VMContext, /// The table declaration, used for compatibilty checking. @@ -31,7 +31,7 @@ pub enum Export { /// A memory export value. Memory { /// The address of the memory descriptor. - address: *mut VMMemoryDefinition, + definition: *mut VMMemoryDefinition, /// Pointer to the containing VMContext. vmctx: *mut VMContext, /// The memory declaration, used for compatibilty checking. @@ -41,7 +41,7 @@ pub enum Export { /// A global export value. Global { /// The address of the global storage. - address: *mut VMGlobalDefinition, + definition: *mut VMGlobalDefinition, /// The global declaration, used for compatibilty checking. global: Global, }, @@ -62,9 +62,13 @@ impl Export { } /// Construct a table export value. - pub fn table(address: *mut VMTableDefinition, vmctx: *mut VMContext, table: TablePlan) -> Self { + pub fn table( + definition: *mut VMTableDefinition, + vmctx: *mut VMContext, + table: TablePlan, + ) -> Self { Export::Table { - address, + definition, vmctx, table, } @@ -72,19 +76,19 @@ impl Export { /// Construct a memory export value. pub fn memory( - address: *mut VMMemoryDefinition, + definition: *mut VMMemoryDefinition, vmctx: *mut VMContext, memory: MemoryPlan, ) -> Self { Export::Memory { - address, + definition, vmctx, memory, } } /// Construct a global export value. - pub fn global(address: *mut VMGlobalDefinition, global: Global) -> Self { - Export::Global { address, global } + pub fn global(definition: *mut VMGlobalDefinition, global: Global) -> Self { + Export::Global { definition, global } } } diff --git a/lib/runtime/src/instance.rs b/lib/runtime/src/instance.rs index 5d89e95aab..8c7557b853 100644 --- a/lib/runtime/src/instance.rs +++ b/lib/runtime/src/instance.rs @@ -260,7 +260,7 @@ impl Instance { } } wasmtime_environ::Export::Table(index) => { - let (address, vmctx) = if let Some(def_index) = + let (definition, vmctx) = if let Some(def_index) = self.module.defined_table_index(*index) { ( @@ -272,13 +272,13 @@ impl Instance { (import.from, import.vmctx) }; Export::Table { - address, + definition, vmctx, table: self.module.table_plans[*index].clone(), } } wasmtime_environ::Export::Memory(index) => { - let (address, vmctx) = if let Some(def_index) = + let (definition, vmctx) = if let Some(def_index) = self.module.defined_memory_index(*index) { ( @@ -290,13 +290,13 @@ impl Instance { (import.from, import.vmctx) }; Export::Memory { - address, + definition, vmctx, memory: self.module.memory_plans[*index].clone(), } } wasmtime_environ::Export::Global(index) => Export::Global { - address: if let Some(def_index) = self.module.defined_global_index(*index) { + definition: if let Some(def_index) = self.module.defined_global_index(*index) { unsafe { self.vmctx.global_mut(def_index) } } else { unsafe { self.vmctx.imported_global(*index).from }