Remove some cretonne bug workarounds and add ir comments

diff --git a/0001-Disable-stdsimd-in-libcore.patch b/0001-Disable-stdsimd-in-libcore.patch
new file mode 100644 (file)
index 0000000..5521bea
--- /dev/null
+++ b/0001-Disable-stdsimd-in-libcore.patch
@@ -0,0 +1,29 @@
+From cc175e6a3f59c7fe1523fd441214e0303f8fee80 Mon Sep 17 00:00:00 2001
+From: bjorn3 <bjorn3@users.noreply.github.com>
+Date: Sat, 30 Jun 2018 12:30:30 +0200
+Subject: [PATCH] Disable stdsimd in libcore
+
+---
+ src/libcore/lib.rs | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
+index 40caee8554..f038d155a1 100644
+--- a/src/libcore/lib.rs
++++ b/src/libcore/lib.rs
+@@ -240,6 +240,7 @@ macro_rules! test_v256 { ($item:item) => {}; }
+ macro_rules! test_v512 { ($item:item) => {}; }
+ #[allow(unused_macros)]
+ macro_rules! vector_impl { ($([$f:ident, $($args:tt)*]),*) => { $($f!($($args)*);)* } }
++/*
+ #[path = "../stdsimd/coresimd/mod.rs"]
+ #[allow(missing_docs, missing_debug_implementations, dead_code, unused_imports)]
+ #[unstable(feature = "stdsimd", issue = "48556")]
+@@ -252,3 +253,4 @@ pub use coresimd::simd;
+ #[stable(feature = "simd_arch", since = "1.27.0")]
+ #[cfg(not(stage0))]
+ pub use coresimd::arch;
++*/
+-- 
+2.15.2 (Apple Git-101.1)
+

diff --git a/src/base.rs b/src/base.rs
index 5e6fa126c3132bacadd1bfabe6abcc424bc1b226..a044620fd74b2ee91633a54ca2ddc2ad168cb1fe 100644 (file)
--- a/src/base.rs
+++ b/src/base.rs
@@ -158,7 +158,7 @@ fn trans_fn<'a, 'tcx: 'a>(cx: &mut CodegenCx<'a, 'tcx, CurrentBackend>, f: &mut
             offset: None,
         });
         let ty = mir.local_decls[local].ty;
-        let cton_type = ::common::fixup_cton_ty(fx.cton_type(ty).unwrap_or(types::I64));
+        let cton_type = fx.cton_type(ty).unwrap_or(types::I64);
         (local, fx.bcx.append_ebb_param(start_ebb, cton_type), ty, stack_slot)
     }).collect::<Vec<(Local, Value, Ty, StackSlot)>>();
 
@@ -197,23 +197,24 @@ fn trans_fn<'a, 'tcx: 'a>(cx: &mut CodegenCx<'a, 'tcx, CurrentBackend>, f: &mut
             trans_stmt(fx, stmt);
         }
 
-        match &bb_data.terminator().kind {
+        let inst = match &bb_data.terminator().kind {
             TerminatorKind::Goto { target } => {
                 let ebb = fx.get_ebb(*target);
-                fx.bcx.ins().jump(ebb, &[]);
+                fx.bcx.ins().jump(ebb, &[])
             }
             TerminatorKind::Return => {
-                fx.bcx.ins().return_(&[]);
+                fx.bcx.ins().return_(&[])
             }
             TerminatorKind::Assert { cond, expected, msg: _, target, cleanup: _ } => {
                 let cond = trans_operand(fx, cond).load_value(fx);
                 let target = fx.get_ebb(*target);
-                if *expected {
-                    fx.bcx.ins().brz(cond, target, &[]);
+                let inst = if *expected {
+                    fx.bcx.ins().brz(cond, target, &[])
                 } else {
-                    fx.bcx.ins().brnz(cond, target, &[]);
-                }
+                    fx.bcx.ins().brnz(cond, target, &[])
+                };
                 fx.bcx.ins().trap(TrapCode::User(!0));
+                inst
             }
 
             TerminatorKind::SwitchInt { discr, switch_ty, values, targets } => {
@@ -224,9 +225,10 @@ fn trans_fn<'a, 'tcx: 'a>(cx: &mut CodegenCx<'a, 'tcx, CurrentBackend>, f: &mut
                     jt_data.set_entry(*value as usize, ebb);
                 }
                 let mut jump_table = fx.bcx.create_jump_table(jt_data);
-                fx.bcx.ins().br_table(discr, jump_table);
+                let inst = fx.bcx.ins().br_table(discr, jump_table);
                 let otherwise_ebb = fx.get_ebb(targets[targets.len() - 1]);
                 fx.bcx.ins().jump(otherwise_ebb, &[]);
+                inst
             }
             TerminatorKind::Call { func, args, destination, cleanup: _ } => {
                 let func_ty = func.ty(&fx.mir.local_decls, fx.tcx);
@@ -251,9 +253,9 @@ fn trans_fn<'a, 'tcx: 'a>(cx: &mut CodegenCx<'a, 'tcx, CurrentBackend>, f: &mut
                                 }
                             })
                     ).collect::<Vec<_>>();
