Merge pull request #171 from wasmerio/feature/ctx-first-arg

Move ctx as first argument to functions

lib/clif-backend/src/func_env.rs

@@ -32,10 +32,10 @@ impl<'env, 'module, 'isa> FuncEnv<'env, 'module, 'isa> {
         let mut signature = self.env.signatures[Converter(clif_sig_index).into()].clone();
 
         // Add the vmctx parameter type to it
-        signature.params.push(ir::AbiParam::special(
-            self.pointer_type(),
-            ir::ArgumentPurpose::VMContext,
-        ));
+        signature.params.insert(
+            0,
+            ir::AbiParam::special(self.pointer_type(), ir::ArgumentPurpose::VMContext),
+        );
 
         // Return signature
         signature
@@ -459,8 +459,8 @@ impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
         // Build a value list for the indirect call instruction containing the call_args
         // and the vmctx parameter.
         let mut args = Vec::with_capacity(call_args.len() + 1);
-        args.extend(call_args.iter().cloned());
         args.push(vmctx_ptr);
+        args.extend(call_args.iter().cloned());
 
         Ok(pos.ins().call_indirect(sig_ref, func_ptr, &args))
     }
@@ -485,8 +485,8 @@ impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
                     .expect("missing vmctx parameter");
 
                 let mut args = Vec::with_capacity(call_args.len() + 1);
-                args.extend(call_args.iter().cloned());
                 args.push(vmctx);
+                args.extend(call_args.iter().cloned());
 
                 Ok(pos.ins().call(callee, &args))
             }
@@ -532,8 +532,8 @@ impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
                 let sig_ref = pos.func.dfg.ext_funcs[callee].signature;
 
                 let mut args = Vec::with_capacity(call_args.len() + 1);
-                args.extend(call_args.iter().cloned());
                 args.push(imported_vmctx_addr);
+                args.extend(call_args.iter().cloned());
 
                 Ok(pos
                     .ins()
@@ -559,9 +559,9 @@ impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
         let signature = pos.func.import_signature(ir::Signature {
             call_conv: self.target_config().default_call_conv,
             params: vec![
+                ir::AbiParam::special(self.pointer_type(), ir::ArgumentPurpose::VMContext),
                 ir::AbiParam::new(ir::types::I32),
                 ir::AbiParam::new(ir::types::I32),
-                ir::AbiParam::special(self.pointer_type(), ir::ArgumentPurpose::VMContext),
             ],
             returns: vec![ir::AbiParam::new(ir::types::I32)],
         });
@@ -604,7 +604,7 @@ impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
 
         let call_inst = pos
             .ins()
-            .call(mem_grow_func, &[const_mem_index, by_value, vmctx]);
+            .call(mem_grow_func, &[vmctx, const_mem_index, by_value]);
 
         Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
     }
@@ -623,8 +623,8 @@ impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
         let signature = pos.func.import_signature(ir::Signature {
             call_conv: self.target_config().default_call_conv,
             params: vec![
-                ir::AbiParam::new(ir::types::I32),
                 ir::AbiParam::special(self.pointer_type(), ir::ArgumentPurpose::VMContext),
+                ir::AbiParam::new(ir::types::I32),
             ],
             returns: vec![ir::AbiParam::new(ir::types::I32)],
         });
@@ -664,7 +664,7 @@ impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
             .special_param(ir::ArgumentPurpose::VMContext)
             .expect("missing vmctx parameter");
 
-        let call_inst = pos.ins().call(mem_grow_func, &[const_mem_index, vmctx]);
+        let call_inst = pos.ins().call(mem_grow_func, &[vmctx, const_mem_index]);
 
         Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
     }

lib/clif-backend/src/module_env.rs

@@ -419,8 +419,8 @@ impl<'module, 'isa, 'data> ModuleEnvironment<'data> for ModuleEnv<'module, 'isa>
                     let signature = pos.func.import_signature(ir::Signature {
                         call_conv: self.target_config().default_call_conv,
                         params: vec![
-                            ir::AbiParam::new(ir::types::I32),
                             ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
+                            ir::AbiParam::new(ir::types::I32),
                         ],
                         returns: vec![],
                     });
@@ -457,8 +457,8 @@ impl<'module, 'isa, 'data> ModuleEnvironment<'data> for ModuleEnv<'module, 'isa>
                     let signature = pos.func.import_signature(ir::Signature {
                         call_conv: self.target_config().default_call_conv,
                         params: vec![
-                            ir::AbiParam::new(ir::types::I32),
                             ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
+                            ir::AbiParam::new(ir::types::I32),
                         ],
                         returns: vec![],
                     });
