8a1c999c9b
This is the result of an audit of all of the ABIs in clang to implement and enable the type for those targets. Additionally, this finds an issue with integer-promotion passing for a few platforms when using _ExtInt of < int, so this also corrects that resulting in signext/zeroext being on a params of those types in some platforms. Differential Revisions: https://reviews.llvm.org/D79118
278 lines
12 KiB
C++
278 lines
12 KiB
C++
// RUN: %clang_cc1 -triple x86_64-gnu-linux -fsanitize=array-bounds,enum,float-cast-overflow,integer-divide-by-zero,implicit-unsigned-integer-truncation,implicit-signed-integer-truncation,implicit-integer-sign-change,unsigned-integer-overflow,signed-integer-overflow,shift-base,shift-exponent -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s
|
|
|
|
|
|
// CHECK: define void @_Z6BoundsRA10_KiU7_ExtIntILi15EEi
|
|
void Bounds(const int (&Array)[10], _ExtInt(15) Index) {
|
|
int I1 = Array[Index];
|
|
// CHECK: %[[SEXT:.+]] = sext i15 %{{.+}} to i64
|
|
// CHECK: %[[CMP:.+]] = icmp ult i64 %[[SEXT]], 10
|
|
// CHECK: br i1 %[[CMP]]
|
|
// CHECK: call void @__ubsan_handle_out_of_bounds
|
|
}
|
|
|
|
// CHECK: define void @_Z4Enumv
|
|
void Enum() {
|
|
enum E1 { e1a = 0, e1b = 127 }
|
|
e1;
|
|
enum E2 { e2a = -1, e2b = 64 }
|
|
e2;
|
|
enum E3 { e3a = (1u << 31) - 1 }
|
|
e3;
|
|
|
|
_ExtInt(34) a = e1;
|
|
// CHECK: %[[E1:.+]] = icmp ule i32 %{{.*}}, 127
|
|
// CHECK: br i1 %[[E1]]
|
|
// CHECK: call void @__ubsan_handle_load_invalid_value_abort
|
|
_ExtInt(34) b = e2;
|
|
// CHECK: %[[E2HI:.*]] = icmp sle i32 {{.*}}, 127
|
|
// CHECK: %[[E2LO:.*]] = icmp sge i32 {{.*}}, -128
|
|
// CHECK: %[[E2:.*]] = and i1 %[[E2HI]], %[[E2LO]]
|
|
// CHECK: br i1 %[[E2]]
|
|
// CHECK: call void @__ubsan_handle_load_invalid_value_abort
|
|
_ExtInt(34) c = e3;
|
|
// CHECK: %[[E3:.*]] = icmp ule i32 {{.*}}, 2147483647
|
|
// CHECK: br i1 %[[E3]]
|
|
// CHECK: call void @__ubsan_handle_load_invalid_value_abort
|
|
}
|
|
|
|
// CHECK: define void @_Z13FloatOverflowfd
|
|
void FloatOverflow(float f, double d) {
|
|
_ExtInt(10) E = f;
|
|
// CHECK: fcmp ogt float %{{.+}}, -5.130000e+02
|
|
// CHECK: fcmp olt float %{{.+}}, 5.120000e+02
|
|
_ExtInt(10) E2 = d;
|
|
// CHECK: fcmp ogt double %{{.+}}, -5.130000e+02
|
|
// CHECK: fcmp olt double %{{.+}}, 5.120000e+02
|
|
_ExtInt(7) E3 = f;
|
|
// CHECK: fcmp ogt float %{{.+}}, -6.500000e+01
|
|
// CHECK: fcmp olt float %{{.+}}, 6.400000e+01
|
|
_ExtInt(7) E4 = d;
|
|
// CHECK: fcmp ogt double %{{.+}}, -6.500000e+01
|
|
// CHECK: fcmp olt double %{{.+}}, 6.400000e+01
|
|
}
|
|
|
|
// CHECK: define void @_Z14UIntTruncationU7_ExtIntILi35EEjjy
|
|
void UIntTruncation(unsigned _ExtInt(35) E, unsigned int i, unsigned long long ll) {
|
|
|
|
i = E;
|
|
// CHECK: %[[LOADE:.+]] = load i35
|
|
// CHECK: store i35 %[[LOADE]], i35* %[[EADDR:.+]]
|
|
// CHECK: %[[LOADE2:.+]] = load i35, i35* %[[EADDR]]
|
|
// CHECK: %[[CONV:.+]] = trunc i35 %[[LOADE2]] to i32
|
|
// CHECK: %[[EXT:.+]] = zext i32 %[[CONV]] to i35
|
|
// CHECK: %[[CHECK:.+]] = icmp eq i35 %[[EXT]], %[[LOADE2]]
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
|
|
E = ll;
|
|
// CHECK: %[[LOADLL:.+]] = load i64
|
|
// CHECK: %[[CONV:.+]] = trunc i64 %[[LOADLL]] to i35
|
|
// CHECK: %[[EXT:.+]] = zext i35 %[[CONV]] to i64
|
|
// CHECK: %[[CHECK:.+]] = icmp eq i64 %[[EXT]], %[[LOADLL]]
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
}
|
|
|
|
// CHECK: define void @_Z13IntTruncationU7_ExtIntILi35EEiU7_ExtIntILi42EEjij
|
|
void IntTruncation(_ExtInt(35) E, unsigned _ExtInt(42) UE, int i, unsigned j) {
|
|
|
|
j = E;
|
|
// CHECK: %[[LOADE:.+]] = load i35
|
|
// CHECK: store i35 %[[LOADE]], i35* %[[EADDR:.+]]
|
|
// CHECK: %[[LOADE2:.+]] = load i35, i35* %[[EADDR]]
|
|
// CHECK: %[[CONV:.+]] = trunc i35 %[[LOADE2]] to i32
|
|
// CHECK: %[[EXT:.+]] = zext i32 %[[CONV]] to i35
|
|
// CHECK: %[[CHECK:.+]] = icmp eq i35 %[[EXT]], %[[LOADE2]]
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
|
|
j = UE;
|
|
// CHECK: %[[LOADUE:.+]] = load i42
|
|
// CHECK: %[[CONV:.+]] = trunc i42 %[[LOADUE]] to i32
|
|
// CHECK: %[[EXT:.+]] = zext i32 %[[CONV]] to i42
|
|
// CHECK: %[[CHECK:.+]] = icmp eq i42 %[[EXT]], %[[LOADUE]]
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
|
|
// Note: also triggers sign change check.
|
|
i = UE;
|
|
// CHECK: %[[LOADUE:.+]] = load i42
|
|
// CHECK: %[[CONV:.+]] = trunc i42 %[[LOADUE]] to i32
|
|
// CHECK: %[[NEG:.+]] = icmp slt i32 %[[CONV]], 0
|
|
// CHECK: %[[SIGNCHECK:.+]] = icmp eq i1 false, %[[NEG]]
|
|
// CHECK: %[[EXT:.+]] = sext i32 %[[CONV]] to i42
|
|
// CHECK: %[[CHECK:.+]] = icmp eq i42 %[[EXT]], %[[LOADUE]]
|
|
// CHECK: %[[CHECKBOTH:.+]] = and i1 %[[SIGNCHECK]], %[[CHECK]]
|
|
// CHECK: br i1 %[[CHECKBOTH]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
|
|
// Note: also triggers sign change check.
|
|
E = UE;
|
|
// CHECK: %[[LOADUE:.+]] = load i42
|
|
// CHECK: %[[CONV:.+]] = trunc i42 %[[LOADUE]] to i35
|
|
// CHECK: %[[NEG:.+]] = icmp slt i35 %[[CONV]], 0
|
|
// CHECK: %[[SIGNCHECK:.+]] = icmp eq i1 false, %[[NEG]]
|
|
// CHECK: %[[EXT:.+]] = sext i35 %[[CONV]] to i42
|
|
// CHECK: %[[CHECK:.+]] = icmp eq i42 %[[EXT]], %[[LOADUE]]
|
|
// CHECK: %[[CHECKBOTH:.+]] = and i1 %[[SIGNCHECK]], %[[CHECK]]
|
|
// CHECK: br i1 %[[CHECKBOTH]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
}
|
|
|
|
// CHECK: define void @_Z15SignChangeCheckU7_ExtIntILi39EEjU7_ExtIntILi39EEi
|
|
void SignChangeCheck(unsigned _ExtInt(39) UE, _ExtInt(39) E) {
|
|
UE = E;
|
|
// CHECK: %[[LOADEU:.+]] = load i39
|
|
// CHECK: %[[LOADE:.+]] = load i39
|
|
// CHECK: store i39 %[[LOADE]], i39* %[[EADDR:.+]]
|
|
// CHECK: %[[LOADE2:.+]] = load i39, i39* %[[EADDR]]
|
|
// CHECK: %[[NEG:.+]] = icmp slt i39 %[[LOADE2]], 0
|
|
// CHECK: %[[SIGNCHECK:.+]] = icmp eq i1 %[[NEG]], false
|
|
// CHECK: br i1 %[[SIGNCHECK]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
|
|
E = UE;
|
|
// CHECK: store i39 %[[LOADE2]], i39* %[[UEADDR:.+]]
|
|
// CHECK: %[[LOADUE2:.+]] = load i39, i39* %[[UEADDR]]
|
|
// CHECK: %[[NEG:.+]] = icmp slt i39 %[[LOADUE2]], 0
|
|
// CHECK: %[[SIGNCHECK:.+]] = icmp eq i1 false, %[[NEG]]
|
|
// CHECK: br i1 %[[SIGNCHECK]]
|
|
// CHECK: call void @__ubsan_handle_implicit_conversion_abort
|
|
}
|
|
|
|
// CHECK: define void @_Z9DivByZeroU7_ExtIntILi11EEii
|
|
void DivByZero(_ExtInt(11) E, int i) {
|
|
|
|
// Also triggers signed integer overflow.
|
|
E / E;
|
|
// CHECK: %[[EADDR:.+]] = alloca i11
|
|
// CHECK: %[[E:.+]] = load i11, i11* %[[EADDR]]
|
|
// CHECK: %[[E2:.+]] = load i11, i11* %[[EADDR]]
|
|
// CHECK: %[[NEZERO:.+]] = icmp ne i11 %[[E2]], 0
|
|
// CHECK: %[[NEMIN:.+]] = icmp ne i11 %[[E]], -1024
|
|
// CHECK: %[[NENEG1:.+]] = icmp ne i11 %[[E2]], -1
|
|
// CHECK: %[[OR:.+]] = or i1 %[[NEMIN]], %[[NENEG1]]
|
|
// CHECK: %[[AND:.+]] = and i1 %[[NEZERO]], %[[OR]]
|
|
// CHECK: br i1 %[[AND]]
|
|
// CHECK: call void @__ubsan_handle_divrem_overflow_abort
|
|
}
|
|
|
|
// TODO:
|
|
//-fsanitize=shift: (shift-base, shift-exponent) Shift operators where the amount shifted is greater or equal to the promoted bit-width of the left hand side or less than zero, or where the left hand side is negative. For a signed left shift, also checks for signed overflow in C, and for unsigned overflow in C++. You can use -fsanitize=shift-base or -fsanitize=shift-exponent to check only left-hand side or right-hand side of shift operation, respectively.
|
|
// CHECK: define void @_Z6ShiftsU7_ExtIntILi9EEi
|
|
void Shifts(_ExtInt(9) E) {
|
|
E >> E;
|
|
// CHECK: %[[EADDR:.+]] = alloca i9
|
|
// CHECK: %[[LHSE:.+]] = load i9, i9* %[[EADDR]]
|
|
// CHECK: %[[RHSE:.+]] = load i9, i9* %[[EADDR]]
|
|
// CHECK: %[[CMP:.+]] = icmp ule i9 %[[RHSE]], 8
|
|
// CHECK: br i1 %[[CMP]]
|
|
// CHECK: call void @__ubsan_handle_shift_out_of_bounds_abort
|
|
|
|
E << E;
|
|
// CHECK: %[[LHSE:.+]] = load i9, i9*
|
|
// CHECK: %[[RHSE:.+]] = load i9, i9*
|
|
// CHECK: %[[CMP:.+]] = icmp ule i9 %[[RHSE]], 8
|
|
// CHECK: br i1 %[[CMP]]
|
|
// CHECK: %[[ZEROS:.+]] = sub nuw nsw i9 8, %[[RHSE]]
|
|
// CHECK: %[[CHECK:.+]] = lshr i9 %[[LHSE]], %[[ZEROS]]
|
|
// CHECK: %[[SKIPSIGN:.+]] = lshr i9 %[[CHECK]], 1
|
|
// CHECK: %[[CHECK:.+]] = icmp eq i9 %[[SKIPSIGN]]
|
|
// CHECK: %[[PHI:.+]] = phi i1 [ true, %{{.+}} ], [ %[[CHECK]], %{{.+}} ]
|
|
// CHECK: and i1 %[[CMP]], %[[PHI]]
|
|
// CHECK: call void @__ubsan_handle_shift_out_of_bounds_abort
|
|
}
|
|
|
|
// CHECK: define void @_Z21SignedIntegerOverflowU7_ExtIntILi93EEiU7_ExtIntILi4EEiU7_ExtIntILi31EEi
|
|
void SignedIntegerOverflow(_ExtInt(93) BiggestE,
|
|
_ExtInt(4) SmallestE,
|
|
_ExtInt(31) JustRightE) {
|
|
BiggestE + BiggestE;
|
|
// CHECK: %[[LOADBIGGESTE2:.+]] = load i93
|
|
// CHECK: store i93 %[[LOADBIGGESTE2]], i93* %[[BIGGESTEADDR:.+]]
|
|
// CHECK: %[[LOAD1:.+]] = load i93, i93* %[[BIGGESTEADDR]]
|
|
// CHECK: %[[LOAD2:.+]] = load i93, i93* %[[BIGGESTEADDR]]
|
|
// CHECK: %[[OFCALL:.+]] = call { i93, i1 } @llvm.sadd.with.overflow.i93(i93 %[[LOAD1]], i93 %[[LOAD2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i93, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i93, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_add_overflow_abort
|
|
|
|
SmallestE - SmallestE;
|
|
// CHECK: %[[LOAD1:.+]] = load i4, i4*
|
|
// CHECK: %[[LOAD2:.+]] = load i4, i4*
|
|
// CHECK: %[[OFCALL:.+]] = call { i4, i1 } @llvm.ssub.with.overflow.i4(i4 %[[LOAD1]], i4 %[[LOAD2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i4, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i4, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_sub_overflow_abort
|
|
|
|
JustRightE * JustRightE;
|
|
// CHECK: %[[LOAD1:.+]] = load i31, i31*
|
|
// CHECK: %[[LOAD2:.+]] = load i31, i31*
|
|
// CHECK: %[[OFCALL:.+]] = call { i31, i1 } @llvm.smul.with.overflow.i31(i31 %[[LOAD1]], i31 %[[LOAD2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i31, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i31, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_mul_overflow_abort
|
|
}
|
|
|
|
// CHECK: define void @_Z23UnsignedIntegerOverflowjU7_ExtIntILi23EEjU7_ExtIntILi35EEj
|
|
void UnsignedIntegerOverflow(unsigned u,
|
|
unsigned _ExtInt(23) SmallE,
|
|
unsigned _ExtInt(35) BigE) {
|
|
u = SmallE + SmallE;
|
|
// CHECK: %[[BIGGESTEADDR:.+]] = alloca i23
|
|
// CHECK: %[[LOADE1:.+]] = load i23, i23* %[[BIGGESTEADDR]]
|
|
// CHECK: %[[LOADE2:.+]] = load i23, i23* %[[BIGGESTEADDR]]
|
|
// CHECK: %[[OFCALL:.+]] = call { i23, i1 } @llvm.uadd.with.overflow.i23(i23 %[[LOADE1]], i23 %[[LOADE2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i23, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i23, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_add_overflow_abort
|
|
|
|
SmallE = u + u;
|
|
// CHECK: %[[LOADU1:.+]] = load i32, i32*
|
|
// CHECK: %[[LOADU2:.+]] = load i32, i32*
|
|
// CHECK: %[[OFCALL:.+]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 %[[LOADU1]], i32 %[[LOADU2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i32, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i32, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_add_overflow_abort
|
|
|
|
SmallE = SmallE + SmallE;
|
|
// CHECK: %[[LOADE1:.+]] = load i23, i23*
|
|
// CHECK: %[[LOADE2:.+]] = load i23, i23*
|
|
// CHECK: %[[OFCALL:.+]] = call { i23, i1 } @llvm.uadd.with.overflow.i23(i23 %[[LOADE1]], i23 %[[LOADE2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i23, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i23, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_add_overflow_abort
|
|
|
|
SmallE = BigE + BigE;
|
|
// CHECK: %[[LOADE1:.+]] = load i35, i35*
|
|
// CHECK: %[[LOADE2:.+]] = load i35, i35*
|
|
// CHECK: %[[OFCALL:.+]] = call { i35, i1 } @llvm.uadd.with.overflow.i35(i35 %[[LOADE1]], i35 %[[LOADE2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i35, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i35, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_add_overflow_abort
|
|
|
|
BigE = BigE + BigE;
|
|
// CHECK: %[[LOADE1:.+]] = load i35, i35*
|
|
// CHECK: %[[LOADE2:.+]] = load i35, i35*
|
|
// CHECK: %[[OFCALL:.+]] = call { i35, i1 } @llvm.uadd.with.overflow.i35(i35 %[[LOADE1]], i35 %[[LOADE2]])
|
|
// CHECK: %[[EXRESULT:.+]] = extractvalue { i35, i1 } %[[OFCALL]], 0
|
|
// CHECK: %[[OFRESULT:.+]] = extractvalue { i35, i1 } %[[OFCALL]], 1
|
|
// CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
|
|
// CHECK: br i1 %[[CHECK]]
|
|
// CHECK: call void @__ubsan_handle_add_overflow_abort
|
|
}
|