Merge remote-tracking branch 'origin/develop' into open-source

Cargo.toml

+# 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.
+
 [package]
 name = "mu"
 version = "0.0.1"
@@ -21,6 +35,7 @@ ast = {path = "src/ast"}
 utils = {path = "src/utils"}
 gc = {path = "src/gc"}
 
+
 field-offset = "0.1.1"
 libloading = "0.3"
 lazy_static = "0.1.15"
@@ -34,4 +49,5 @@ time = "0.1.34"
 maplit = "0.1.4"
 docopt = "0.6"
 petgraph = "0.4.1"
-extprim = "*"
\ No newline at end of file
+extprim = "*"
+num-traits = "*"

build.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.
+
 extern crate gcc;
 
 #[cfg(any(target_os = "macos", target_os = "linux"))]

ci.sh

+# 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.
+
+set -e
+if [ -z "$MU_ZEBU" ]
+then
+	export MU_ZEBU=$PWD
+fi
+export MU_LOG_LEVEL=none
+export RUST_TEST_THREADS=1
+export RUST_BACKTRACE=0
+export PYTHONPATH="$MU_ZEBU/tests/test_jit/mu-client-pypy/:$MU_ZEBU/tests/test_jit/RPySOM/src"
+export LD_LIBRARY_PATH="$MU_ZEBU/tests/test_jit/:$MU_ZEBU/tests/test_jit"
+export ZEBU_BUILD=release
+
+rm -rf $MU_ZEBU/emit
+rm -rf $MU_ZEBU/tests/test_jit/emit
+
+#cargo clean
+cargo test --release --no-run --color=always 2>&1 | tee build_out.txt
+
+/usr/bin/time -f "finished in %e secs" -a -o cargo_test_out.txt ./test-release --color=always 2>/dev/null | tee cargo_test_out.txt
+
+cd $MU_ZEBU/tests/test_jit/mu-client-pypy
+git pull
+
+cd $MU_ZEBU/tests/test_jit/RPySOM
+git pull
+
+cd $MU_ZEBU/tests/test_jit/
+ZEBU_BUILD=release LD_LIBRARY_PATH=. PYTHONPATH=mu-client-pypy:RPySOM/src pytest test_*.py -v --color=yes 2>&1 | tee $MU_ZEBU/pytest_out.txt
+

src/ast/Cargo.toml

+# 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.
+
 [package]
 name = "ast"
 version = "0.0.1"

src/ast/src/inst.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.
+
 use ir::*;
 use ptr::*;
 use types::*;
@@ -116,7 +130,8 @@ impl Instruction {
             | CommonInst_Pin(_)
             | CommonInst_Unpin(_)
             | Move(_)
-            | PrintHex(_) => false,
+            | PrintHex(_)
+            | SetRetval(_) => false,
             Return(_)
             | ThreadExit
             | Throw(_)
@@ -189,7 +204,8 @@ impl Instruction {
             CommonInst_Pin(_) => true,
             CommonInst_Unpin(_) => true,
             Move(_) => false,
-            PrintHex(_) => true
+            PrintHex(_) => true,
+            SetRetval(_) => true,
         }
     }
 
@@ -243,7 +259,8 @@ impl Instruction {
             | CommonInst_Pin(_)
             | CommonInst_Unpin(_)
             | Move(_)
-            | PrintHex(_) => false
+            | PrintHex(_)
+            | SetRetval(_) => false
         }
     }
 
@@ -302,7 +319,8 @@ impl Instruction {
             | CommonInst_Pin(_)
             | CommonInst_Unpin(_)
             | Move(_)
-            | PrintHex(_) => None
+            | PrintHex(_)
+            | SetRetval(_) => None
         }
     }
 