@@ -476,8 +476,8 @@ impl<'module, 'isa, 'data> ModuleEnvironment<'data> for ModuleEnv<'module, 'isa>
                     let signature = pos.func.import_signature(ir::Signature {
                         call_conv: self.target_config().default_call_conv,
                         params: vec![
-                            ir::AbiParam::new(ir::types::I64),
                             ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
+                            ir::AbiParam::new(ir::types::I64),
                         ],
                         returns: vec![],
                     });
@@ -495,8 +495,8 @@ impl<'module, 'isa, 'data> ModuleEnvironment<'data> for ModuleEnv<'module, 'isa>
                     let signature = pos.func.import_signature(ir::Signature {
                         call_conv: self.target_config().default_call_conv,
                         params: vec![
-                            ir::AbiParam::new(ir::types::F32),
                             ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
+                            ir::AbiParam::new(ir::types::F32),
                         ],
                         returns: vec![],
                     });
@@ -514,8 +514,8 @@ impl<'module, 'isa, 'data> ModuleEnvironment<'data> for ModuleEnv<'module, 'isa>
                     let signature = pos.func.import_signature(ir::Signature {
                         call_conv: self.target_config().default_call_conv,
                         params: vec![
-                            ir::AbiParam::new(ir::types::F64),
                             ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
+                            ir::AbiParam::new(ir::types::F64),
                         ],
                         returns: vec![],
                     });
@@ -536,14 +536,14 @@ impl<'module, 'isa, 'data> ModuleEnvironment<'data> for ModuleEnv<'module, 'isa>
 
                 let func_index = pos.ins().iconst(ir::types::I32, func_index.index() as i64);
 
-                pos.ins().call(start_debug, &[func_index, vmctx]);
+                pos.ins().call(start_debug, &[vmctx, func_index]);
 
                 for param in new_ebb_params.iter().cloned() {
                     match pos.func.dfg.value_type(param) {
-                        ir::types::I32 => pos.ins().call(i32_print, &[param, vmctx]),
-                        ir::types::I64 => pos.ins().call(i64_print, &[param, vmctx]),
-                        ir::types::F32 => pos.ins().call(f32_print, &[param, vmctx]),
-                        ir::types::F64 => pos.ins().call(f64_print, &[param, vmctx]),
+                        ir::types::I32 => pos.ins().call(i32_print, &[vmctx, param]),
+                        ir::types::I64 => pos.ins().call(i64_print, &[vmctx, param]),
+                        ir::types::F32 => pos.ins().call(f32_print, &[vmctx, param]),
+                        ir::types::F64 => pos.ins().call(f64_print, &[vmctx, param]),
                         _ => unimplemented!(),
                     };
                 }

lib/clif-backend/src/resolver.rs

@@ -350,21 +350,21 @@ fn round_up(n: usize, multiple: usize) -> usize {
     (n + multiple - 1) & !(multiple - 1)
 }
 
