[WIP] Make usize overflow always have debug-assertions semantics

This is a prototype for rust-lang/rfcs#2635 to enable us to collect some measurements.

Author: alex

src/librustc_codegen_llvm/context.rs

@@ -12,13 +12,15 @@ use type_of::PointeeInfo;
 use rustc_codegen_ssa::traits::*;
 use libc::c_uint;
 
+use syntax::ast;
+
 use rustc_data_structures::base_n;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc::mir::mono::Stats;
 use rustc::session::config::{self, DebugInfo};
 use rustc::session::Session;
 use rustc::ty::layout::{LayoutError, LayoutOf, Size, TyLayout, VariantIdx};
-use rustc::ty::{self, Ty, TyCtxt};
+use rustc::ty::{self, Ty, TyCtxt, TyKind};
 use rustc::util::nodemap::FxHashMap;
 use rustc_target::spec::{HasTargetSpec, Target};
 use rustc_codegen_ssa::callee::resolve_and_get_fn;
@@ -409,8 +411,14 @@ impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         &self.tcx.sess
     }
 
-    fn check_overflow(&self) -> bool {
-        self.check_overflow
+    fn check_overflow(&self, ty: Option<Ty<'tcx>>) -> bool {
+        let type_specific_overflow = match ty {
+            Some(ty) => {
+                ty.sty == TyKind::Uint(ast::UintTy::Usize)
+            },
+            None => false
+        };
+        self.check_overflow || type_specific_overflow
     }
 
     fn stats(&self) -> &RefCell<Stats> {

src/librustc_codegen_ssa/mir/block.rs

@@ -339,7 +339,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 // NOTE: Unlike binops, negation doesn't have its own
                 // checked operation, just a comparison with the minimum
                 // value, so we have to check for the assert message.
-                if !bx.check_overflow() {
+                if !bx.check_overflow(None) {
                     if let mir::interpret::EvalErrorKind::OverflowNeg = *msg {
                         const_cond = Some(expected);
                     }

src/librustc_codegen_ssa/mir/rvalue.rs

@@ -670,7 +670,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         // with #[rustc_inherit_overflow_checks] and inlined from
         // another crate (mostly core::num generic/#[inline] fns),
         // while the current crate doesn't use overflow checks.
-        if !bx.cx().check_overflow() {
+        if !bx.cx().check_overflow(Some(input_ty)) {
             let val = self.codegen_scalar_binop(bx, op, lhs, rhs, input_ty);
             return OperandValue::Pair(val, bx.cx().const_bool(false));
         }

src/librustc_codegen_ssa/traits/misc.rs

@@ -12,7 +12,7 @@ pub trait MiscMethods<'tcx>: BackendTypes {
     fn vtables(
         &self,
     ) -> &RefCell<FxHashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), Self::Value>>;
-    fn check_overflow(&self) -> bool;
+    fn check_overflow(&self, ty: Option<Ty<'tcx>>) -> bool;
     fn instances(&self) -> &RefCell<FxHashMap<Instance<'tcx>, Self::Value>>;
     fn get_fn(&self, instance: Instance<'tcx>) -> Self::Value;
     fn get_param(&self, llfn: Self::Value, index: c_uint) -> Self::Value;

src/librustc_mir/build/expr/as_rvalue.rs

@@ -84,7 +84,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
             ExprKind::Unary { op, arg } => {
                 let arg = unpack!(block = this.as_operand(block, scope, arg));
                 // Check for -MIN on signed integers
-                if this.hir.check_overflow() && op == UnOp::Neg && expr.ty.is_signed() {
+                if this.hir.check_overflow(expr.ty) && op == UnOp::Neg && expr.ty.is_signed() {
                     let bool_ty = this.hir.bool_ty();
 
                     let minval = this.minval_literal(expr_span, expr.ty);
@@ -410,7 +410,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
     ) -> BlockAnd<Rvalue<'tcx>> {
         let source_info = self.source_info(span);
         let bool_ty = self.hir.bool_ty();
-        if self.hir.check_overflow() && op.is_checkable() && ty.is_integral() {
+        if self.hir.check_overflow(ty) && op.is_checkable() && ty.is_integral() {
             let result_tup = self.hir.tcx().intern_tup(&[ty, bool_ty]);
             let result_value = self.temp(result_tup, span);
 

src/librustc_mir/hair/cx/mod.rs

@@ -11,7 +11,7 @@ use rustc::hir::Node;
 use rustc::middle::region;
 use rustc::infer::InferCtxt;
 use rustc::ty::subst::Subst;
-use rustc::ty::{self, Ty, TyCtxt};
+use rustc::ty::{self, Ty, TyCtxt, TyKind};
 use rustc::ty::subst::{Kind, Substs};
 use rustc::ty::layout::VariantIdx;
 use syntax::ast;
@@ -218,8 +218,8 @@ impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> {
         self.tables
     }
 
-    pub fn check_overflow(&self) -> bool {
-        self.check_overflow
+    pub fn check_overflow(&self, ty: Ty<'tcx>) -> bool {
+        self.check_overflow || ty.sty == TyKind::Uint(ast::UintTy::Usize)
     }
 
     pub fn type_is_copy_modulo_regions(&self, ty: Ty<'tcx>, span: Span) -> bool {