-                match func {
+                let inst = match func {
                     CValue::Func(func, _) => {
-                        fx.bcx.ins().call(func, &args);
+                        fx.bcx.ins().call(func, &args)
                     }
                     func => {
                         let func = func.load_value(fx);
@@ -263,18 +265,19 @@ fn trans_fn<'a, 'tcx: 'a>(cx: &mut CodegenCx<'a, 'tcx, CurrentBackend>, f: &mut
                             _ => bug!("Calling non function type {:?}", func_ty),
                         };
                         let sig = fx.bcx.import_signature(cton_sig_from_fn_sig(fx.tcx, sig, fx.param_substs));
-                        fx.bcx.ins().call_indirect(sig, func, &args);
+                        fx.bcx.ins().call_indirect(sig, func, &args)
                     }
-                }
+                };
                 if let Some((_, dest)) = *destination {
                     let ret_ebb = fx.get_ebb(dest);
                     fx.bcx.ins().jump(ret_ebb, &[]);
                 } else {
                     fx.bcx.ins().trap(TrapCode::User(!0));
                 }
+                inst
             }
             TerminatorKind::Resume | TerminatorKind::Abort | TerminatorKind::Unreachable => {
-                fx.bcx.ins().trap(TrapCode::User(!0));
+                fx.bcx.ins().trap(TrapCode::User(!0))
             }
             TerminatorKind::Yield { .. } |
             TerminatorKind::FalseEdges { .. } |
@@ -285,12 +288,16 @@ fn trans_fn<'a, 'tcx: 'a>(cx: &mut CodegenCx<'a, 'tcx, CurrentBackend>, f: &mut
                 // TODO call drop impl
                 // unimplemented!("terminator {:?}", bb_data.terminator());
                 let target_ebb = fx.get_ebb(*target);
-                fx.bcx.ins().jump(target_ebb, &[]);
+                fx.bcx.ins().jump(target_ebb, &[])
             }
             TerminatorKind::GeneratorDrop => {
                 unimplemented!("terminator GeneratorDrop");
             }
-        }
+        };
+
+        let mut terminator_head = "\n".to_string();
+        bb_data.terminator().kind.fmt_head(&mut terminator_head).unwrap();
+        fx.bcx.func.comments[inst] = terminator_head;
     }
 
     fx.bcx.seal_all_blocks();
@@ -298,6 +305,8 @@ fn trans_fn<'a, 'tcx: 'a>(cx: &mut CodegenCx<'a, 'tcx, CurrentBackend>, f: &mut
 }
 
 fn trans_stmt<'a, 'tcx: 'a>(fx: &mut FunctionCx<'a, 'tcx>, stmt: &Statement<'tcx>) {
+    let nop_inst = fx.bcx.ins().nop();
+
     match &stmt.kind {
         StatementKind::SetDiscriminant { place, variant_index } => {
             let place = trans_place(fx, place);
@@ -472,9 +481,15 @@ fn trans_stmt<'a, 'tcx: 'a>(fx: &mut FunctionCx<'a, 'tcx>, stmt: &Statement<'tcx
                 rval => unimplemented!("rval {:?}", rval),
             }
         }
-        StatementKind::StorageLive(_) | StatementKind::StorageDead(_) | StatementKind::Nop => {}
+        StatementKind::StorageLive(_) | StatementKind::StorageDead(_) | StatementKind::Nop => {
+            fx.bcx.ins().nop();
+        }
         _ => unimplemented!("stmt {:?}", stmt),
     }
+
+    let inst = fx.bcx.func.layout.next_inst(nop_inst).unwrap();
+    fx.bcx.func.layout.remove_inst(nop_inst);
+    fx.bcx.func.comments[inst] = format!("{:?}", stmt);
 }
 
 fn trans_int_binop<'a, 'tcx: 'a>(fx: &mut FunctionCx<'a, 'tcx>, bin_op: BinOp, lhs: Value, rhs: Value, ty: Ty<'tcx>, signed: bool, checked: bool) -> CValue<'tcx> {

diff --git a/src/common.rs b/src/common.rs
index 157e3000bd8353f5447e872e5f41d50ffb314566..35e3b9d3657899b351472f814d069fb3512b897a 100644 (file)
--- a/src/common.rs
+++ b/src/common.rs
@@ -51,36 +51,6 @@ fn cton_type_from_ty(ty: Ty) -> Option<types::Type> {
     })
 }
 
