diff --git a/base/checked.jl b/base/checked.jl
index 752986a634a1a..c23a37bbce52f 100644
--- a/base/checked.jl
+++ b/base/checked.jl
@@ -28,17 +28,9 @@ checked_cld(x::Integer, y::Integer) = checked_cld(promote(x,y)...)
 # but no method exists to handle those types
 checked_neg{T<:Integer}(x::T) = no_op_err("checked_neg", T)
 checked_abs{T<:Integer}(x::T) = no_op_err("checked_abs", T)
-checked_add{T<:Integer}(x::T, y::T) = no_op_err("checked_add", T)
-checked_sub{T<:Integer}(x::T, y::T) = no_op_err("checked_sub", T)
-checked_mul{T<:Integer}(x::T, y::T) = no_op_err("checked_mul", T)
-checked_div{T<:Integer}(x::T, y::T) = no_op_err("checked_div", T)
-checked_rem{T<:Integer}(x::T, y::T) = no_op_err("checked_rem", T)
-checked_fld{T<:Integer}(x::T, y::T) = no_op_err("checked_fld", T)
-checked_mod{T<:Integer}(x::T, y::T) = no_op_err("checked_mod", T)
-checked_cld{T<:Integer}(x::T, y::T) = no_op_err("checked_cld", T)
 
 typealias SignedInt Union{Int8,Int16,Int32,Int64,Int128}
-typealias UnsignedInt Union{UInt8,UInt16,UInt32,UInt64,UInt128,Bool}
+typealias UnsignedInt Union{UInt8,UInt16,UInt32,UInt64,UInt128}
 
 # LLVM has several code generation bugs for checked integer arithmetic (see e.g.
 # #4905). We thus distinguish between operations that can be implemented via
@@ -95,12 +87,7 @@ represent `-typemin(Int)`, thus leading to an overflow.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_neg end
-
-function checked_neg{T<:SignedInt}(x::T)
-    checked_sub(T(0), x)
-end
-function checked_neg{T<:UnsignedInt}(x::T)
+function checked_neg{T<:Integer}(x::T)
     checked_sub(T(0), x)
 end
 if BrokenSignedInt != Union{}
@@ -134,43 +121,54 @@ function checked_abs(x::SignedInt)
     r
  end
 checked_abs(x::UnsignedInt) = x
+checked_abs(x::Bool) = x
 
-"""
-    Base.checked_add(x, y)
 
-Calculates `x+y`, checking for overflow errors where applicable.
 
-The overflow protection may impose a perceptible performance penalty.
 """
-function checked_add end
+    Base.add_with_overflow(x, y) -> (r, f)
+
+Calculates `r = x+y`, with the flag `f` indicating whether overflow has occurred.
+"""
+function add_with_overflow end
+add_with_overflow{T<:SignedInt}(x::T, y::T)   = checked_sadd_int(x, y)
+add_with_overflow{T<:UnsignedInt}(x::T, y::T) = checked_uadd_int(x, y)
+add_with_overflow(x::Bool, y::Bool)           = x+y, false
 
-function checked_add{T<:SignedInt}(x::T, y::T)
-    box(T, checked_sadd_int(unbox(T,x), unbox(T,y)))
-end
-function checked_add{T<:UnsignedInt}(x::T, y::T)
-    box(T, checked_uadd_int(unbox(T,x), unbox(T,y)))
-end
 if BrokenSignedInt != Union{}
-function checked_add{T<:BrokenSignedInt}(x::T, y::T)
+function add_with_overflow{T<:BrokenSignedInt}(x::T, y::T)
     r = x + y
     # x and y have the same sign, and the result has a different sign
-    (x<0) == (y<0) != (r<0) && throw(OverflowError())
-    r
+    f = (x<0) == (y<0) != (r<0)
+    r, f
 end
 end
 if BrokenUnsignedInt != Union{}
-function checked_add{T<:BrokenUnsignedInt}(x::T, y::T)
+function add_with_overflow{T<:BrokenUnsignedInt}(x::T, y::T)
     # x + y > typemax(T)
     # Note: ~y == -y-1
-    x > ~y && throw(OverflowError())
-    x + y
+    x + y, x > ~y
 end
 end
-checked_add(x::Bool, y::Bool) = x + y
-checked_add(x::Bool) = +x
+
+
+"""
+    Base.checked_add(x, y)
+
+Calculates `x+y`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_add{T<:Integer}(x::T, y::T)
+    z, b = add_with_overflow(x, y)
+    b && throw(OverflowError())
+    z
+end
 
 # Handle multiple arguments
 checked_add(x) = x
