Working test groups: binop, floating_point, alloc

Cargo.toml

@@ -27,6 +27,7 @@ default = ["aot"]
 aot = []
 jit = []
 sel4-rumprun = []
+sel4-rumprun-target-side = []
 
 [build-dependencies]
 gcc = "0.3"
@@ -34,8 +35,7 @@ gcc = "0.3"
 [dependencies]
 ast = {path = "src/ast"}
 utils = {path = "src/utils"}
-gc = {path = "src/gc"}
-
+#gc = {path = "src/gc"}
 
 field-offset = "0.1.1"
 libloading = "0.3"
@@ -52,3 +52,12 @@ docopt = "0.6"
 petgraph = "0.4.1"
 extprim = "*"
 num-traits = "*"
+
+[target.x86_64-unknown-linux-gnu.dependencies]
+gc = { path = "src/gc", default-features = false}
+
+[target.x86_64-apple-darwin.dependencies]
+gc = { path = "src/gc", default-features = false}
+
+[target.x86_64-rumprun-netbsd.dependencies]
+gc = { path = "src/gc", default-features = false, features = ["sel4-rumprun-target-side"], target = "x86_64-rumprun-netbsd"}

build.rs

@@ -13,7 +13,9 @@
 // limitations under the License.
 
 extern crate gcc;