-extern "C" fn i32_print(n: i32) {
+extern "C" fn i32_print(_ctx: &mut vm::Ctx, n: i32) {
     print!(" i32: {},", n);
 }
-extern "C" fn i64_print(n: i64) {
+extern "C" fn i64_print(_ctx: &mut vm::Ctx, n: i64) {
     print!(" i64: {},", n);
 }
-extern "C" fn f32_print(n: f32) {
+extern "C" fn f32_print(_ctx: &mut vm::Ctx, n: f32) {
     print!(" f32: {},", n);
 }
-extern "C" fn f64_print(n: f64) {
+extern "C" fn f64_print(_ctx: &mut vm::Ctx, n: f64) {
     print!(" f64: {},", n);
 }
-extern "C" fn start_debug(func_index: u32) {
+extern "C" fn start_debug(_ctx: &mut vm::Ctx, func_index: u32) {
     print!("func ({}), args: [", func_index);
 }
-extern "C" fn end_debug() {
+extern "C" fn end_debug(_ctx: &mut vm::Ctx) {
     println!(" ]");
 }

lib/clif-backend/src/trampoline.rs

@@ -169,6 +169,7 @@ fn generate_func(func_sig: &FuncSig) -> ir::Function {
     let mut pos = FuncCursor::new(&mut func).at_first_insertion_point(entry_ebb);
 
     let mut args_vec = Vec::with_capacity(func_sig.params().len() + 1);
+    args_vec.push(vmctx_ptr);
     for (index, wasm_ty) in func_sig.params().iter().enumerate() {
         let mem_flags = ir::MemFlags::trusted();
 
@@ -180,7 +181,6 @@ fn generate_func(func_sig: &FuncSig) -> ir::Function {
         );
         args_vec.push(val);
     }
-    args_vec.push(vmctx_ptr);
 
     let call_inst = pos.ins().call_indirect(export_sig_ref, func_ptr, &args_vec);
 
@@ -229,22 +229,21 @@ fn generate_trampoline_signature() -> ir::Signature {
 fn generate_export_signature(func_sig: &FuncSig) -> ir::Signature {
     let mut export_clif_sig = ir::Signature::new(isa::CallConv::SystemV);
 
-    export_clif_sig.params = func_sig
-        .params()
-        .iter()
-        .map(|wasm_ty| ir::AbiParam {
-            value_type: wasm_ty_to_clif(*wasm_ty),
-            purpose: ir::ArgumentPurpose::Normal,
-            extension: ir::ArgumentExtension::None,
-            location: ir::ArgumentLoc::Unassigned,
-        })
-        .chain(iter::once(ir::AbiParam {
-            value_type: ir::types::I64,
-            purpose: ir::ArgumentPurpose::VMContext,
-            extension: ir::ArgumentExtension::None,
-            location: ir::ArgumentLoc::Unassigned,
-        }))
-        .collect();
+    let func_sig_iter = func_sig.params().iter().map(|wasm_ty| ir::AbiParam {
+        value_type: wasm_ty_to_clif(*wasm_ty),
+        purpose: ir::ArgumentPurpose::Normal,
+        extension: ir::ArgumentExtension::None,
+        location: ir::ArgumentLoc::Unassigned,
+    });
+
+    export_clif_sig.params = iter::once(ir::AbiParam {
+        value_type: ir::types::I64,
+        purpose: ir::ArgumentPurpose::VMContext,
+        extension: ir::ArgumentExtension::None,
+        location: ir::ArgumentLoc::Unassigned,
+    })
+    .chain(func_sig_iter)
+    .collect();
 
     export_clif_sig.returns = func_sig
         .returns()

lib/emscripten/src/README.md

@@ -10,7 +10,7 @@
   ```
 - **abort** ✅ 🔥     [:top:](#host-apis)
   ```rust
-  fn abort(message: u32, ctx: &mut Ctx)
+  fn abort(ctx: &mut Ctx, message: u32, )
   ```
 - **abort_on_cannot_grow_memory** ✅     [:top:](#host-apis)
   ```rust
@@ -28,19 +28,19 @@
 
 - **\_getenv** ✅     [:top:](#host-apis)
   ```rust
-  fn _getenv(name: c_int, ctx: &mut Ctx)
+  fn _getenv(ctx: &mut Ctx, name: c_int, )
   ```
 - **\_putenv** ✅     [:top:](#host-apis)
   ```rust
-  fn _putenv(name: c_int, ctx: &mut Ctx)
+  fn _putenv(ctx: &mut Ctx, name: c_int, )
   ```
 - **\_setenv** ✅     [:top:](#host-apis)
   ```rust
   fn _setenv(name: c_int, value: c_int, overwrite: c_int, instance: &mut Instance
   ```
 - **\_unsetenv** ✅     [:top:](#host-apis)
   ```rust
-  fn _unsetenv(name: c_int, ctx: &mut Ctx)
+  fn _unsetenv(ctx: &mut Ctx, name: c_int, )
   ```
 
 ###### THREAD
@@ -70,15 +70,15 @@
 
 - **\_emscripten_memcpy_big** ✅ 🔥     [:top:](#host-apis)
   ```rust
-  fn _emscripten_memcpy_big(dest: u32, src: u32, len: u32, ctx: &mut Ctx) -> u32
+  fn _emscripten_memcpy_big(ctx: &mut Ctx, dest: u32, src: u32, len: u32, ) -> u32
   ```
 - **enlarge_memory** ✅     [:top:](#host-apis)
   ```rust
   fn enlarge_memory()
   ```
 - **get_total_memory** ✅     [:top:](#host-apis)
   ```rust
-  fn get_total_memory(ctx: &mut Ctx) -> u32
+  fn get_total_memory(ctx: &mut Ctx, ) -> u32
   ```
 
 ###### TIMING
@@ -337,7 +337,7 @@
   ```
 - **open** (\_\_\_syscall5) ✅ ❗️ 🔥     [:top:](#host-apis)
   ```rust
-  fn open(path: u32, flags: c_int, mode: c_int, ctx: &mut Ctx) -> c_int
+  fn open(ctx: &mut Ctx, path: u32, flags: c_int, mode: c_int, ) -> c_int
   ```
 - **openat** (\_\_\_syscall295)     [:top:](#host-apis)
   ```rust
@@ -385,7 +385,7 @@
   ```
 - **read** (\_\_\_syscall3) ✅ ❗️     [:top:](#host-apis)
   ```rust
-  fn read(fd: c_int, buf: u32, count: size_t, ctx: &mut Ctx) -> ssize_t
+  fn read(ctx: &mut Ctx, fd: c_int, buf: u32, count: size_t, ) -> ssize_t
   ```
 - **readlink** (\_\_\_syscall85)     [:top:](#host-apis)
   ```rust

lib/emscripten/src/env/mod.rs

@@ -14,24 +14,24 @@ use crate::{allocate_on_stack, EmscriptenData};
 use std::os::raw::c_int;
 use wasmer_runtime_core::vm::Ctx;
 
-pub fn _getaddrinfo(_one: i32, _two: i32, _three: i32, _four: i32, _ctx: &mut Ctx) -> i32 {
+pub fn _getaddrinfo(_ctx: &mut Ctx, _one: i32, _two: i32, _three: i32, _four: i32) -> i32 {
     debug!("emscripten::_getaddrinfo");
     -1
 }
 
-pub fn call_malloc(size: u32, ctx: &mut Ctx) -> u32 {
+pub fn call_malloc(ctx: &mut Ctx, size: u32) -> u32 {
     get_emscripten_data(ctx).malloc.call(size).unwrap()
 }
 
-pub fn call_memalign(alignment: u32, size: u32, ctx: &mut Ctx) -> u32 {
+pub fn call_memalign(ctx: &mut Ctx, alignment: u32, size: u32) -> u32 {
     if let Some(memalign) = &get_emscripten_data(ctx).memalign {
         memalign.call(alignment, size).unwrap()
     } else {
         panic!("Memalign is set to None");
     }
 }
 
-pub fn call_memset(pointer: u32, value: u32, size: u32, ctx: &mut Ctx) -> u32 {
+pub fn call_memset(ctx: &mut Ctx, pointer: u32, value: u32, size: u32) -> u32 {
     get_emscripten_data(ctx)
         .memset
         .call(pointer, value, size)
@@ -48,16 +48,16 @@ pub fn _getpagesize(_ctx: &mut Ctx) -> u32 {
 }
 
 #[allow(clippy::cast_ptr_alignment)]
-pub fn ___build_environment(environ: c_int, ctx: &mut Ctx) {
+pub fn ___build_environment(ctx: &mut Ctx, environ: c_int) {
     debug!("emscripten::___build_environment {}", environ);
     const MAX_ENV_VALUES: u32 = 64;
     const TOTAL_ENV_SIZE: u32 = 1024;
     let environment = emscripten_memory_pointer!(ctx.memory(0), environ) as *mut c_int;
     unsafe {
         let (pool_offset, _pool_slice): (u32, &mut [u8]) =
-            allocate_on_stack(TOTAL_ENV_SIZE as u32, ctx);
+            allocate_on_stack(ctx, TOTAL_ENV_SIZE as u32);
         let (env_offset, _env_slice): (u32, &mut [u8]) =
-            allocate_on_stack((MAX_ENV_VALUES * 4) as u32, ctx);
+            allocate_on_stack(ctx, (MAX_ENV_VALUES * 4) as u32);
         let env_ptr = emscripten_memory_pointer!(ctx.memory(0), env_offset) as *mut c_int;
         let mut _pool_ptr = emscripten_memory_pointer!(ctx.memory(0), pool_offset) as *mut c_int;
         *env_ptr = pool_offset as i32;
@@ -70,7 +70,7 @@ pub fn ___build_environment(environ: c_int, ctx: &mut Ctx) {
     // };
 }
 
-pub fn ___assert_fail(a: c_int, b: c_int, c: c_int, d: c_int, _ctx: &mut Ctx) {
+pub fn ___assert_fail(_ctx: &mut Ctx, a: c_int, b: c_int, c: c_int, d: c_int) {
     debug!("emscripten::___assert_fail {} {} {} {}", a, b, c, d);
     // TODO: Implement like emscripten expects regarding memory/page size
     // TODO raise an error