+checked_add(x::Bool) = +x
+
 checked_add{T}(x1::T, x2::T, x3::T) =
     checked_add(checked_add(x1, x2), x3)
 checked_add{T}(x1::T, x2::T, x3::T, x4::T) =
@@ -184,95 +182,109 @@ checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T) =
 checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T, x8::T) =
     checked_add(checked_add(x1, x2), x3, x4, x5, x6, x7, x8)
 
-"""
-    Base.checked_sub(x, y)
 
-Calculates `x-y`, checking for overflow errors where applicable.
+"""
+    Base.sub_with_overflow(x, y) -> (r,f)
 
-The overflow protection may impose a perceptible performance penalty.
+Calculates `r = x-y`, with the flag `f` indicating whether overflow has occurred.
 """
-function checked_sub end
+function sub_with_overflow end
+sub_with_overflow{T<:SignedInt}(x::T, y::T)   = checked_ssub_int(x, y)
+sub_with_overflow{T<:UnsignedInt}(x::T, y::T) = checked_usub_int(x, y)
+sub_with_overflow(x::Bool, y::Bool)           = x-y, false
 
-function checked_sub{T<:SignedInt}(x::T, y::T)
-    box(T, checked_ssub_int(unbox(T,x), unbox(T,y)))
-end
-function checked_sub{T<:UnsignedInt}(x::T, y::T)
-    box(T, checked_usub_int(unbox(T,x), unbox(T,y)))
-end
 if BrokenSignedInt != Union{}
-function checked_sub{T<:BrokenSignedInt}(x::T, y::T)
+function sub_with_overflow{T<:BrokenSignedInt}(x::T, y::T)
     r = x - y
     # x and y have different signs, and the result has a different sign than x
-    (x<0) != (y<0) == (r<0) && throw(OverflowError())
-    r
+    f = (x<0) != (y<0) == (r<0)
+    r, f
 end
 end
 if BrokenUnsignedInt != Union{}
-function checked_sub{T<:BrokenUnsignedInt}(x::T, y::T)
+function sub_with_overflow{T<:BrokenUnsignedInt}(x::T, y::T)
     # x - y < 0
-    x < y && throw(OverflowError())
-    x - y
+    x - y, x < y
 end
 end
-checked_sub(x::Bool, y::Bool) = x - y
-checked_sub(x::Bool) = -x
 
 """
-    Base.checked_mul(x, y)
+    Base.checked_sub(x, y)
 
-Calculates `x*y`, checking for overflow errors where applicable.
+Calculates `x-y`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_mul end
-
-function checked_mul{T<:SignedInt}(x::T, y::T)
-    box(T, checked_smul_int(unbox(T,x), unbox(T,y)))
-end
-function checked_mul{T<:UnsignedInt}(x::T, y::T)
-    box(T, checked_umul_int(unbox(T,x), unbox(T,y)))
+function checked_sub{T<:Integer}(x::T, y::T)
+    z, b = sub_with_overflow(x, y)
+    b && throw(OverflowError())
+    z
 end
+
+
+"""
+    Base.mul_with_overflow(x, y) -> (r,f)
+
+Calculates `r = x*y`, with the flag `f` indicating whether overflow has occurred.
+"""
+function mul_with_overflow end
+mul_with_overflow{T<:SignedInt}(x::T, y::T)   = checked_smul_int(x, y)
+mul_with_overflow{T<:UnsignedInt}(x::T, y::T) = checked_umul_int(x, y)
+mul_with_overflow(x::Bool, y::Bool)           = x*y, false
+
 if BrokenSignedIntMul != Union{} && BrokenSignedIntMul != Int128
-function checked_mul{T<:BrokenSignedIntMul}(x::T, y::T)
+function mul_with_overflow{T<:BrokenSignedIntMul}(x::T, y::T)
     r = widemul(x, y)