-// FIXME(cretonne) fix types smaller than I32
-pub fn fixup_cton_ty(ty: Type) -> Type {
-    match ty {
-        types::I64X2 | types::I64 | types::I32 => ty,
-        _ => types::I32,
-    }
-}
-
-// FIXME(cretonne) fix load.i8
-fn load_workaround(fx: &mut FunctionCx, ty: Type, addr: Value, offset: i32) -> Value {
-    use cretonne::codegen::ir::types::*;
-    match ty {
-        I8 => fx.bcx.ins().uload8(I32, MemFlags::new(), addr, offset),
-        I16 => fx.bcx.ins().uload16(I32, MemFlags::new(), addr, offset),
-        // I32 and I64 work
-        _ => fx.bcx.ins().load(ty, MemFlags::new(), addr, offset),
-    }
-}
-
-// FIXME(cretonne) fix store.i8
-fn store_workaround(fx: &mut FunctionCx, ty: Type, addr: Value, val: Value, offset: i32) {
-    use cretonne::codegen::ir::types::*;
-    match ty {
-        I8 => fx.bcx.ins().istore8(MemFlags::new(), val, addr, offset),
-        I16 => fx.bcx.ins().istore16(MemFlags::new(), val, addr, offset),
-        // I32 and I64 work
-        _ => fx.bcx.ins().store(MemFlags::new(), val, addr, offset),
-    };
-}
-
 #[derive(Debug, Copy, Clone)]
 pub enum CValue<'tcx> {
     ByRef(Value, TyLayout<'tcx>),
@@ -118,9 +88,9 @@ pub fn force_stack<'a>(self, fx: &mut FunctionCx<'a, 'tcx>) -> Value where 'tcx:
 
     pub fn load_value<'a>(self, fx: &mut FunctionCx<'a, 'tcx>) -> Value where 'tcx: 'a{
         match self {
-            CValue::ByRef(value, layout) => {
+            CValue::ByRef(addr, layout) => {
                 let cton_ty = fx.cton_type(layout.ty).expect(&format!("{:?}", layout.ty));
-                load_workaround(fx, cton_ty, value, 0)
+                fx.bcx.ins().load(cton_ty, MemFlags::new(), addr, 0)
             }
             CValue::ByVal(value, _layout) => value,
             CValue::Func(func, _layout) => {
@@ -165,7 +135,6 @@ pub fn value_field<'a>(self, fx: &mut FunctionCx<'a, 'tcx>, field: mir::Field) -
 
     pub fn const_val<'a>(fx: &mut FunctionCx<'a, 'tcx>, ty: Ty<'tcx>, const_val: i64) -> CValue<'tcx> where 'tcx: 'a {
         let cton_ty = fx.cton_type(ty).unwrap();
-        let cton_ty = fixup_cton_ty(cton_ty);
         let layout = fx.layout_of(ty);
         CValue::ByVal(fx.bcx.ins().iconst(cton_ty, const_val), layout)
     }
@@ -229,12 +198,12 @@ pub fn write_cvalue(self, fx: &mut FunctionCx<'a, 'tcx>, from: CValue<'tcx>) {
 
                 if let Some(cton_ty) = fx.cton_type(layout.ty) {
                     let data = from.load_value(fx);
-                    store_workaround(fx, cton_ty, addr, data, 0);
+                    fx.bcx.ins().store(MemFlags::new(), data, addr, 0);
                 } else {
                     for i in 0..size {
                         let from = from.expect_byref();
-                        let byte = load_workaround(fx, types::I8, from.0, i);
-                        store_workaround(fx, types::I8, addr, byte, i);
+                        let byte = fx.bcx.ins().load(types::I8, MemFlags::new(), from.0, i);
+                        fx.bcx.ins().store(MemFlags::new(), byte, addr, i);
                     }
                 }
             }
@@ -288,7 +257,7 @@ pub fn cton_sig_from_mono_fn_sig<'a ,'tcx: 'a>(sig: PolyFnSig<'tcx>) -> Signatur
     };
     Signature {
         params: Some(types::I64).into_iter() // First param is place to put return val
-            .chain(inputs.into_iter().map(|ty| fixup_cton_ty(cton_type_from_ty(ty).unwrap_or(types::I64))))
+            .chain(inputs.into_iter().map(|ty| cton_type_from_ty(ty).unwrap_or(types::I64)))
             .map(AbiParam::new).collect(),
         returns: vec![],
         call_conv,

diff --git a/src/lib.rs b/src/lib.rs
index 39e7a8d82f5782145ae6dbb0558ee488f9260559..5cd275b94db93488cd45dfc5b34fa07d03f3b665 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,5 @@
 #![feature(rustc_private)]
+#![allow(intra_doc_link_resolution_failure)]
 
 extern crate syntax;
 #[macro_use]