+use std::env;
 
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[cfg(any(target_os = "macos", target_os = "linux"))]
 #[cfg(target_arch = "x86_64")]
 fn main() {
@@ -24,6 +26,7 @@ fn main() {
                      .compile("libswap_stack.a"); 
 }
 
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[cfg(target_os = "linux")]
 #[cfg(target_arch = "aarch64")]
 fn main() {
@@ -35,6 +38,7 @@ fn main() {
 }
 
 // This is here to enable cross compiling from windows/x86_64 to linux/aarch64
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[cfg(target_os = "windows")]
 #[cfg(target_arch = "x86_64")]
 fn main() {
@@ -45,9 +49,14 @@ fn main() {
         .compile("libswap_stack.a");
 }
 
-#[cfg(feature = "sel4-rumprun")]
+
+//#[cfg(all(target_os = "netbsd", target_vendor = "rumprun"))]
+#[cfg(feature = "sel4-rumprun-target-side")]
 #[cfg(target_arch = "x86_64")]
 fn main() {
+//    env::set_var("ZEBU_TARGET", "x86_64-rumprun-netbsd");
+//    println!("*****ENV VAR SET*****");
+    use std::path::Path;
     let mut compiler_name = String::new();
     compiler_name.push_str("x86_64-rumprun-netbsd-gcc");
     gcc::Config::new().flag("-O3").flag("-c")
@@ -56,10 +65,10 @@ fn main() {
         .compile("libruntime.a");
     gcc::Config::new().flag("-O3").flag("-c")
         .compiler(Path::new(compiler_name.as_str()))
-        .file("src/runtime/swap_stack_x64_sysv.S")
+        .file("src/runtime/swap_stack_x64_sel4_rumprun_sysv.S")
         .compile("libswap_stack.a");
     gcc::Config::new().flag("-O3").flag("-c")
         .compiler(Path::new(compiler_name.as_str()))
-        .file("c_helpers.c")
-        .compile("libc_helpers.a");
+        .file("zebu_c_helpers.c")
+        .compile("libzebu_c_helpers.a");
 }
\ No newline at end of file

build_for_sel4_rumprun.sh

+#!/usr/bin/env bash
+export ZEBU_TARGET=x86_64-rumprun-netbsd
+cd ././../rumprun-sel4/
+bash clean_and_build.sh
\ No newline at end of file

src/ast/src/ir.rs

@@ -802,7 +802,7 @@ impl Value {
 }
 
 const DISPLAY_ID : bool = true;
-const DISPLAY_TYPE : bool = false;
+const DISPLAY_TYPE : bool = true;
 const PRINT_ABBREVIATE_NAME: bool = true;
 
 impl fmt::Debug for Value {

src/compiler/backend/arch/aarch64/asm_backend.rs

@@ -2790,6 +2790,7 @@ fn write_const_value(f: &mut File, constant: P<Value>) {
     }
 }
 
+
 use std::collections::HashMap;
 
 pub fn emit_context_with_reloc(vm: &VM,

src/compiler/backend/arch/x86_64/asm_backend.rs

@@ -15,6 +15,7 @@
 #![allow(unused_variables)]
 
 use compiler::backend::AOT_EMIT_CONTEXT_FILE;
+use compiler::backend::AOT_EMIT_SYM_TABLE_FILE;
 use compiler::backend::RegGroup;
 use utils::ByteSize;
 use utils::Address;
@@ -2998,6 +2999,7 @@ impl CodeGenerator for ASMCodeGen {
         self.add_asm_branch2(asm, dest_name);
     }
 
+    #[cfg(not(feature = "sel4-rumprun"))]
     #[cfg(target_os = "macos")]
     fn emit_call_near_rel32(&mut self, callsite: String, func: MuName, pe: Option<MuName>) -> ValueLocation {
         trace!("emit: call {}", func);
@@ -3012,6 +3014,7 @@ impl CodeGenerator for ASMCodeGen {
         ValueLocation::Relocatable(RegGroup::GPR, callsite)
     }
 
+    #[cfg(not(feature = "sel4-rumprun"))]
     #[cfg(target_os = "linux")]
     // generating Position-Independent Code using PLT
     fn emit_call_near_rel32(&mut self, callsite: String, func: MuName, pe: Option<MuName>) -> ValueLocation {
@@ -3436,11 +3439,14 @@ fn write_const_min_align(f: &mut File) {
     write_align(f, MIN_ALIGN);
 }
 
+#[cfg(not(feature = "sel4-rumprun"))]
 #[cfg(target_os = "linux")]
 fn write_align(f: &mut File, align: ByteSize) {
     use std::io::Write;
     f.write_fmt(format_args!("\t.align {}\n", check_min_align(align))).unwrap();
 }
+
+#[cfg(not(feature = "sel4-rumprun"))]
 #[cfg(target_os = "macos")]
 fn write_align(f: &mut File, align: ByteSize) {
     use std::io::Write;
@@ -3524,6 +3530,128 @@ fn write_const_value(f: &mut File, constant: P<Value>) {
     }
 }
 
+#[cfg(not(feature = "sel4-rumprun"))]
+pub fn emit_sym_table(vm: &VM) {
+    debug!("Currently nothing to emit for --!");
+}
+
+#[cfg(feature = "sel4-rumprun")]
+pub fn emit_sym_table(vm: &VM){
+    use std::path;
+    use std::io::Write;
+    // Javad-cross-compile
+    // code to generate an asm file to resolve symbol addresses at link time!
+    // in this stage, a single sym_file is generated for each test
+    // these sym_files will be merged in build.rs\
+    // in the parent directory of sel4 side
+
+    //**************************************************
+    // Code starts here
+    // first create the asm file in the correct path
+    // _st added file name and path stands for _SymTable
+    // *************************************************
+    debug!("Going to emit Sym table for sel4-rumprun");
+    let mut file_path_st = path::PathBuf::new();
+    file_path_st.push(&vm.vm_options.flag_aot_emit_dir);
+    //just the file name is changed compared to context.s
+    // vm file name is: "fnID_sym_table.s"
+    file_path_st.push(format!("{}", AOT_EMIT_SYM_TABLE_FILE));
+
+    let mut file_st = match File::create(file_path_st.as_path()) {
+        Err(why) => panic!("couldn't create SYM TABLE file {}: {}", file_path_st.to_str().unwrap(), why),
+        Ok(file) => file
+    };
+
+    // **************************************************
+    // fnID_sym_table.s is created, but it's empty
+    // *************************************************
+    // **************************************************
+    // Code for exporting all of the required symbols \
+    // in vm, using the following fields:
+    // compiled_funcs.CompiledFunction.start
+    // compiled_funcs.CompiledFunction.end
+    // compiled_funcs.CompiledFunction.Frame. \
+    // exception_callsites[iter](src,_)
+    // compiled_funcs.CompiledFunction.Frame. \
+    // exception_callsites[iter](_,dest)
+    // ret
+    // *************************************************
+
+    let mut sym_vec: Vec<String> = Vec::new();
+    let compiled_funcs : &HashMap<_, _> = &vm.compiled_funcs().read().unwrap();
+    debug!("Number of Compiled functions: {}\n", compiled_funcs.len());
+    for (theID, theCFs) in compiled_funcs.iter() {
+        let theCF : &CompiledFunction = &theCFs.read().unwrap();
+        debug!("new theCF\n");
+        match theCF.start {
+            // CF.start can only be relocatable , otherwise panic
+            ValueLocation::Relocatable(_, ref symbol) => {
+                debug!("theCF.start, symbol = {}\n", *symbol);
+                sym_vec.push((*symbol).clone());
+            },
+            // CF.start can't reach this state
+            _ => panic!("Sym_Table_start: expecting Relocatable location, found {}", theCF.start)
+        }
+        match theCF.end {
+            // CF.start can only be relocatable , otherwise panic
+            ValueLocation::Relocatable(_, ref symbol) => {
+                debug!("theCF.end, symbol = {}\n", *symbol);
+                sym_vec.push((*symbol).clone());
+            },
+            // CF.end can't reach this state
+            _ => panic!("Sym_Table_end: expecting Relocatable location, found {}", theCF.end)
+        }
+        debug!("Number of exp callsites = {}\n", theCF.frame.get_exception_callsites().len());
+        for &(ref callsite, ref dest) in theCF.frame.get_exception_callsites().iter(){
+            debug!("exception callsite, step 1\n");
+            match *callsite {
+                ValueLocation::Relocatable(_, ref symbol) => {
+                    debug!("exception callsite, step 2, callsite symbol = {}\n", *symbol);
+                    sym_vec.push((*symbol).clone());
+                },
+                // can't reach this state
+                _ => panic!("Sym_Table_callsite: expecting Relocatable location, found {}", callsite)
+            }
+            match *dest {
+                ValueLocation::Relocatable(_, ref symbol) => {
+                    debug!("exception callsite, step 3, dest symbol = {}\n", *symbol);
+                    sym_vec.push((*symbol).clone());
+                },
+                // can't reach this state
+                _ => panic!("Sym_Table_callsite: expecting Relocatable location, found {}", dest)
+            }
+        }
+    }
+    // **************************************************
+    // To generate the following code
+    // .data
+    // .globl mu_sym_table
+    // mu_sym_table:
+    // for each symbol {
+    //      .quad "symbol_name".length()
+    //      __symbol_name:
+    //      .ascii "symbol_name"
+    //      .quad 0
+    // }
+    // *************************************************
+    file_st.write("\t.data\n".as_bytes()).unwrap();
+
+    file_st.write_fmt(format_args!("\t{}\n", directive_globl("mu_sym_table".to_string()))).unwrap();
+    file_st.write_fmt(format_args!("mu_sym_table:\n")).unwrap();
+    file_st.write_fmt(format_args!(".quad {}\n", sym_vec.len())).unwrap();
+    for i in 0..sym_vec.len(){
+        file_st.write_fmt(format_args!(".quad {}\n", sym_vec[i].len())).unwrap();
+        file_st.write_fmt(format_args!(".ascii \"{}\"\n", sym_vec[i])).unwrap();
+        //        file_st.write_fmt(format_args!("__{}:\n", sym_vec[i])).unwrap();
+        file_st.write_fmt(format_args!(".quad {}\n", sym_vec[i])).unwrap();
+    }
+    //**************************************************
+    // Javad's code for generating sym_table ends here
+    // __
+    // *************************************************
+}
+
+
 use std::collections::HashMap;
 use compiler::backend::code_emission::emit_mu_types;
 
@@ -3669,6 +3797,8 @@ pub fn emit_context_with_reloc(vm: &VM,
     //        let primordial = primordial.as_ref().unwrap();
     //    }
 
+    emit_sym_table(vm);
+
     debug!("---finish---");
 }
 
@@ -3706,14 +3836,18 @@ fn directive_comm(name: String, size: ByteSize, align: ByteSize) -> String {
     format!(".comm {},{},{}", name, size, align)
 }
 
+#[cfg(not(feature = "sel4-rumprun"))]
 #[cfg(target_os = "linux")]
 pub fn symbol(name: String) -> String {
     name
 }
+
+#[cfg(not(feature = "sel4-rumprun"))]
 #[cfg(target_os = "macos")]
 pub fn symbol(name: String) -> String {
     format!("_{}", name)
 }
+
 // same as Linux
 #[cfg(feature = "sel4-rumprun")]
 pub fn symbol(name: String) -> String {
@@ -3722,11 +3856,13 @@ pub fn symbol(name: String) -> String {
 
 
 #[allow(dead_code)]
+#[cfg(not(feature = "sel4-rumprun"))]
 #[cfg(target_os = "linux")]
 pub fn pic_symbol(name: String) -> String {
     format!("{}@GOTPCREL", name)
 }
 #[allow(dead_code)]
+#[cfg(not(feature = "sel4-rumprun"))]
 #[cfg(target_os = "macos")]
 pub fn pic_symbol(name: String) -> String {
     symbol(name)

src/compiler/backend/arch/x86_64/inst_sel.rs

@@ -3943,15 +3943,15 @@ impl <'a> InstructionSelection {
                                 self.backend.emit_mov_r64_imm64(&tmp_h, vals[1] as i64);
                             },
                             &Constant::FuncRef(func_id) => {
-                                if cfg!(target_os = "macos") {
+                                if cfg!(feature = "sel4-rumprun") {
+                                    let mem = self.get_mem_for_funcref(func_id, vm);
+                                    self.backend.emit_mov_r_mem(&tmp, &mem);
+                                } else if cfg!(target_os = "macos") {
                                     let mem = self.get_mem_for_funcref(func_id, vm);
                                     self.backend.emit_lea_r64(&tmp, &mem);
                                 } else if cfg!(target_os = "linux") {
                                     let mem = self.get_mem_for_funcref(func_id, vm);
                                     self.backend.emit_mov_r_mem(&tmp, &mem);
-                                } else if cfg!(feature = "sel4-rumprun") {
-                                    let mem = self.get_mem_for_funcref(func_id, vm);
-                                    self.backend.emit_mov_r_mem(&tmp, &mem);
                                 } else {
                                     unimplemented!()
                                 }
@@ -4117,17 +4117,7 @@ impl <'a> InstructionSelection {
                             unimplemented!()
                         } else {
                             // symbolic
-                            if cfg!(target_os = "macos") {
-                                P(Value {
-                                    hdr: MuEntityHeader::unnamed(vm.next_id()),
-                                    ty: types::get_referent_ty(&pv.ty).unwrap(),
-                                    v: Value_::Memory(MemoryLocation::Symbolic {
-                                        base: Some(x86_64::RIP.clone()),
-                                        label: pv.name().unwrap(),
-                                        is_global: true,
-                                    })
-                                })
-                            } else if cfg!(target_os = "linux") {
+                            if cfg!(feature = "sel4-rumprun") {
                                 // for a(%RIP), we need to load its address from a@GOTPCREL(%RIP)
                                 // then load from the address.
                                 // asm_backend will emit a@GOTPCREL(%RIP) for a(%RIP)
@@ -4146,7 +4136,17 @@ impl <'a> InstructionSelection {
                                 self.emit_move_value_to_value(&actual_loc, &got_loc);
 
                                 self.make_memory_op_base_offset(&actual_loc, 0, types::get_referent_ty(&pv.ty).unwrap(), vm)
-                            } else if cfg!(feature = "sel4-rumprun") {
+                            } else if cfg!(target_os = "macos") {
+                                P(Value {
+                                    hdr: MuEntityHeader::unnamed(vm.next_id()),
+                                    ty: types::get_referent_ty(&pv.ty).unwrap(),
+                                    v: Value_::Memory(MemoryLocation::Symbolic {
+                                        base: Some(x86_64::RIP.clone()),
+                                        label: pv.name().unwrap(),
+                                        is_global: true,
+                                    })
+                                })
+                            } else if cfg!(target_os = "linux") {
                                 // for a(%RIP), we need to load its address from a@GOTPCREL(%RIP)
                                 // then load from the address.
                                 // asm_backend will emit a@GOTPCREL(%RIP) for a(%RIP)

src/compiler/backend/mod.rs

@@ -27,6 +27,8 @@ pub const WORD_SIZE : ByteSize = 8;
 
 pub const AOT_EMIT_CONTEXT_FILE : &'static str = "context.s";
 
+pub const AOT_EMIT_SYM_TABLE_FILE : &'static str = "mu_sym_table.s";
+
 // this is not full name, but pro/epilogue name is generated from this
 pub const PROLOGUE_BLOCK_NAME: &'static str = "prologue";
 pub const EPILOGUE_BLOCK_NAME: &'static str = "epilogue";

src/gc/Cargo.toml

@@ -24,6 +24,8 @@ crate-type = ["rlib"]
 [features]
 default = []
 use-sidemap = []
+sel4-rumprun = []
+sel4-rumprun-target-side = []
 
 [build-dependencies]
 gcc = "0.3"

src/gc/build.rs

@@ -14,32 +14,61 @@
 
 extern crate gcc;
 
+//#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[cfg(any(target_os = "macos", target_os = "linux"))]
 #[cfg(target_arch = "x86_64")]
-fn main() {
+fn build_libgc(){
+    println!("detected macos or linux");
     gcc::compile_library("libgc_clib_x64.a", &["src/heap/gc/clib_x64.c"]);
 }
 
+//#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[cfg(target_os = "linux")]
 #[cfg(target_arch = "aarch64")]
-fn main() {
+fn build_libgc() {
+    println!("detected linux aarch64");
     gcc::compile_library("libgc_clib_aarch64.a", &["src/heap/gc/clib_aarch64.S"]);
 }
 
 // This is here to enable cross compiling from windows/x86_64 to linux/aarch64
+//#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[cfg(target_os = "windows")]
 #[cfg(target_arch = "x86_64")]
-fn main() {
+fn build_libgc() {
+    println!("detected windows 64");
     gcc::compile_library("libgc_clib_aarch64.a", &["src/heap/gc/clib_aarch64.S"]);
 }
 
-#[cfg(feature = "sel4-rumprun")]
-#[cfg(target_arch = "x86_64")]
+
+//#[cfg(all(target_os = "netbsd", target_vendor = "rumprun"))]
+//#[cfg(feature = "sel4-rumprun-target-side")]
+//#[cfg(target_arch = "x86_64")]
 fn main() {
-    let mut compiler_name = String::new();
-    compiler_name.push_str("x86_64-rumprun-netbsd-gcc");
-    gcc::Config::new().flag("-O3").flag("-c")
-        .compiler(Path::new(compiler_name.as_str()))
-        .file("src/heap/gc/clib_x64_sel4_rumprun.c")
-        .compile("libgc_clib_x64_sel4_rumprun.a");
-}
\ No newline at end of file
+    use std::env;
+    let mut gc_target = 0;  // 1 for rumprun-sel4 and 0 otherwise
+    for (key, value) in env::vars() {
+        if key == "ZEBU_TARGET" {
+            if value == "x86_64-rumprun-netbsd" {
+                gc_target = 1;
+                break;
+            }
+            else {
+                gc_target = 0;
+                break;
+            }
+        }
+    }
+    // for sel4-rumprun, do (if)
+    // otherwise, call the related target function
+    if gc_target == 1 {
+        use std::path::Path;
+        println!("detected rumprun-netbsd");
+        let mut compiler_name = String::new();
+        compiler_name.push_str("x86_64-rumprun-netbsd-gcc");
+        gcc::Config::new().flag("-O3").flag("-c")
+            .compiler(Path::new(compiler_name.as_str()))
+            .file("src/heap/gc/clib_x64_sel4_rumprun.c")
+            .compile("libgc_clib_x64.a");
+    }
+    else { build_libgc(); }
+}

src/gc/src/heap/gc/clib_x64_sel4_rumprun.c

@@ -13,9 +13,11 @@
 // limitations under the License.
 
 #include <inttypes.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+#include <pthread.h>
 
 void* malloc_zero(size_t size) {
     void* ret = malloc(size);

src/gc/src/heap/gc/mod.rs

@@ -87,18 +87,6 @@ extern "C" {
     fn get_registers_count() -> i32;
 }
 
-#[cfg(target_arch = "x86_64")]
-#[cfg(feature = "sel4-rumprun")]
-#[link(name = "gc_clib_x64_sel4_rumprun")]
-extern "C" {
-    pub fn malloc_zero(size: usize) -> *const c_void;
-    fn immmix_get_stack_ptr() -> Address;
-    pub fn set_low_water_mark();
-    fn get_low_water_mark() -> Address;
-    fn get_registers() -> *const Address;
-    fn get_registers_count() -> i32;
-}
-
 pub fn stack_scan() -> Vec<ObjectReference> {
     trace!("stack scanning...");
     let stack_ptr : Address = unsafe {immmix_get_stack_ptr()};

src/gc/tests/lib.rs

@@ -12,6 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod test_gc_harness;
+pub mod test_gc_harness;
 mod test_gcbench;
 mod test_gc_linked_list;

src/gc/tests/test_gc_harness.rs

@@ -65,7 +65,7 @@ const FIXSIZE_REFx1_ENCODE : u64 = 0xb000000000000001u64;
 
 
 #[test]
-fn test_exhaust_alloc() {
+pub fn test_exhaust_alloc() {
     gc::gc_init(IMMIX_SPACE_SIZE, LO_SPACE_SIZE, 8, false);
     let mut mutator = gc::new_mutator();
 

src/lib.rs

-// Copyright 2017 The Australian National University
-// 
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// 
-//     http://www.apache.org/licenses/LICENSE-2.0
-// 
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
+// Copyright 2017 The Australian National University
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![feature(cfg_target_vendor)]
+
 #[macro_use]
 extern crate lazy_static;
 #[macro_use]

src/runtime/mod.rs

@@ -44,7 +44,8 @@ pub mod exception;
 // consider using libloading crate instead of the raw c functions for dynalic libraries
 // however i am not sure if libloading can load symbols from current process (not from an actual dylib)
 // so here i use dlopen/dlsym from C
-#[cfg(not(feature = "sel4-rumprun"))]
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
+//#[cfg(not(all(target_os = "netbsd", target_vendor = "rumprun")))]
 #[link(name="dl")]
 extern "C" {
     fn dlopen(filename: *const c_char, flags: isize) -> *const c_void;
@@ -52,7 +53,8 @@ extern "C" {
     fn dlerror() -> *const c_char;
 }
 
-#[cfg(not(feature = "sel4-rumprun"))]
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
+//#[cfg(not(all(target_os = "netbsd", target_vendor = "rumprun")))]
 pub fn resolve_symbol(symbol: String) -> Address {
     use std::ptr;
 
@@ -76,8 +78,9 @@ pub fn resolve_symbol(symbol: String) -> Address {
 // This function is specific to sel4-rumprun platform
 // it replaces the resolve_symbol function provided by Linux and Mac
 // all other platforms (except sel4-rumprun) already provide this function
-#[cfg(feature = "sel4-rumprun")]
-#[link(name="c_helpers")]
+#[cfg(feature = "sel4-rumprun-target-side")]
+//#[cfg(all(target_os = "netbsd", target_vendor = "rumprun"))]
+#[link(name="zebu_c_helpers")]
 extern "C" {
     fn c_resolve_symbol(symbol: *const c_char) -> *const c_void;
 }
@@ -102,8 +105,10 @@ extern "C" {
 
 // TODO
 // resolve symbol is different from the one used for Linux and Mac
-#[cfg(feature = "sel4-rumprun")]
+#[cfg(feature = "sel4-rumprun-target-side")]
+//#[cfg(all(target_os = "netbsd", target_vendor = "rumprun"))]
 pub fn resolve_symbol(symbol: String) -> Address {
+    debug!("Going to resolve Symbol -{}-", symbol);
     let ret = unsafe { c_resolve_symbol(CString::new(symbol.clone()).unwrap().as_ptr()) };
     if ret.is_null() {
         panic!("failed to resolve symbol: {}", symbol.clone());
@@ -260,7 +265,7 @@ pub extern fn mu_main(serialized_vm : *const c_char, argc: c_int, argv: *const *
     debug!("mu_main() started...");
     
     let str_vm = unsafe{CStr::from_ptr(serialized_vm)}.to_str().unwrap();
-    
+
     let vm : Arc<VM> = Arc::new(VM::resume_vm(str_vm));
     
     let primordial = vm.primordial.read().unwrap();
@@ -271,7 +276,6 @@ pub extern fn mu_main(serialized_vm : *const c_char, argc: c_int, argv: *const *
         
         // create mu stack
         let stack = vm.new_stack(primordial.func_id);
-
         // if the primordial named some const arguments, we use the const args
         // otherwise we push 'argc' and 'argv' to new stack
         let args : Vec<ValueLocation> = if primordial.has_const_args {
@@ -287,11 +291,9 @@ pub extern fn mu_main(serialized_vm : *const c_char, argc: c_int, argv: *const *
 
             args
         };
-        
         // FIXME: currently assumes no user defined thread local
         // will need to fix this after we can serialize heap object
         let thread = thread::MuThread::new_thread_normal(stack, unsafe{Address::zero()}, args, vm.clone());
-        
         thread.join().unwrap();
     }
 }

src/runtime/runtime_x64_sel4_rumprun_sysv.c

@@ -22,6 +22,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <pthread.h>
+#include <assert.h>
 
 int tls_initialized = 0;
 
@@ -63,6 +64,10 @@ void muentry_set_retval(int32_t x) {
     mu_retval = x;
 }
 
+int32_t muentry_get_retval() {
+    return mu_retval;
+}
+
 int32_t c_check_result() {
     return mu_retval;
 }
\ No newline at end of file

src/runtime/thread.rs

@@ -320,6 +320,7 @@ impl fmt::Display for MuThread {
 
 #[cfg(target_arch = "aarch64")]
 #[cfg(any(target_os = "macos", target_os = "linux"))]
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[link(name = "swap_stack")]
 extern "C" {
     fn swap_to_mu_stack(new_sp: Address, entry: Address, old_sp_loc: Address);
@@ -331,6 +332,7 @@ extern "C" {
 
 #[cfg(target_arch = "aarch64")]
 #[cfg(any(target_os = "macos", target_os = "linux"))]
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[link(name = "runtime")]
 #[allow(improper_ctypes)]
 extern "C" {
@@ -341,6 +343,7 @@ extern "C" {
 
 #[cfg(target_arch = "x86_64")]
 #[cfg(any(target_os = "macos", target_os = "linux"))]
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[link(name = "runtime")]
 extern "C" {
     pub fn set_thread_local(thread: *mut MuThread);
@@ -350,6 +353,7 @@ extern "C" {
 
 #[cfg(target_arch = "x86_64")]
 #[cfg(any(target_os = "macos", target_os = "linux"))]
+#[cfg(not(feature = "sel4-rumprun-target-side"))]
 #[link(name = "swap_stack")]
 extern "C" {
     fn swap_to_mu_stack(new_sp: Address, entry: Address, old_sp_loc: Address);
@@ -360,7 +364,8 @@ extern "C" {
 }
 
 #[cfg(target_arch = "x86_64")]
-#[cfg(feature = "sel4-rumprun")]
+//#[cfg(all(target_os = "netbsd", target_vendor = "rumprun"))]
+#[cfg(feature = "sel4-rumprun-target-side")]
 #[link(name = "runtime")]
 extern "C" {
     pub fn set_thread_local(thread: *mut MuThread);
@@ -369,7 +374,8 @@ extern "C" {
 }
 
 #[cfg(target_arch = "x86_64")]
-#[cfg(feature = "sel4-rumprun")]
+//#[cfg(all(target_os = "netbsd", target_vendor = "rumprun"))]
+#[cfg(feature = "sel4-rumprun-target-side")]
 #[link(name = "swap_stack")]
 extern "C" {
     fn swap_to_mu_stack(new_sp: Address, entry: Address, old_sp_loc: Address);

src/testutil/aot.rs

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+extern crate time;
+
 use testutil::*;
 use ast::ir::MuName;
 use runtime;
@@ -21,6 +23,7 @@ use compiler::backend;
 use std::path::PathBuf;
 use std::process::Command;
 use std::process::Output;
+use std::process::Stdio;
 
 fn link_executable_internal (files: Vec<PathBuf>, lib: &Vec<String>, libpath: &Vec<String>, out: PathBuf) -> PathBuf {
     let mut cc = Command::new(get_test_clang_path());
@@ -288,3 +291,242 @@ pub fn link_dylib_with_extra_srcs(funcs: Vec<MuName>, srcs: Vec<String>, out: &s
                         &vm.vm_options.flag_bootimage_external_libpath,
                         out_path)
 }
+
+#[cfg(not(feature = "sel4-rumprun"))]
+pub fn run_test(vm: &VM, test_name: &str, tester_name: &str){
+    let output_name = test_name.to_string()+ "_" + tester_name;
+    let executable = link_test_primordial(vec![test_name.to_string(), tester_name.to_string()], output_name.as_str(), vm);
+    execute(executable);
+}
+
+#[cfg(feature = "sel4-rumprun")]
+pub fn run_test(vm: &VM, test_name: &str, tester_name: &str){
+
+    use std::fs::File;