@@ -555,7 +573,9 @@ pub enum Instruction_ {
     /// internal use: move from value to value
     Move(OpIndex),
     /// internal use: print op as hex value
-    PrintHex(OpIndex)
+    PrintHex(OpIndex),
+    /// internal use: set return value for main
+    SetRetval(OpIndex)
 }
 
 impl Instruction_ {
@@ -682,7 +702,9 @@ impl Instruction_ {
             // move
             &Instruction_::Move(from) => format!("MOVE {}", ops[from]),
             // print hex
-            &Instruction_::PrintHex(i) => format!("PRINTHEX {}", ops[i])
+            &Instruction_::PrintHex(i) => format!("PRINTHEX {}", ops[i]),
+            // set retval
+            &Instruction_::SetRetval(val) => format!("SETRETVAL {}", ops[val]),
         }
     }
 }

src/ast/src/ir.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.
+
 use ptr::P;
 use types::*;
 use inst::*;
@@ -781,6 +795,14 @@ impl Value {
         })
     }
 
+    pub fn is_int_ex_const(&self) -> bool {
+        match self.v {
+            Value_::Constant(Constant::IntEx(_)) => true,
+            _ => false
+        }
+    }
+
+
     pub fn is_int_const(&self) -> bool {
         match self.v {
             Value_::Constant(Constant::Int(_)) => true,
@@ -788,6 +810,14 @@ impl Value {
             _ => false
         }
     }
+
+    pub fn is_fp_const(&self) -> bool {
+        match self.v {
+            Value_::Constant(Constant::Float(_)) => true,
+            Value_::Constant(Constant::Double(_)) => true,
+            _ => false
+        }
+    }
     
     pub fn extract_int_const(&self) -> Option<u64> {
         match self.v {
@@ -797,6 +827,13 @@ impl Value {
         }
     }
 
+    pub fn extract_int_ex_const(&self) -> Vec<u64> {
+        match self.v {
+            Value_::Constant(Constant::IntEx(ref val)) => val.clone(),
+            _ => panic!("expect int ex const")
+        }
+    }
+
     pub fn extract_ssa_id(&self) -> Option<MuID> {
         match self.v {
             Value_::SSAVar(id) => Some(id),

src/ast/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.
+
 //! # MuIR AST crate
 //!
 //! This crate provides data structures to allow construct MuIR in Rust code, including:

src/ast/src/op.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.
+
 #[derive(Copy, Clone, Debug, PartialEq, RustcEncodable, RustcDecodable)]
 pub enum BinOp {
     // BinOp Int(n) Int(n) -> Int(n)
@@ -83,7 +97,7 @@ impl CmpOp {
             FUGT => FULT,
             FULT => FUGT,
 
-            _ => self, // all other comparisons are reflexive
+            _ => self, // all other comparisons are symmetric
         }
     }
 
@@ -132,6 +146,18 @@ impl CmpOp {
         }
     }
 
+    // gets the unsigned version of the comparison
+    pub fn get_unsigned(self) -> CmpOp {
+        use op::CmpOp::*;
+        match self {
+            SGE => UGE,
+            SLT => ULT,
+            SGT => UGT,
+            SLE => ULE,
+            _   => self,
+        }
+    }
+
     pub fn is_signed(self) -> bool {
         use op::CmpOp::*;
         match self {
@@ -156,6 +182,14 @@ impl CmpOp {
             _ => false
         }
     }
+
+    pub fn is_symmetric(self) -> bool {
+        use op::CmpOp::*;
+        match self {
+            EQ | NE | FORD| FUNO| FUNE | FUEQ | FONE | FOEQ => true,
+            _ => false
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, RustcEncodable, RustcDecodable)]

src/ast/src/ptr.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 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 use std::sync::Arc;
 
 /// P<T> is alias type for sharable Mu AST components (such as Value, MuFuncSig, MuType, etc)

src/ast/src/types.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.
+
 use ptr::P;
 use ir::*;
 
@@ -49,7 +63,11 @@ lazy_static! {
     pub static ref VOID_TYPE : P<MuType> = P(
         MuType::new(new_internal_id(), MuType_::void())
     );
-    
+
+    pub static ref REF_VOID_TYPE : P<MuType> = P(
+        MuType::new(new_internal_id(), MuType_::muref(VOID_TYPE.clone()))
+    );
+
     pub static ref INTERNAL_TYPES : Vec<P<MuType>> = vec![
         ADDRESS_TYPE.clone(),
         UINT1_TYPE.clone(),
@@ -60,8 +78,10 @@ lazy_static! {
         UINT128_TYPE.clone(),
         FLOAT_TYPE.clone(),
         DOUBLE_TYPE.clone(),
-        VOID_TYPE.clone()
-    ];    
+        FLOAT_TYPE.clone(),
+        VOID_TYPE.clone(),
+        REF_VOID_TYPE.clone(),
+    ];
 }
 
 /// clear struct/hybrid maps, called when creating new VM

src/compiler/backend/arch/aarch64/codegen.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.
+
 use ast::ptr::P;
 use ast::ir::*;
 use runtime::ValueLocation;
@@ -23,8 +37,10 @@ pub trait CodeGenerator {
     fn end_block(&mut self, block_name: MuName);
 
     // add CFI info
+    fn add_cfi_sections(&mut self, arg: &str);
     fn add_cfi_startproc(&mut self);
     fn add_cfi_endproc(&mut self);
+    fn add_cfi_def_cfa(&mut self, reg: Reg, offset: i32);
     fn add_cfi_def_cfa_register(&mut self, reg: Reg);
     fn add_cfi_def_cfa_offset(&mut self, offset: i32);
     fn add_cfi_offset(&mut self, reg: Reg, offset: i32);
@@ -35,6 +51,10 @@ pub trait CodeGenerator {
     fn emit_frame_grow(&mut self); // Emits a SUB
     fn emit_frame_shrink(&mut self); // Emits an ADD
 
+    // Used to pass a string that the assembler will interpret as an immediate argument
+    // (This is neccesary to support the use of ELF relocations like ':tprel_hi12:foo')
+    fn emit_add_str(&mut self, dest: Reg, src1: Reg, src2: &str);
+
     // stack minimpulation
     fn emit_push_pair(&mut self, src1: Reg, src2: Reg, stack: Reg); // Emits a STP
     fn emit_pop_pair(&mut self, dest1: Reg, dest2: Reg, stack: Reg); // Emits a LDP

src/compiler/backend/arch/x86_64/asm_backend.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.
+
+#![allow(unused_variables)]
+
 use compiler::backend::AOT_EMIT_CONTEXT_FILE;
 use compiler::backend::RegGroup;
 use utils::ByteSize;
@@ -1221,7 +1237,7 @@ impl ASMCodeGen {
     fn prepare_machine_regs(&self, regs: Iter<P<Value>>) -> Vec<MuID> {
         regs.map(|x| self.prepare_machine_reg(x)).collect()
     }
-    
+
     /// prepares information for a memory operand, returns (operand string (as in asm), reg/tmp locations)
     /// This function turns memory operands into something like "offset(base, scale, index)" or
     /// "label(base)"
@@ -3111,7 +3127,7 @@ impl CodeGenerator for ASMCodeGen {
         let asm = format!("mfence");
         self.add_asm_inst(asm, linked_hashmap!{}, linked_hashmap!{}, false);
     }
-    
+
     fn emit_push_r64(&mut self, src: &P<Value>) {
         trace!("emit: push {}", src);
         

src/compiler/backend/arch/x86_64/codegen.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.
+
 use ast::ptr::P;
 use ast::ir::*;
 use runtime::ValueLocation;

src/compiler/backend/arch/x86_64/mod.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.
+
 #![allow(dead_code)]
 
 /// Tree pattern matching instruction selection.
@@ -21,6 +35,7 @@ pub use compiler::backend::x86_64::asm_backend::emit_context;
 pub use compiler::backend::x86_64::asm_backend::emit_context_with_reloc;
 #[cfg(feature = "aot")]
 pub use compiler::backend::x86_64::asm_backend::spill_rewrite;
+use utils::Address;
 
 use ast::ptr::P;
 use ast::ir::*;
@@ -30,6 +45,9 @@ use compiler::backend::RegGroup;
 use utils::LinkedHashMap;
 use std::collections::HashMap;
 
+// number of normal callee saved registers (excluding RSP and RBP)
+pub const CALLEE_SAVED_COUNT : usize = 5;
+
 /// a macro to declare a set of general purpose registers that are aliased to the first one
 macro_rules! GPR_ALIAS {
     ($alias: ident: ($id64: expr, $r64: ident) -> $r32: ident, $r16: ident, $r8l: ident, $r8h: ident) => {
@@ -499,6 +517,49 @@ pub fn pick_group_for_reg(reg_id: MuID) -> RegGroup {
     RegGroup::get_from_value(reg)
 }
 
+/// gets the previouse frame pointer with respect to the current
+#[inline(always)]
+pub fn get_previous_frame_pointer(frame_pointer: Address) -> Address {
+    unsafe { frame_pointer.load::<Address>() }
+}
+
+/// gets the return address for the current frame pointer
+#[inline(always)]
+pub fn get_return_address(frame_pointer: Address) -> Address {
+    unsafe { frame_pointer.plus(8).load::<Address>() }
+}
+
+/// gets the stack pointer before the current frame was created
+#[inline(always)]
+pub fn get_previous_stack_pointer(frame_pointer: Address) -> Address {
+    frame_pointer.plus(16)
+}
+
+/// sets the stack point
+#[inline(always)]
+pub fn set_previous_frame_pointer(frame_pointer: Address, value: Address) {
+    unsafe { frame_pointer.store::<Address>(value) }
+}
+
+/// gets the return address for the current frame pointer
+#[inline(always)]
+pub fn set_return_address(frame_pointer: Address, value: Address) {
+    unsafe { frame_pointer.plus(8).store::<Address>(value) }
+}
+
+/// returns offset of callee saved register
+/// Reg should be a 64-bit callee saved GPR or FPR
+pub fn get_callee_saved_offset(reg: MuID) -> isize {
+    debug_assert!(is_callee_saved(reg) && reg != RBP.id());
+
+    let id = if reg == RBX.id() {
+        0
+    } else {
+        (reg - R12.id())/4 + 1
+    };
+    (id as isize + 1)*(-8)
+}
+
 /// is a machine register (by ID) callee saved?
 /// returns false if the ID is not a machine register
 pub fn is_callee_saved(reg_id: MuID) -> bool {
@@ -513,12 +574,17 @@ pub fn is_callee_saved(reg_id: MuID) -> bool {
 
 /// is a constant a valid x86_64 immediate number (32 bits integer)?
 pub fn is_valid_x86_imm(op: &P<Value>) -> bool {
-    use std::u32;
-    match op.v {
-        Value_::Constant(Constant::Int(val)) if val <= u32::MAX as u64 => {
-            true
-        },
-        _ => false
+    use std::i32;
+
+    if op.ty.get_int_length().is_some() && op.ty.get_int_length().unwrap() <= 32 {
+        match op.v {
+            Value_::Constant(Constant::Int(val)) if val as i32 >= i32::MIN && val as i32 <= i32::MAX => {
+                true
+            },
+            _ => false
+        }
+    } else {
+        false
     }
 }
 
@@ -570,7 +636,8 @@ pub fn estimate_insts_for_ir(inst: &Instruction) -> usize {
 
         // others
         Move(_) => 0,
-        PrintHex(_) => 10,
+        PrintHex(_)  => 10,
+        SetRetval(_) => 10,
         ExnInstruction{ref inner, ..} => estimate_insts_for_ir(&inner)
     }
 }

src/compiler/backend/code_emission.rs

+// Copyright 2017 The Australian National University
+//