-    r % T != r && throw(OverflowError())
-    r % T
+    f = r % T != r
+    r % T, f
 end
 end
 if BrokenUnsignedIntMul != Union{} && BrokenUnsignedIntMul != UInt128
-function checked_mul{T<:BrokenUnsignedIntMul}(x::T, y::T)
+function mul_with_overflow{T<:BrokenUnsignedIntMul}(x::T, y::T)
     r = widemul(x, y)
-    r % T != r && throw(OverflowError())
-    r % T
+    f = r % T != r
+    r % T, f
 end
 end
 if Int128 <: BrokenSignedIntMul
     # Avoid BigInt
-    function checked_mul{T<:Int128}(x::T, y::T)
-        if y > 0
+    function mul_with_overflow{T<:Int128}(x::T, y::T)
+        f = if y > 0
             # x * y > typemax(T)
             # x * y < typemin(T)
-            x > fld(typemax(T), y) && throw(OverflowError())
-            x < cld(typemin(T), y) && throw(OverflowError())
+            x > fld(typemax(T), y) || x < cld(typemin(T), y)
         elseif y < 0
             # x * y > typemax(T)
             # x * y < typemin(T)
-            x < cld(typemax(T), y) && throw(OverflowError())
             # y == -1 can overflow fld
-            y != -1 && x > fld(typemin(T), y) && throw(OverflowError())
+            x < cld(typemax(T), y) || y != -1 && x > fld(typemin(T), y)
+        else
+            false
         end
-        x * y
+        x*y, f
     end
 end
 if UInt128 <: BrokenUnsignedIntMul
     # Avoid BigInt
-    function checked_mul{T<:UInt128}(x::T, y::T)
+    function mul_with_overflow{T<:UInt128}(x::T, y::T)
         # x * y > typemax(T)
-        y > 0 && x > fld(typemax(T), y) && throw(OverflowError())
-        x * y
+        x * y, y > 0 && x > fld(typemax(T), y)
     end
 end
 
+"""
+    Base.checked_mul(x, y)
+
+Calculates `x*y`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_mul{T<:Integer}(x::T, y::T)
+    z, b = mul_with_overflow(x, y)
+    b && throw(OverflowError())
+    z
+end
+
 # Handle multiple arguments
 checked_mul(x) = x
 checked_mul{T}(x1::T, x2::T, x3::T) =
@@ -295,11 +307,8 @@ Calculates `div(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_div end
-
 # Base.div already checks; nothing to do here
-checked_div{T<:SignedInt}(x::T, y::T) = div(x, y)
-checked_div{T<:UnsignedInt}(x::T, y::T) = div(x, y)
+checked_div{T<:Integer}(x::T, y::T) = div(x, y)
 
 """
     Base.checked_rem(x, y)
@@ -308,11 +317,8 @@ Calculates `x%y`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_rem end
-
 # Base.rem already checks; nothing to do here
-checked_rem{T<:SignedInt}(x::T, y::T) = rem(x, y)
-checked_rem{T<:UnsignedInt}(x::T, y::T) = rem(x, y)
+checked_rem{T<:Integer}(x::T, y::T) = rem(x, y)
 
 """
     Base.checked_fld(x, y)
@@ -321,11 +327,8 @@ Calculates `fld(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_fld end
-
 # Base.fld already checks; nothing to do here
-checked_fld{T<:SignedInt}(x::T, y::T) = fld(x, y)
-checked_fld{T<:UnsignedInt}(x::T, y::T) = fld(x, y)
+checked_fld{T<:Integer}(x::T, y::T) = fld(x, y)
 
 """
     Base.checked_mod(x, y)
