Use Cranelift legalization for icmp.i128

[rust.git] / src / num.rs

diff --git a/src/num.rs b/src/num.rs
index 417b9b5f7172ddf37932e7372a1453187bec8856..5acff80768eafcbfc4bcb3d7b89186ab361bed1f 100644 (file)
--- a/src/num.rs
+++ b/src/num.rs
@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-pub fn bin_op_to_intcc(bin_op: BinOp, signed: bool) -> Option<IntCC> {
+pub(crate) fn bin_op_to_intcc(bin_op: BinOp, signed: bool) -> Option<IntCC> {
     use BinOp::*;
     use IntCC::*;
     Some(match bin_op {
@@ -46,12 +46,12 @@ fn codegen_compare_bin_op<'tcx>(
     rhs: Value,
 ) -> CValue<'tcx> {
     let intcc = crate::num::bin_op_to_intcc(bin_op, signed).unwrap();
-    let val = codegen_icmp(fx, intcc, lhs, rhs);
+    let val = fx.bcx.ins().icmp(intcc, lhs, rhs);
     let val = fx.bcx.ins().bint(types::I8, val);
     CValue::by_val(val, fx.layout_of(fx.tcx.types.bool))
 }
 
-pub fn codegen_binop<'tcx>(
+pub(crate) fn codegen_binop<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
     bin_op: BinOp,
     in_lhs: CValue<'tcx>,
@@ -59,15 +59,15 @@ pub fn codegen_binop<'tcx>(
 ) -> CValue<'tcx> {
     match bin_op {
         BinOp::Eq | BinOp::Lt | BinOp::Le | BinOp::Ne | BinOp::Ge | BinOp::Gt => {
-            match in_lhs.layout().ty.sty {
+            match in_lhs.layout().ty.kind {
                 ty::Bool | ty::Uint(_) | ty::Int(_) | ty::Char => {
                     let signed = type_sign(in_lhs.layout().ty);
                     let lhs = in_lhs.load_scalar(fx);
                     let rhs = in_rhs.load_scalar(fx);
 
                     let (lhs, rhs) = if (bin_op == BinOp::Eq || bin_op == BinOp::Ne)
-                        && (in_lhs.layout().ty.sty == fx.tcx.types.i8.sty
-                            || in_lhs.layout().ty.sty == fx.tcx.types.i16.sty)
+                        && (in_lhs.layout().ty.kind == fx.tcx.types.i8.kind
+                            || in_lhs.layout().ty.kind == fx.tcx.types.i16.kind)
                     {
                         // FIXME(CraneStation/cranelift#896) icmp_imm.i8/i16 with eq/ne for signed ints is implemented wrong.
                         (
@@ -86,12 +86,12 @@ pub fn codegen_binop<'tcx>(
         _ => {}
     }
 
-    match in_lhs.layout().ty.sty {
+    match in_lhs.layout().ty.kind {
         ty::Bool => crate::num::trans_bool_binop(fx, bin_op, in_lhs, in_rhs),
         ty::Uint(_) | ty::Int(_) => crate::num::trans_int_binop(fx, bin_op, in_lhs, in_rhs),
         ty::Float(_) => crate::num::trans_float_binop(fx, bin_op, in_lhs, in_rhs),
         ty::RawPtr(..) | ty::FnPtr(..) => crate::num::trans_ptr_binop(fx, bin_op, in_lhs, in_rhs),
-        _ => unimplemented!(
+        _ => unreachable!(
             "{:?}({:?}, {:?})",
             bin_op,
             in_lhs.layout().ty,
@@ -100,7 +100,7 @@ pub fn codegen_binop<'tcx>(
     }
 }
 
-pub fn trans_bool_binop<'tcx>(
+pub(crate) fn trans_bool_binop<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
     bin_op: BinOp,
     in_lhs: CValue<'tcx>,
@@ -121,7 +121,7 @@ pub fn trans_bool_binop<'tcx>(
     CValue::by_val(res, fx.layout_of(fx.tcx.types.bool))
 }
 
-pub fn trans_int_binop<'tcx>(
+pub(crate) fn trans_int_binop<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
     bin_op: BinOp,
     in_lhs: CValue<'tcx>,
@@ -192,7 +192,7 @@ pub fn trans_int_binop<'tcx>(
     CValue::by_val(val, in_lhs.layout())
 }
 
-pub fn trans_checked_int_binop<'tcx>(
+pub(crate) fn trans_checked_int_binop<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
     bin_op: BinOp,
     in_lhs: CValue<'tcx>,
@@ -285,10 +285,11 @@ pub fn trans_checked_int_binop<'tcx>(
     };
 
     let has_overflow = fx.bcx.ins().bint(types::I8, has_overflow);
+
+    // FIXME directly write to result place instead
     let out_place = CPlace::new_stack_slot(
         fx,
-        fx.tcx
-            .mk_tup([in_lhs.layout().ty, fx.tcx.types.bool].iter()),
+        fx.layout_of(fx.tcx.mk_tup([in_lhs.layout().ty, fx.tcx.types.bool].iter())),
     );
     let out_layout = out_place.layout();
     out_place.write_cvalue(fx, CValue::by_val_pair(res, has_overflow, out_layout));
@@ -296,7 +297,7 @@ pub fn trans_checked_int_binop<'tcx>(
     out_place.to_cvalue(fx)
 }
 
-pub fn trans_float_binop<'tcx>(
+pub(crate) fn trans_float_binop<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
     bin_op: BinOp,
     in_lhs: CValue<'tcx>,
@@ -314,7 +315,7 @@ pub fn trans_float_binop<'tcx>(
         BinOp::Mul => b.fmul(lhs, rhs),
         BinOp::Div => b.fdiv(lhs, rhs),
         BinOp::Rem => {
-            let name = match in_lhs.layout().ty.sty {
+            let name = match in_lhs.layout().ty.kind {
                 ty::Float(FloatTy::F32) => "fmodf",
                 ty::Float(FloatTy::F64) => "fmod",
                 _ => bug!(),
@@ -341,20 +342,17 @@ pub fn trans_float_binop<'tcx>(
     CValue::by_val(res, in_lhs.layout())
 }
 
-pub fn trans_ptr_binop<'tcx>(
+pub(crate) fn trans_ptr_binop<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
     bin_op: BinOp,
     in_lhs: CValue<'tcx>,
     in_rhs: CValue<'tcx>,
 ) -> CValue<'tcx> {
-    let not_fat = match in_lhs.layout().ty.sty {
-        ty::RawPtr(TypeAndMut { ty, mutbl: _ }) => {
-            ty.is_sized(fx.tcx.at(DUMMY_SP), ParamEnv::reveal_all())
-        }
-        ty::FnPtr(..) => true,
-        _ => bug!("trans_ptr_binop on non ptr"),
-    };
-    if not_fat {
+    let is_thin_ptr = in_lhs.layout().ty.builtin_deref(true).map(|TypeAndMut { ty, mutbl: _}| {
+        !has_ptr_meta(fx.tcx, ty)
+    }).unwrap_or(true);
+
+    if is_thin_ptr {
         match bin_op {
             BinOp::Eq | BinOp::Lt | BinOp::Le | BinOp::Ne | BinOp::Ge | BinOp::Gt => {
                 let lhs = in_lhs.load_scalar(fx);
@@ -363,8 +361,8 @@ pub fn trans_ptr_binop<'tcx>(
                 return codegen_compare_bin_op(fx, bin_op, false, lhs, rhs);
             }
             BinOp::Offset => {
+                let pointee_ty = in_lhs.layout().ty.builtin_deref(true).unwrap().ty;
                 let (base, offset) = (in_lhs, in_rhs.load_scalar(fx));
-                let pointee_ty = base.layout().ty.builtin_deref(true).unwrap().ty;
                 let pointee_size = fx.layout_of(pointee_ty).size.bytes();
                 let ptr_diff = fx.bcx.ins().imul_imm(offset, pointee_size as i64);
                 let base_val = base.load_scalar(fx);