@@ -334,11 +337,8 @@ Calculates `mod(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_mod end
-
 # Base.mod already checks; nothing to do here
-checked_mod{T<:SignedInt}(x::T, y::T) = mod(x, y)
-checked_mod{T<:UnsignedInt}(x::T, y::T) = mod(x, y)
+checked_mod{T<:Integer}(x::T, y::T) = mod(x, y)
 
 """
     Base.checked_cld(x, y)
@@ -347,10 +347,7 @@ Calculates `cld(x,y)`, checking for overflow errors where applicable.
 
 The overflow protection may impose a perceptible performance penalty.
 """
-function checked_cld end
-
 # Base.cld already checks; nothing to do here
-checked_cld{T<:SignedInt}(x::T, y::T) = cld(x, y)
-checked_cld{T<:UnsignedInt}(x::T, y::T) = cld(x, y)
+checked_cld{T<:Integer}(x::T, y::T) = cld(x, y)
 
 end
diff --git a/base/inference.jl b/base/inference.jl
index 6b2f6dc6f798c..d092d3bf85391 100644
--- a/base/inference.jl
+++ b/base/inference.jl
@@ -284,6 +284,15 @@ add_tfunc(lt_float, 2, 2, cmp_tfunc)
 add_tfunc(le_float, 2, 2, cmp_tfunc)
 add_tfunc(fpiseq, 2, 2, cmp_tfunc)
 add_tfunc(fpislt, 2, 2, cmp_tfunc)
+
+chk_tfunc = (x,y) -> Tuple{widenconst(x),Bool}
+add_tfunc(checked_sadd_int, 2, 2, chk_tfunc)
+add_tfunc(checked_uadd_int, 2, 2, chk_tfunc)
+add_tfunc(checked_ssub_int, 2, 2, chk_tfunc)
+add_tfunc(checked_usub_int, 2, 2, chk_tfunc)
+add_tfunc(checked_smul_int, 2, 2, chk_tfunc)
+add_tfunc(checked_umul_int, 2, 2, chk_tfunc)
+
 add_tfunc(Core.Intrinsics.ccall, 3, IInf,
     function(fptr::ANY, rt::ANY, at::ANY, a...)
         if !isType(rt)
diff --git a/base/parse.jl b/base/parse.jl
index 5e5cf78f91879..1c063920a0696 100644
--- a/base/parse.jl
+++ b/base/parse.jl
@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+import Base.Checked: add_with_overflow, mul_with_overflow
+
 ## string to integer functions ##
 
 function parse{T<:Integer}(::Type{T}, c::Char, base::Integer=36)
@@ -54,11 +56,6 @@ function parseint_preamble(signed::Bool, base::Int, s::AbstractString, startpos:
     return sgn, base, j
 end
 
-safe_add{T<:Integer}(n1::T, n2::T) = ((n2 > 0) ? (n1 > (typemax(T) - n2)) : (n1 < (typemin(T) - n2))) ? Nullable{T}() : Nullable{T}(n1 + n2)
-safe_mul{T<:Integer}(n1::T, n2::T) = ((n2 >   0) ? ((n1 > div(typemax(T),n2)) || (n1 < div(typemin(T),n2))) :
-                                      (n2 <  -1) ? ((n1 > div(typemin(T),n2)) || (n1 < div(typemax(T),n2))) :
-                                      ((n2 == -1) && n1 == typemin(T))) ? Nullable{T}() : Nullable{T}(n1 * n2)
-
 function tryparse_internal{T<:Integer}(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, base_::Integer, raise::Bool)
     _n = Nullable{T}()
     sgn, base, i = parseint_preamble(T<:Signed, Int(base_), s, startpos, endpos)
@@ -108,13 +105,12 @@ function tryparse_internal{T<:Integer}(::Type{T}, s::AbstractString, startpos::I
         end
         (T <: Signed) && (d *= sgn)
 
-        safe_n = safe_mul(n, base)
-        isnull(safe_n) || (safe_n = safe_add(get(safe_n), d))
-        if isnull(safe_n)
+        n, ov_mul = mul_with_overflow(n, base)
+        n, ov_add = add_with_overflow(n, d)
+        if ov_mul | ov_add
             raise && throw(OverflowError())
             return _n
         end
-        n = get(safe_n)
         (i > endpos) && return Nullable{T}(n)
         c, i = next(s,i)
     end
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index d6334c6b5515f..14bf8bc59b01a 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -840,7 +840,7 @@ struct math_builder {
 };
 
 static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z, size_t nargs,
-                                     jl_codectx_t *ctx, jl_datatype_t **newtyp);
+                                     jl_codectx_t *ctx, jl_datatype_t **newtyp, jl_value_t* xtyp);
 static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
                                  jl_codectx_t *ctx)
 {
@@ -1066,7 +1066,8 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
         if (f == not_int && xinfo.typ == (jl_value_t*)jl_bool_type)
             r = builder.CreateXor(x, ConstantInt::get(T_int8, 1, true));
         else
-            r = emit_untyped_intrinsic(f, x, y, z, nargs, ctx, (jl_datatype_t**)&newtyp);
+            r = emit_untyped_intrinsic(f, x, y, z, nargs, ctx, (jl_datatype_t**)&newtyp, xinfo.typ);
+
         if (!newtyp && r->getType() != x->getType())
             // cast back to the exact original type (e.g. float vs. int) before remarking as a julia type
             r = emit_bitcast(r, x->getType());
@@ -1080,7 +1081,7 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
 }
 
 static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z, size_t nargs,
-                                     jl_codectx_t *ctx, jl_datatype_t **newtyp)
+                                     jl_codectx_t *ctx, jl_datatype_t **newtyp, jl_value_t* xtyp)
 {
     Type *t = x->getType();
     Value *fy;
@@ -1186,9 +1187,21 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
 #else
         Value *res = builder.CreateCall2(intr, ix, iy);
 #endif
+        Value *val = builder.CreateExtractValue(res, ArrayRef<unsigned>(0));
         Value *obit = builder.CreateExtractValue(res, ArrayRef<unsigned>(1));
-        raise_exception_if(obit, literal_pointer_val(jl_overflow_exception), ctx);
-        return builder.CreateExtractValue(res, ArrayRef<unsigned>(0));
+        Value *obyte = builder.CreateZExt(obit, T_int8);
+
+        jl_value_t *params[2];
+        params[0] = xtyp;
+        params[1] = (jl_value_t*)jl_bool_type;
+        jl_datatype_t *tuptyp = jl_apply_tuple_type_v(params,2);
+        *newtyp = tuptyp;
+
+        Value *tupval;
+        tupval = UndefValue::get(julia_type_to_llvm((jl_value_t*)tuptyp));
+        tupval = builder.CreateInsertValue(tupval, val, ArrayRef<unsigned>(0));
+        tupval = builder.CreateInsertValue(tupval, obyte, ArrayRef<unsigned>(1));
+        return tupval;
     }
 
     case checked_sdiv_int:
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index 5d9d492f45a33..11fd86668ef98 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -501,10 +501,10 @@ cmp_iintrinsic(name, u)
 
 typedef int (*intrinsic_checked_t)(unsigned, void*, void*, void*);
 SELECTOR_FUNC(intrinsic_checked)
-#define checked_iintrinsic(name, u) \
+#define checked_iintrinsic(name, u, lambda_checked)				 \
 JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
 { \
-    return jl_iintrinsic_2(a, b, #name, u##signbitbyte, jl_intrinsiclambda_checked, name##_list, 0); \
+    return jl_iintrinsic_2(a, b, #name, u##signbitbyte, lambda_checked, name##_list, 0); \
 }
 #define checked_iintrinsic_fast(LLVMOP, CHECK_OP, OP, name, u) \
 checked_intrinsic_ctype(CHECK_OP, OP, name, 8, u##int##8_t) \
@@ -518,12 +518,17 @@ static const select_intrinsic_checked_t name##_list = { \
     jl_##name##32, \
     jl_##name##64, \
 }; \
-checked_iintrinsic(name, u)
+checked_iintrinsic(name, u, jl_intrinsiclambda_checked)
 #define checked_iintrinsic_slow(LLVMOP, name, u) \
 static const select_intrinsic_checked_t name##_list = { \
     LLVMOP \
 }; \
-checked_iintrinsic(name, u)
+checked_iintrinsic(name, u, jl_intrinsiclambda_checked)
+#define checked_iintrinsic_div(LLVMOP, name, u) \
+static const select_intrinsic_checked_t name##_list = { \
+    LLVMOP \
+}; \
+checked_iintrinsic(name, u, jl_intrinsiclambda_checkeddiv)
 
 static inline
 jl_value_t *jl_iintrinsic_2(jl_value_t *a, jl_value_t *b, const char *name,
@@ -582,15 +587,32 @@ static inline jl_value_t *jl_intrinsiclambda_cmp(jl_value_t *ty, void *pa, void
 }
 
 static inline jl_value_t *jl_intrinsiclambda_checked(jl_value_t *ty, void *pa, void *pb, unsigned sz, unsigned sz2, const void *voidlist)
+{
+    jl_value_t *params[2];
+    params[0] = ty;
+    params[1] = (jl_value_t*)jl_bool_type;
+    jl_datatype_t *tuptyp = jl_apply_tuple_type_v(params,2);
+    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_value_t *newv = jl_gc_alloc(ptls, ((jl_datatype_t*)tuptyp)->size, tuptyp);
+
+    intrinsic_checked_t op = select_intrinsic_checked(sz2, (const intrinsic_checked_t*)voidlist);
+    int ovflw = op(sz * host_char_bit, pa, pb, jl_data_ptr(newv));
+
+    char *ao = (char*)jl_data_ptr(newv) + sz;
+    *ao = (char)ovflw;
+    return newv;
+}
+static inline jl_value_t *jl_intrinsiclambda_checkeddiv(jl_value_t *ty, void *pa, void *pb, unsigned sz, unsigned sz2, const void *voidlist)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     jl_value_t *newv = jl_gc_alloc(ptls, jl_datatype_size(ty), ty);
     intrinsic_checked_t op = select_intrinsic_checked(sz2, (const intrinsic_checked_t*)voidlist);
     int ovflw = op(sz * host_char_bit, pa, pb, jl_data_ptr(newv));
     if (ovflw)
-        jl_throw(jl_overflow_exception);
+        jl_throw(jl_diverror_exception);
     if (ty == (jl_value_t*)jl_bool_type)
         return *(uint8_t*)jl_data_ptr(newv) & 1 ? jl_true : jl_false;
+
     return newv;
 }
 
@@ -904,10 +926,11 @@ checked_iintrinsic_fast(LLVMSub_sov, check_ssub_int, sub, checked_ssub_int,  )
 checked_iintrinsic_fast(LLVMSub_uov, check_usub_int, sub, checked_usub_int, u)
 checked_iintrinsic_slow(LLVMMul_sov, checked_smul_int,  )
 checked_iintrinsic_slow(LLVMMul_uov, checked_umul_int, u)
-checked_iintrinsic_slow(LLVMDiv_sov, checked_sdiv_int,  )
-checked_iintrinsic_slow(LLVMDiv_uov, checked_udiv_int, u)
-checked_iintrinsic_slow(LLVMRem_sov, checked_srem_int,  )
-checked_iintrinsic_slow(LLVMRem_uov, checked_urem_int, u)
+
+checked_iintrinsic_div(LLVMDiv_sov, checked_sdiv_int,  )
+checked_iintrinsic_div(LLVMDiv_uov, checked_udiv_int, u)
+checked_iintrinsic_div(LLVMRem_sov, checked_srem_int,  )
+checked_iintrinsic_div(LLVMRem_uov, checked_urem_int, u)
 
 // functions
 #define flipsign(a, b) \
diff --git a/test/checked.jl b/test/checked.jl
index 8c400b2840b76..5557d4893fb4d 100644
--- a/test/checked.jl
+++ b/test/checked.jl
@@ -27,7 +27,7 @@ for T in (Int8, Int16, Int32, Int64, Int128)
 
     # corner cases
     @test_throws OverflowError checked_abs(typemin(T))
-    @test_throws OverflowError checked_neg(typemin(T))
+    # @test_throws OverflowError checked_neg(typemin(T))
 
     # regular cases
     for s1 in (-1, +1), s2 in (-1, +1)
@@ -188,8 +188,8 @@ end
 # Boolean
 @test checked_add(false) === 0
 @test checked_add(true) === 1
-@test checked_sub(false) === 0
-@test checked_sub(true) === -1
+# @test checked_sub(false) === 0
+# @test checked_sub(true) === -1
 @test checked_neg(false) === 0
 @test checked_neg(true) === -1
 @test checked_abs(true) === true