Clang Project

clang_source_code/test/CodeGen/catch-implicit-integer-truncations-CompoundAssignOperator.c
1// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK
2
3// RUN: %clang_cc1 -fsanitize=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -fno-sanitize-recover=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
4// RUN: %clang_cc1 -fsanitize=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -fsanitize-recover=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
5// RUN: %clang_cc1 -fsanitize=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -fsanitize-trap=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
6
7// LHS can be of 2 types: unsigned char and signed char
8// RHS can be of 4 types: unsigned char, signed char, unsigned int, signed int.
9// Therefore there are total of 8 tests per group.
10
11// Also there are total of 10 compound operators (+=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=)
12
13// CHECK-SANITIZE-ANYRECOVER: @[[INT:.*]] = {{.*}} c"'int'\00" }
14// CHECK-SANITIZE-ANYRECOVER: @[[UNSIGNED_CHAR:.*]] = {{.*}} c"'unsigned char'\00" }
15// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
16// CHECK-SANITIZE-ANYRECOVER: @[[LINE_200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
17// CHECK-SANITIZE-ANYRECOVER: @[[UNSIGNED_INT:.*]] = {{.*}} c"'unsigned int'\00" }
18// CHECK-SANITIZE-ANYRECOVER: @[[LINE_300_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 300, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
19// CHECK-SANITIZE-ANYRECOVER: @[[LINE_400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
20// CHECK-SANITIZE-ANYRECOVER: @[[SIGNED_CHAR:.*]] = {{.*}} c"'signed char'\00" }
21// CHECK-SANITIZE-ANYRECOVER: @[[LINE_500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 500, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
22// CHECK-SANITIZE-ANYRECOVER: @[[LINE_600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
23// CHECK-SANITIZE-ANYRECOVER: @[[LINE_700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 700, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
24// CHECK-SANITIZE-ANYRECOVER: @[[LINE_800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
25
26// CHECK-SANITIZE-ANYRECOVER: @[[LINE_900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 900, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
27// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
28// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1100_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 1100, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
29// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
30// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1300, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
31// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
32// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1500, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
33// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
34
35// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1700, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
36// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
37// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1900_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 1900, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
38// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
39// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2100, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
40// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
41// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2300, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
42// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
43
44// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2500, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
45// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
46// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2700_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 2700, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
47// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
48// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2900, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
49// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
50// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3100, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
51// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
52
53// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3300, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
54// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
55// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3500_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 3500, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
56// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
57// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3700, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
58// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
59// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3900, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
60// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
61
62// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4100, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
63// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
64// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4300, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
65// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
66// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4500, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
67// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
68// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4700, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
69// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
70
71// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4900, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
72// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
73// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5100, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
74// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
75// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5300, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
76// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
77// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5500, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
78// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
79
80// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5700, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
81// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
82// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5900_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 5900, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
83// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
84// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6100, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
85// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
86// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6300, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
87// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
88
89// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6500, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
90// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
91// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6700_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 6700, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
92// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
93// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6900, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
94// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
95// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7100, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
96// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7200, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
97
98// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7300, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
99// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7400, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
100// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7500_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 7500, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 1 }
101// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7600, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[UNSIGNED_CHAR]], i8 2 }
102// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7700, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
103// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7800, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
104// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7900, i32 10 }, {{.*}}* @[[UNSIGNED_INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
105// CHECK-SANITIZE-ANYRECOVER: @[[LINE_8000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 8000, i32 10 }, {{.*}}* @[[INT]], {{.*}}* @[[SIGNED_CHAR]], i8 2 }
106
107//----------------------------------------------------------------------------//
108// Compound add operator.                                                     //
109//----------------------------------------------------------------------------//
110
111// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_char
112void unsigned_char_add_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
113  // CHECK: {
114  // CHECK-NEXT: entry:
115  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
116  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
117  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
118  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
119  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
120  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
121  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
122  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
123  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
124  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]
125  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
126  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
127  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
128  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
129  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
130  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
131  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
132  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
133  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
134  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
135  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
136  // CHECK-SANITIZE: [[CONT]]:
137  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
138  // CHECK-NEXT: ret void
139  // CHECK-NEXT: }
140#line 100
141  (*LHS) += RHS;
142}
143
144// CHECK-LABEL: @unsigned_char_add_signed_char_signed_char
145void unsigned_char_add_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
146  // CHECK: {
147  // CHECK-NEXT: entry:
148  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
149  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
150  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
151  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
152  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
153  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
154  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
155  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
156  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
157  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]
158  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
159  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
160  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
161  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
162  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
163  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
164  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
165  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
166  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
167  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
168  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
169  // CHECK-SANITIZE: [[CONT]]:
170  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
171  // CHECK-NEXT: ret void
172  // CHECK-NEXT: }
173#line 200
174  (*LHS) += RHS;
175}
176
177// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_int
178void unsigned_char_add_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
179  // CHECK: {
180  // CHECK-NEXT: entry:
181  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
182  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
183  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
184  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
185  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
186  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
187  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
188  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
189  // CHECK-NEXT: %[[SRC:.*]] = add i32 %[[LHSEXT]], %[[RHS]]
190  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
191  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
192  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
193  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
194  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
195  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
196  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
197  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_300_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
198  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_300_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
199  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
200  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
201  // CHECK-SANITIZE: [[CONT]]:
202  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
203  // CHECK-NEXT: ret void
204  // CHECK-NEXT: }
205#line 300
206  (*LHS) += RHS;
207}
208
209// CHECK-LABEL: @unsigned_char_add_signed_char_signed_int
210void unsigned_char_add_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
211  // CHECK: {
212  // CHECK-NEXT: entry:
213  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
214  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
215  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
216  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
217  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
218  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
219  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
220  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
221  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHS]]
222  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
223  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
224  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
225  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
226  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
227  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
228  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
229  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
230  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
231  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
232  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
233  // CHECK-SANITIZE: [[CONT]]:
234  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
235  // CHECK-NEXT: ret void
236  // CHECK-NEXT: }
237#line 400
238  (*LHS) += RHS;
239}
240
241// CHECK-LABEL: @signed_char_add_unsigned_char
242void signed_char_add_unsigned_char(signed char *LHS, unsigned char RHS) {
243  // CHECK: {
244  // CHECK-NEXT: entry:
245  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
246  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
247  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
248  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
249  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
250  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
251  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
252  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
253  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
254  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]
255  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
256  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
257  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
258  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
259  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
260  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
261  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
262  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
263  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
264  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
265  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
266  // CHECK-SANITIZE: [[CONT]]:
267  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
268  // CHECK-NEXT: ret void
269  // CHECK-NEXT: }
270#line 500
271  (*LHS) += RHS;
272}
273
274// CHECK-LABEL: @signed_char_add_signed_char
275void signed_char_add_signed_char(signed char *LHS, signed char RHS) {
276  // CHECK: {
277  // CHECK-NEXT: entry:
278  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
279  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
280  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
281  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
282  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
283  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
284  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
285  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
286  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
287  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]
288  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
289  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
290  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
291  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
292  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
293  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
294  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
295  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
296  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
297  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
298  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
299  // CHECK-SANITIZE: [[CONT]]:
300  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
301  // CHECK-NEXT: ret void
302  // CHECK-NEXT: }
303#line 600
304  (*LHS) += RHS;
305}
306
307// CHECK-LABEL: @signed_char_add_signed_char_unsigned_int
308void signed_char_add_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
309  // CHECK: {
310  // CHECK-NEXT: entry:
311  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
312  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
313  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
314  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
315  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
316  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
317  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
318  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
319  // CHECK-NEXT: %[[SRC:.*]] = add i32 %[[LHSEXT]], %[[RHS]]
320  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
321  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
322  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
323  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
324  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
325  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
326  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
327  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
328  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
329  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
330  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
331  // CHECK-SANITIZE: [[CONT]]:
332  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
333  // CHECK-NEXT: ret void
334  // CHECK-NEXT: }
335#line 700
336  (*LHS) += RHS;
337}
338
339// CHECK-LABEL: @signed_char_add_signed_char_signed_int
340void signed_char_add_signed_char_signed_int(signed char *LHS, signed int RHS) {
341  // CHECK: {
342  // CHECK-NEXT: entry:
343  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
344  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
345  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
346  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
347  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
348  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
349  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
350  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
351  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHS]]
352  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
353  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
354  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
355  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
356  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
357  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
358  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
359  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
360  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
361  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
362  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
363  // CHECK-SANITIZE: [[CONT]]:
364  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
365  // CHECK-NEXT: ret void
366  // CHECK-NEXT: }
367#line 800
368  (*LHS) += RHS;
369}
370
371//----------------------------------------------------------------------------//
372// Compound subtract operator.                                                //
373//----------------------------------------------------------------------------//
374
375// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_char
376void unsigned_char_sub_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
377  // CHECK: {
378  // CHECK-NEXT: entry:
379  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
380  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
381  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
382  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
383  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
384  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
385  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
386  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
387  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
388  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]
389  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
390  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
391  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
392  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
393  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
394  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
395  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
396  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
397  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
398  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
399  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
400  // CHECK-SANITIZE: [[CONT]]:
401  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
402  // CHECK-NEXT: ret void
403  // CHECK-NEXT: }
404#line 900
405  (*LHS) -= RHS;
406}
407
408// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_char
409void unsigned_char_sub_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
410  // CHECK: {
411  // CHECK-NEXT: entry:
412  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
413  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
414  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
415  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
416  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
417  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
418  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
419  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
420  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
421  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]
422  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
423  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
424  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
425  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
426  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
427  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
428  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
429  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
430  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
431  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
432  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
433  // CHECK-SANITIZE: [[CONT]]:
434  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
435  // CHECK-NEXT: ret void
436  // CHECK-NEXT: }
437#line 1000
438  (*LHS) -= RHS;
439}
440
441// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_int
442void unsigned_char_sub_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
443  // CHECK: {
444  // CHECK-NEXT: entry:
445  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
446  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
447  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
448  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
449  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
450  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
451  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
452  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
453  // CHECK-NEXT: %[[SRC:.*]] = sub i32 %[[LHSEXT]], %[[RHS]]
454  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
455  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
456  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
457  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
458  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
459  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
460  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
461  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1100_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
462  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1100_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
463  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
464  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
465  // CHECK-SANITIZE: [[CONT]]:
466  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
467  // CHECK-NEXT: ret void
468  // CHECK-NEXT: }
469#line 1100
470  (*LHS) -= RHS;
471}
472
473// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_int
474void unsigned_char_sub_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
475  // CHECK: {
476  // CHECK-NEXT: entry:
477  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
478  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
479  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
480  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
481  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
482  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
483  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
484  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
485  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]
486  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
487  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
488  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
489  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
490  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
491  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
492  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
493  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
494  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
495  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
496  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
497  // CHECK-SANITIZE: [[CONT]]:
498  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
499  // CHECK-NEXT: ret void
500  // CHECK-NEXT: }
501#line 1200
502  (*LHS) -= RHS;
503}
504
505// CHECK-LABEL: @signed_char_sub_unsigned_char
506void signed_char_sub_unsigned_char(signed char *LHS, unsigned char RHS) {
507  // CHECK: {
508  // CHECK-NEXT: entry:
509  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
510  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
511  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
512  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
513  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
514  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
515  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
516  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
517  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
518  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]
519  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
520  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
521  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
522  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
523  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
524  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
525  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
526  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
527  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
528  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
529  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
530  // CHECK-SANITIZE: [[CONT]]:
531  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
532  // CHECK-NEXT: ret void
533  // CHECK-NEXT: }
534#line 1300
535  (*LHS) -= RHS;
536}
537
538// CHECK-LABEL: @signed_char_sub_signed_char
539void signed_char_sub_signed_char(signed char *LHS, signed char RHS) {
540  // CHECK: {
541  // CHECK-NEXT: entry:
542  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
543  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
544  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
545  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
546  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
547  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
548  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
549  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
550  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
551  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]
552  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
553  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
554  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
555  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
556  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
557  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
558  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
559  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
560  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
561  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
562  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
563  // CHECK-SANITIZE: [[CONT]]:
564  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
565  // CHECK-NEXT: ret void
566  // CHECK-NEXT: }
567#line 1400
568  (*LHS) -= RHS;
569}
570
571// CHECK-LABEL: @signed_char_sub_signed_char_unsigned_int
572void signed_char_sub_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
573  // CHECK: {
574  // CHECK-NEXT: entry:
575  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
576  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
577  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
578  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
579  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
580  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
581  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
582  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
583  // CHECK-NEXT: %[[SRC:.*]] = sub i32 %[[LHSEXT]], %[[RHS]]
584  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
585  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
586  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
587  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
588  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
589  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
590  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
591  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
592  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
593  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
594  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
595  // CHECK-SANITIZE: [[CONT]]:
596  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
597  // CHECK-NEXT: ret void
598  // CHECK-NEXT: }
599#line 1500
600  (*LHS) -= RHS;
601}
602
603// CHECK-LABEL: @signed_char_sub_signed_char_signed_int
604void signed_char_sub_signed_char_signed_int(signed char *LHS, signed int RHS) {
605  // CHECK: {
606  // CHECK-NEXT: entry:
607  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
608  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
609  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
610  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
611  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
612  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
613  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
614  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
615  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]
616  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
617  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
618  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
619  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
620  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
621  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
622  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
623  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
624  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
625  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
626  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
627  // CHECK-SANITIZE: [[CONT]]:
628  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
629  // CHECK-NEXT: ret void
630  // CHECK-NEXT: }
631#line 1600
632  (*LHS) -= RHS;
633}
634
635//----------------------------------------------------------------------------//
636// Compound multiply operator.                                                //
637//----------------------------------------------------------------------------//
638
639// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_char
640void unsigned_char_mul_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
641  // CHECK: {
642  // CHECK-NEXT: entry:
643  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
644  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
645  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
646  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
647  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
648  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
649  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
650  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
651  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
652  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]
653  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
654  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
655  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
656  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
657  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
658  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
659  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
660  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
661  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
662  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
663  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
664  // CHECK-SANITIZE: [[CONT]]:
665  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
666  // CHECK-NEXT: ret void
667  // CHECK-NEXT: }
668#line 1700
669  (*LHS) *= RHS;
670}
671
672// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_char
673void unsigned_char_mul_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
674  // CHECK: {
675  // CHECK-NEXT: entry:
676  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
677  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
678  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
679  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
680  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
681  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
682  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
683  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
684  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
685  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]
686  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
687  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
688  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
689  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
690  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
691  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
692  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
693  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
694  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
695  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
696  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
697  // CHECK-SANITIZE: [[CONT]]:
698  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
699  // CHECK-NEXT: ret void
700  // CHECK-NEXT: }
701#line 1800
702  (*LHS) *= RHS;
703}
704
705// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_int
706void unsigned_char_mul_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
707  // CHECK: {
708  // CHECK-NEXT: entry:
709  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
710  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
711  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
712  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
713  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
714  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
715  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
716  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
717  // CHECK-NEXT: %[[SRC:.*]] = mul i32 %[[LHSEXT]], %[[RHS]]
718  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
719  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
720  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
721  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
722  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
723  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
724  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
725  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1900_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
726  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_1900_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
727  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
728  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
729  // CHECK-SANITIZE: [[CONT]]:
730  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
731  // CHECK-NEXT: ret void
732  // CHECK-NEXT: }
733#line 1900
734  (*LHS) *= RHS;
735}
736
737// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_int
738void unsigned_char_mul_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
739  // CHECK: {
740  // CHECK-NEXT: entry:
741  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
742  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
743  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
744  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
745  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
746  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
747  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
748  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
749  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]
750  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
751  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
752  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
753  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
754  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
755  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
756  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
757  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
758  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
759  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
760  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
761  // CHECK-SANITIZE: [[CONT]]:
762  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
763  // CHECK-NEXT: ret void
764  // CHECK-NEXT: }
765#line 2000
766  (*LHS) *= RHS;
767}
768
769// CHECK-LABEL: @signed_char_mul_unsigned_char
770void signed_char_mul_unsigned_char(signed char *LHS, unsigned char RHS) {
771  // CHECK: {
772  // CHECK-NEXT: entry:
773  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
774  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
775  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
776  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
777  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
778  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
779  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
780  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
781  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
782  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]
783  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
784  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
785  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
786  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
787  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
788  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
789  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
790  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
791  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
792  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
793  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
794  // CHECK-SANITIZE: [[CONT]]:
795  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
796  // CHECK-NEXT: ret void
797  // CHECK-NEXT: }
798#line 2100
799  (*LHS) *= RHS;
800}
801
802// CHECK-LABEL: @signed_char_mul_signed_char
803void signed_char_mul_signed_char(signed char *LHS, signed char RHS) {
804  // CHECK: {
805  // CHECK-NEXT: entry:
806  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
807  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
808  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
809  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
810  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
811  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
812  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
813  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
814  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
815  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]
816  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
817  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
818  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
819  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
820  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
821  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
822  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
823  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
824  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
825  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
826  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
827  // CHECK-SANITIZE: [[CONT]]:
828  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
829  // CHECK-NEXT: ret void
830  // CHECK-NEXT: }
831#line 2200
832  (*LHS) *= RHS;
833}
834
835// CHECK-LABEL: @signed_char_mul_signed_char_unsigned_int
836void signed_char_mul_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
837  // CHECK: {
838  // CHECK-NEXT: entry:
839  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
840  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
841  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
842  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
843  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
844  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
845  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
846  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
847  // CHECK-NEXT: %[[SRC:.*]] = mul i32 %[[LHSEXT]], %[[RHS]]
848  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
849  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
850  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
851  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
852  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
853  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
854  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
855  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
856  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
857  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
858  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
859  // CHECK-SANITIZE: [[CONT]]:
860  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
861  // CHECK-NEXT: ret void
862  // CHECK-NEXT: }
863#line 2300
864  (*LHS) *= RHS;
865}
866
867// CHECK-LABEL: @signed_char_mul_signed_char_signed_int
868void signed_char_mul_signed_char_signed_int(signed char *LHS, signed int RHS) {
869  // CHECK: {
870  // CHECK-NEXT: entry:
871  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
872  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
873  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
874  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
875  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
876  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
877  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
878  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
879  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]
880  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
881  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
882  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
883  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
884  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
885  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
886  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
887  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
888  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
889  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
890  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
891  // CHECK-SANITIZE: [[CONT]]:
892  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
893  // CHECK-NEXT: ret void
894  // CHECK-NEXT: }
895#line 2400
896  (*LHS) *= RHS;
897}
898
899//----------------------------------------------------------------------------//
900// Compound divide operator.                                                  //
901//----------------------------------------------------------------------------//
902
903// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_char
904void unsigned_char_div_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
905  // CHECK: {
906  // CHECK-NEXT: entry:
907  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
908  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
909  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
910  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
911  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
912  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
913  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
914  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
915  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
916  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]
917  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
918  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
919  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
920  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
921  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
922  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
923  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
924  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
925  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
926  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
927  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
928  // CHECK-SANITIZE: [[CONT]]:
929  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
930  // CHECK-NEXT: ret void
931  // CHECK-NEXT: }
932#line 2500
933  (*LHS) /= RHS;
934}
935
936// CHECK-LABEL: @unsigned_char_div_signed_char_signed_char
937void unsigned_char_div_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
938  // CHECK: {
939  // CHECK-NEXT: entry:
940  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
941  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
942  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
943  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
944  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
945  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
946  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
947  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
948  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
949  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]
950  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
951  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
952  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
953  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
954  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
955  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
956  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
957  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
958  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
959  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
960  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
961  // CHECK-SANITIZE: [[CONT]]:
962  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
963  // CHECK-NEXT: ret void
964  // CHECK-NEXT: }
965#line 2600
966  (*LHS) /= RHS;
967}
968
969// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_int
970void unsigned_char_div_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
971  // CHECK: {
972  // CHECK-NEXT: entry:
973  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
974  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
975  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
976  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
977  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
978  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
979  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
980  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
981  // CHECK-NEXT: %[[SRC:.*]] = udiv i32 %[[LHSEXT]], %[[RHS]]
982  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
983  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
984  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
985  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
986  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
987  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
988  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
989  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2700_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
990  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2700_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
991  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
992  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
993  // CHECK-SANITIZE: [[CONT]]:
994  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
995  // CHECK-NEXT: ret void
996  // CHECK-NEXT: }
997#line 2700
998  (*LHS) /= RHS;
999}
1000
1001// CHECK-LABEL: @unsigned_char_div_signed_char_signed_int
1002void unsigned_char_div_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
1003  // CHECK: {
1004  // CHECK-NEXT: entry:
1005  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1006  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1007  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1008  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1009  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1010  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1011  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1012  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1013  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]
1014  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1015  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1016  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1017  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1018  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1019  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1020  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1021  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1022  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1023  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1024  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1025  // CHECK-SANITIZE: [[CONT]]:
1026  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1027  // CHECK-NEXT: ret void
1028  // CHECK-NEXT: }
1029#line 2800
1030  (*LHS) /= RHS;
1031}
1032
1033// CHECK-LABEL: @signed_char_div_unsigned_char
1034void signed_char_div_unsigned_char(signed char *LHS, unsigned char RHS) {
1035  // CHECK: {
1036  // CHECK-NEXT: entry:
1037  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1038  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1039  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1040  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1041  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1042  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1043  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1044  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1045  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1046  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]
1047  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1048  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1049  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1050  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1051  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1052  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1053  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1054  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1055  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_2900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1056  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1057  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1058  // CHECK-SANITIZE: [[CONT]]:
1059  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1060  // CHECK-NEXT: ret void
1061  // CHECK-NEXT: }
1062#line 2900
1063  (*LHS) /= RHS;
1064}
1065
1066// CHECK-LABEL: @signed_char_div_signed_char
1067void signed_char_div_signed_char(signed char *LHS, signed char RHS) {
1068  // CHECK: {
1069  // CHECK-NEXT: entry:
1070  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1071  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1072  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1073  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1074  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1075  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
1076  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1077  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1078  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1079  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]
1080  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1081  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1082  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1083  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1084  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1085  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1086  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1087  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1088  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1089  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1090  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1091  // CHECK-SANITIZE: [[CONT]]:
1092  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1093  // CHECK-NEXT: ret void
1094  // CHECK-NEXT: }
1095#line 3000
1096  (*LHS) /= RHS;
1097}
1098
1099// CHECK-LABEL: @signed_char_div_signed_char_unsigned_int
1100void signed_char_div_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
1101  // CHECK: {
1102  // CHECK-NEXT: entry:
1103  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1104  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1105  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1106  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1107  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1108  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1109  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1110  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1111  // CHECK-NEXT: %[[SRC:.*]] = udiv i32 %[[LHSEXT]], %[[RHS]]
1112  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1113  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1114  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1115  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1116  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1117  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1118  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1119  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1120  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1121  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1122  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1123  // CHECK-SANITIZE: [[CONT]]:
1124  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1125  // CHECK-NEXT: ret void
1126  // CHECK-NEXT: }
1127#line 3100
1128  (*LHS) /= RHS;
1129}
1130
1131// CHECK-LABEL: @signed_char_div_signed_char_signed_int
1132void signed_char_div_signed_char_signed_int(signed char *LHS, signed int RHS) {
1133  // CHECK: {
1134  // CHECK-NEXT: entry:
1135  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1136  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1137  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1138  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1139  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1140  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1141  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1142  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1143  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]
1144  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1145  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1146  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1147  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1148  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1149  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1150  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1151  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1152  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1153  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1154  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1155  // CHECK-SANITIZE: [[CONT]]:
1156  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1157  // CHECK-NEXT: ret void
1158  // CHECK-NEXT: }
1159#line 3200
1160  (*LHS) /= RHS;
1161}
1162
1163//----------------------------------------------------------------------------//
1164// Compound remainder operator.                                               //
1165//----------------------------------------------------------------------------//
1166
1167// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_char
1168void unsigned_char_rem_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
1169  // CHECK: {
1170  // CHECK-NEXT: entry:
1171  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1172  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1173  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1174  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1175  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1176  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1177  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1178  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1179  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1180  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]
1181  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1182  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1183  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1184  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1185  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1186  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1187  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1188  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1189  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1190  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1191  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1192  // CHECK-SANITIZE: [[CONT]]:
1193  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1194  // CHECK-NEXT: ret void
1195  // CHECK-NEXT: }
1196#line 3300
1197  (*LHS) %= RHS;
1198}
1199
1200// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_char
1201void unsigned_char_rem_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
1202  // CHECK: {
1203  // CHECK-NEXT: entry:
1204  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1205  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1206  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1207  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1208  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1209  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
1210  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1211  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1212  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1213  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]
1214  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1215  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1216  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1217  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1218  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1219  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1220  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1221  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1222  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1223  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1224  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1225  // CHECK-SANITIZE: [[CONT]]:
1226  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1227  // CHECK-NEXT: ret void
1228  // CHECK-NEXT: }
1229#line 3400
1230  (*LHS) %= RHS;
1231}
1232
1233// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_int
1234void unsigned_char_rem_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
1235  // CHECK: {
1236  // CHECK-NEXT: entry:
1237  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1238  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1239  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1240  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1241  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1242  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1243  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1244  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1245  // CHECK-NEXT: %[[SRC:.*]] = urem i32 %[[LHSEXT]], %[[RHS]]
1246  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1247  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1248  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1249  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1250  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1251  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1252  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1253  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3500_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1254  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3500_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1255  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1256  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1257  // CHECK-SANITIZE: [[CONT]]:
1258  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1259  // CHECK-NEXT: ret void
1260  // CHECK-NEXT: }
1261#line 3500
1262  (*LHS) %= RHS;
1263}
1264
1265// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_int
1266void unsigned_char_rem_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
1267  // CHECK: {
1268  // CHECK-NEXT: entry:
1269  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1270  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1271  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1272  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1273  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1274  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1275  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1276  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1277  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]
1278  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1279  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1280  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1281  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1282  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1283  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1284  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1285  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1286  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1287  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1288  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1289  // CHECK-SANITIZE: [[CONT]]:
1290  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1291  // CHECK-NEXT: ret void
1292  // CHECK-NEXT: }
1293#line 3600
1294  (*LHS) %= RHS;
1295}
1296
1297// CHECK-LABEL: @signed_char_rem_unsigned_char
1298void signed_char_rem_unsigned_char(signed char *LHS, unsigned char RHS) {
1299  // CHECK: {
1300  // CHECK-NEXT: entry:
1301  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1302  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1303  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1304  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1305  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1306  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1307  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1308  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1309  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1310  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]
1311  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1312  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1313  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1314  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1315  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1316  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1317  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1318  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1319  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1320  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1321  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1322  // CHECK-SANITIZE: [[CONT]]:
1323  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1324  // CHECK-NEXT: ret void
1325  // CHECK-NEXT: }
1326#line 3700
1327  (*LHS) %= RHS;
1328}
1329
1330// CHECK-LABEL: @signed_char_rem_signed_char
1331void signed_char_rem_signed_char(signed char *LHS, signed char RHS) {
1332  // CHECK: {
1333  // CHECK-NEXT: entry:
1334  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1335  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1336  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1337  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1338  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1339  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
1340  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1341  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1342  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1343  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]
1344  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1345  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1346  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1347  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1348  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1349  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1350  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1351  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1352  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1353  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1354  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1355  // CHECK-SANITIZE: [[CONT]]:
1356  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1357  // CHECK-NEXT: ret void
1358  // CHECK-NEXT: }
1359#line 3800
1360  (*LHS) %= RHS;
1361}
1362
1363// CHECK-LABEL: @signed_char_rem_signed_char_unsigned_int
1364void signed_char_rem_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
1365  // CHECK: {
1366  // CHECK-NEXT: entry:
1367  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1368  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1369  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1370  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1371  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1372  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1373  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1374  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1375  // CHECK-NEXT: %[[SRC:.*]] = urem i32 %[[LHSEXT]], %[[RHS]]
1376  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1377  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1378  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1379  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1380  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1381  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1382  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1383  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1384  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_3900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1385  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1386  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1387  // CHECK-SANITIZE: [[CONT]]:
1388  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1389  // CHECK-NEXT: ret void
1390  // CHECK-NEXT: }
1391#line 3900
1392  (*LHS) %= RHS;
1393}
1394
1395// CHECK-LABEL: @signed_char_rem_signed_char_signed_int
1396void signed_char_rem_signed_char_signed_int(signed char *LHS, signed int RHS) {
1397  // CHECK: {
1398  // CHECK-NEXT: entry:
1399  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1400  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1401  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1402  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1403  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1404  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1405  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1406  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1407  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]
1408  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1409  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1410  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1411  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1412  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1413  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1414  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1415  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1416  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1417  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1418  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1419  // CHECK-SANITIZE: [[CONT]]:
1420  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1421  // CHECK-NEXT: ret void
1422  // CHECK-NEXT: }
1423#line 4000
1424  (*LHS) %= RHS;
1425}
1426
1427//----------------------------------------------------------------------------//
1428// Compound left-shift operator.                                              //
1429//----------------------------------------------------------------------------//
1430
1431// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_char
1432void unsigned_char_shl_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
1433  // CHECK: {
1434  // CHECK-NEXT: entry:
1435  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1436  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1437  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1438  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1439  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1440  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1441  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1442  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1443  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1444  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]
1445  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1446  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1447  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1448  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1449  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1450  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1451  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1452  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1453  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1454  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1455  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1456  // CHECK-SANITIZE: [[CONT]]:
1457  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1458  // CHECK-NEXT: ret void
1459  // CHECK-NEXT: }
1460#line 4100
1461  (*LHS) <<= RHS;
1462}
1463
1464// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_char
1465void unsigned_char_shl_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
1466  // CHECK: {
1467  // CHECK-NEXT: entry:
1468  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1469  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1470  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1471  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1472  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1473  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
1474  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1475  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1476  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1477  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]
1478  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1479  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1480  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1481  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1482  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1483  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1484  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1485  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1486  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1487  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1488  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1489  // CHECK-SANITIZE: [[CONT]]:
1490  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1491  // CHECK-NEXT: ret void
1492  // CHECK-NEXT: }
1493#line 4200
1494  (*LHS) <<= RHS;
1495}
1496
1497// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_int
1498void unsigned_char_shl_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
1499  // CHECK: {
1500  // CHECK-NEXT: entry:
1501  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1502  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1503  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1504  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1505  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1506  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1507  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1508  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1509  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]
1510  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1511  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1512  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1513  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1514  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1515  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1516  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1517  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1518  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1519  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1520  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1521  // CHECK-SANITIZE: [[CONT]]:
1522  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1523  // CHECK-NEXT: ret void
1524  // CHECK-NEXT: }
1525#line 4300
1526  (*LHS) <<= RHS;
1527}
1528
1529// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_int
1530void unsigned_char_shl_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
1531  // CHECK: {
1532  // CHECK-NEXT: entry:
1533  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1534  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1535  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1536  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1537  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1538  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1539  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1540  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1541  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]
1542  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1543  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1544  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1545  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1546  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1547  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1548  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1549  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1550  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1551  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1552  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1553  // CHECK-SANITIZE: [[CONT]]:
1554  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1555  // CHECK-NEXT: ret void
1556  // CHECK-NEXT: }
1557#line 4400
1558  (*LHS) <<= RHS;
1559}
1560
1561// CHECK-LABEL: @signed_char_shl_unsigned_char
1562void signed_char_shl_unsigned_char(signed char *LHS, unsigned char RHS) {
1563  // CHECK: {
1564  // CHECK-NEXT: entry:
1565  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1566  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1567  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1568  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1569  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1570  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1571  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1572  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1573  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1574  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]
1575  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1576  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1577  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1578  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1579  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1580  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1581  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1582  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1583  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1584  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1585  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1586  // CHECK-SANITIZE: [[CONT]]:
1587  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1588  // CHECK-NEXT: ret void
1589  // CHECK-NEXT: }
1590#line 4500
1591  (*LHS) <<= RHS;
1592}
1593
1594// CHECK-LABEL: @signed_char_shl_signed_char
1595void signed_char_shl_signed_char(signed char *LHS, signed char RHS) {
1596  // CHECK: {
1597  // CHECK-NEXT: entry:
1598  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1599  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1600  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1601  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1602  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1603  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
1604  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1605  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1606  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1607  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]
1608  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1609  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1610  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1611  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1612  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1613  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1614  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1615  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1616  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1617  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1618  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1619  // CHECK-SANITIZE: [[CONT]]:
1620  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1621  // CHECK-NEXT: ret void
1622  // CHECK-NEXT: }
1623#line 4600
1624  (*LHS) <<= RHS;
1625}
1626
1627// CHECK-LABEL: @signed_char_shl_signed_char_unsigned_int
1628void signed_char_shl_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
1629  // CHECK: {
1630  // CHECK-NEXT: entry:
1631  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1632  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1633  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1634  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1635  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1636  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1637  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1638  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1639  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]
1640  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1641  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1642  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1643  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1644  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1645  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1646  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1647  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1648  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1649  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1650  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1651  // CHECK-SANITIZE: [[CONT]]:
1652  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1653  // CHECK-NEXT: ret void
1654  // CHECK-NEXT: }
1655#line 4700
1656  (*LHS) <<= RHS;
1657}
1658
1659// CHECK-LABEL: @signed_char_shl_signed_char_signed_int
1660void signed_char_shl_signed_char_signed_int(signed char *LHS, signed int RHS) {
1661  // CHECK: {
1662  // CHECK-NEXT: entry:
1663  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1664  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1665  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1666  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1667  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1668  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1669  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1670  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1671  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]
1672  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1673  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1674  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1675  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1676  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1677  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1678  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1679  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1680  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1681  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1682  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1683  // CHECK-SANITIZE: [[CONT]]:
1684  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1685  // CHECK-NEXT: ret void
1686  // CHECK-NEXT: }
1687#line 4800
1688  (*LHS) <<= RHS;
1689}
1690
1691//----------------------------------------------------------------------------//
1692// Compound right-shift operator.                                             //
1693//----------------------------------------------------------------------------//
1694
1695// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_char
1696void unsigned_char_shr_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
1697  // CHECK: {
1698  // CHECK-NEXT: entry:
1699  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1700  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1701  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1702  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1703  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1704  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1705  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1706  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1707  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1708  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]
1709  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1710  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1711  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1712  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1713  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1714  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1715  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1716  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1717  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_4900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1718  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1719  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1720  // CHECK-SANITIZE: [[CONT]]:
1721  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1722  // CHECK-NEXT: ret void
1723  // CHECK-NEXT: }
1724#line 4900
1725  (*LHS) >>= RHS;
1726}
1727
1728// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_char
1729void unsigned_char_shr_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
1730  // CHECK: {
1731  // CHECK-NEXT: entry:
1732  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1733  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1734  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1735  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1736  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1737  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
1738  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1739  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1740  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1741  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]
1742  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1743  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1744  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1745  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1746  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1747  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1748  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1749  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1750  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1751  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1752  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1753  // CHECK-SANITIZE: [[CONT]]:
1754  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1755  // CHECK-NEXT: ret void
1756  // CHECK-NEXT: }
1757#line 5000
1758  (*LHS) >>= RHS;
1759}
1760
1761// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_int
1762void unsigned_char_shr_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
1763  // CHECK: {
1764  // CHECK-NEXT: entry:
1765  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1766  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1767  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1768  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1769  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1770  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1771  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1772  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1773  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]
1774  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1775  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1776  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1777  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1778  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1779  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1780  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1781  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1782  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1783  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1784  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1785  // CHECK-SANITIZE: [[CONT]]:
1786  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1787  // CHECK-NEXT: ret void
1788  // CHECK-NEXT: }
1789#line 5100
1790  (*LHS) >>= RHS;
1791}
1792
1793// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_int
1794void unsigned_char_shr_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
1795  // CHECK: {
1796  // CHECK-NEXT: entry:
1797  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1798  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1799  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1800  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1801  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1802  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1803  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1804  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1805  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]
1806  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1807  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1808  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1809  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1810  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1811  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1812  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1813  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1814  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1815  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1816  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1817  // CHECK-SANITIZE: [[CONT]]:
1818  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1819  // CHECK-NEXT: ret void
1820  // CHECK-NEXT: }
1821#line 5200
1822  (*LHS) >>= RHS;
1823}
1824
1825// CHECK-LABEL: @signed_char_shr_unsigned_char
1826void signed_char_shr_unsigned_char(signed char *LHS, unsigned char RHS) {
1827  // CHECK: {
1828  // CHECK-NEXT: entry:
1829  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1830  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1831  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1832  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1833  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1834  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1835  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1836  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1837  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1838  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]
1839  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1840  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1841  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1842  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1843  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1844  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1845  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1846  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1847  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1848  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1849  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1850  // CHECK-SANITIZE: [[CONT]]:
1851  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1852  // CHECK-NEXT: ret void
1853  // CHECK-NEXT: }
1854#line 5300
1855  (*LHS) >>= RHS;
1856}
1857
1858// CHECK-LABEL: @signed_char_shr_signed_char
1859void signed_char_shr_signed_char(signed char *LHS, signed char RHS) {
1860  // CHECK: {
1861  // CHECK-NEXT: entry:
1862  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1863  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1864  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1865  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1866  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1867  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
1868  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1869  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1870  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1871  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]
1872  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1873  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1874  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1875  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1876  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1877  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1878  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1879  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1880  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1881  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1882  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1883  // CHECK-SANITIZE: [[CONT]]:
1884  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1885  // CHECK-NEXT: ret void
1886  // CHECK-NEXT: }
1887#line 5400
1888  (*LHS) >>= RHS;
1889}
1890
1891// CHECK-LABEL: @signed_char_shr_signed_char_unsigned_int
1892void signed_char_shr_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
1893  // CHECK: {
1894  // CHECK-NEXT: entry:
1895  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1896  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1897  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1898  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1899  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1900  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1901  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1902  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1903  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]
1904  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1905  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1906  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1907  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1908  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1909  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1910  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1911  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1912  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1913  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1914  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1915  // CHECK-SANITIZE: [[CONT]]:
1916  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1917  // CHECK-NEXT: ret void
1918  // CHECK-NEXT: }
1919#line 5500
1920  (*LHS) >>= RHS;
1921}
1922
1923// CHECK-LABEL: @signed_char_shr_signed_char_signed_int
1924void signed_char_shr_signed_char_signed_int(signed char *LHS, signed int RHS) {
1925  // CHECK: {
1926  // CHECK-NEXT: entry:
1927  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1928  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
1929  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1930  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
1931  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
1932  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1933  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1934  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
1935  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]
1936  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1937  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
1938  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1939  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1940  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1941  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1942  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1943  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1944  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1945  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1946  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1947  // CHECK-SANITIZE: [[CONT]]:
1948  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1949  // CHECK-NEXT: ret void
1950  // CHECK-NEXT: }
1951#line 5600
1952  (*LHS) >>= RHS;
1953}
1954
1955//----------------------------------------------------------------------------//
1956// Compound and operator.                                                     //
1957//----------------------------------------------------------------------------//
1958
1959// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_char
1960void unsigned_char_and_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
1961  // CHECK: {
1962  // CHECK-NEXT: entry:
1963  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1964  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1965  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1966  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
1967  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
1968  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
1969  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
1970  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
1971  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
1972  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]
1973  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
1974  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
1975  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
1976  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
1977  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
1978  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
1979  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
1980  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1981  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
1982  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
1983  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
1984  // CHECK-SANITIZE: [[CONT]]:
1985  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
1986  // CHECK-NEXT: ret void
1987  // CHECK-NEXT: }
1988#line 5700
1989  (*LHS) &= RHS;
1990}
1991
1992// CHECK-LABEL: @unsigned_char_and_signed_char_signed_char
1993void unsigned_char_and_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
1994  // CHECK: {
1995  // CHECK-NEXT: entry:
1996  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
1997  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
1998  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
1999  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2000  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2001  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
2002  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2003  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2004  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2005  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]
2006  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2007  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2008  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2009  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2010  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2011  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2012  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2013  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2014  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2015  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2016  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2017  // CHECK-SANITIZE: [[CONT]]:
2018  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2019  // CHECK-NEXT: ret void
2020  // CHECK-NEXT: }
2021#line 5800
2022  (*LHS) &= RHS;
2023}
2024
2025// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_int
2026void unsigned_char_and_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
2027  // CHECK: {
2028  // CHECK-NEXT: entry:
2029  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2030  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2031  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2032  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2033  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2034  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2035  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2036  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2037  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]
2038  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2039  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2040  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2041  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2042  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2043  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2044  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2045  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5900_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2046  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_5900_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2047  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2048  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2049  // CHECK-SANITIZE: [[CONT]]:
2050  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2051  // CHECK-NEXT: ret void
2052  // CHECK-NEXT: }
2053#line 5900
2054  (*LHS) &= RHS;
2055}
2056
2057// CHECK-LABEL: @unsigned_char_and_signed_char_signed_int
2058void unsigned_char_and_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
2059  // CHECK: {
2060  // CHECK-NEXT: entry:
2061  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2062  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2063  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2064  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2065  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2066  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2067  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2068  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2069  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]
2070  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2071  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2072  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2073  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2074  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2075  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2076  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2077  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2078  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2079  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2080  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2081  // CHECK-SANITIZE: [[CONT]]:
2082  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2083  // CHECK-NEXT: ret void
2084  // CHECK-NEXT: }
2085#line 6000
2086  (*LHS) &= RHS;
2087}
2088
2089// CHECK-LABEL: @signed_char_and_unsigned_char
2090void signed_char_and_unsigned_char(signed char *LHS, unsigned char RHS) {
2091  // CHECK: {
2092  // CHECK-NEXT: entry:
2093  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2094  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2095  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2096  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2097  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2098  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
2099  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2100  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2101  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2102  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]
2103  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2104  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2105  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2106  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2107  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2108  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2109  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2110  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2111  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2112  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2113  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2114  // CHECK-SANITIZE: [[CONT]]:
2115  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2116  // CHECK-NEXT: ret void
2117  // CHECK-NEXT: }
2118#line 6100
2119  (*LHS) &= RHS;
2120}
2121
2122// CHECK-LABEL: @signed_char_and_signed_char
2123void signed_char_and_signed_char(signed char *LHS, signed char RHS) {
2124  // CHECK: {
2125  // CHECK-NEXT: entry:
2126  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2127  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2128  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2129  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2130  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2131  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
2132  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2133  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2134  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2135  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]
2136  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2137  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2138  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2139  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2140  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2141  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2142  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2143  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2144  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2145  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2146  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2147  // CHECK-SANITIZE: [[CONT]]:
2148  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2149  // CHECK-NEXT: ret void
2150  // CHECK-NEXT: }
2151#line 6200
2152  (*LHS) &= RHS;
2153}
2154
2155// CHECK-LABEL: @signed_char_and_signed_char_unsigned_int
2156void signed_char_and_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
2157  // CHECK: {
2158  // CHECK-NEXT: entry:
2159  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2160  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2161  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2162  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2163  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2164  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2165  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2166  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2167  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]
2168  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2169  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2170  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2171  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2172  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2173  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2174  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2175  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2176  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2177  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2178  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2179  // CHECK-SANITIZE: [[CONT]]:
2180  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2181  // CHECK-NEXT: ret void
2182  // CHECK-NEXT: }
2183#line 6300
2184  (*LHS) &= RHS;
2185}
2186
2187// CHECK-LABEL: @signed_char_and_signed_char_signed_int
2188void signed_char_and_signed_char_signed_int(signed char *LHS, signed int RHS) {
2189  // CHECK: {
2190  // CHECK-NEXT: entry:
2191  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2192  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2193  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2194  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2195  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2196  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2197  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2198  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2199  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]
2200  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2201  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2202  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2203  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2204  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2205  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2206  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2207  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2208  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2209  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2210  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2211  // CHECK-SANITIZE: [[CONT]]:
2212  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2213  // CHECK-NEXT: ret void
2214  // CHECK-NEXT: }
2215#line 6400
2216  (*LHS) &= RHS;
2217}
2218
2219//----------------------------------------------------------------------------//
2220// Compound xor operator.                                                     //
2221//----------------------------------------------------------------------------//
2222
2223// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_char
2224void unsigned_char_or_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
2225  // CHECK: {
2226  // CHECK-NEXT: entry:
2227  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2228  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2229  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2230  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2231  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2232  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
2233  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2234  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2235  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2236  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]
2237  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2238  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2239  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2240  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2241  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2242  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2243  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2244  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2245  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6500_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2246  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2247  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2248  // CHECK-SANITIZE: [[CONT]]:
2249  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2250  // CHECK-NEXT: ret void
2251  // CHECK-NEXT: }
2252#line 6500
2253  (*LHS) |= RHS;
2254}
2255
2256// CHECK-LABEL: @unsigned_char_or_signed_char_signed_char
2257void unsigned_char_or_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
2258  // CHECK: {
2259  // CHECK-NEXT: entry:
2260  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2261  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2262  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2263  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2264  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2265  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
2266  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2267  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2268  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2269  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]
2270  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2271  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2272  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2273  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2274  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2275  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2276  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2277  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2278  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2279  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2280  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2281  // CHECK-SANITIZE: [[CONT]]:
2282  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2283  // CHECK-NEXT: ret void
2284  // CHECK-NEXT: }
2285#line 6600
2286  (*LHS) |= RHS;
2287}
2288
2289// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_int
2290void unsigned_char_or_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
2291  // CHECK: {
2292  // CHECK-NEXT: entry:
2293  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2294  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2295  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2296  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2297  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2298  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2299  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2300  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2301  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]
2302  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2303  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2304  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2305  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2306  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2307  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2308  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2309  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6700_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2310  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6700_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2311  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2312  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2313  // CHECK-SANITIZE: [[CONT]]:
2314  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2315  // CHECK-NEXT: ret void
2316  // CHECK-NEXT: }
2317#line 6700
2318  (*LHS) |= RHS;
2319}
2320
2321// CHECK-LABEL: @unsigned_char_or_signed_char_signed_int
2322void unsigned_char_or_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
2323  // CHECK: {
2324  // CHECK-NEXT: entry:
2325  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2326  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2327  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2328  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2329  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2330  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2331  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2332  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2333  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]
2334  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2335  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2336  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2337  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2338  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2339  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2340  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2341  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2342  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2343  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2344  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2345  // CHECK-SANITIZE: [[CONT]]:
2346  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2347  // CHECK-NEXT: ret void
2348  // CHECK-NEXT: }
2349#line 6800
2350  (*LHS) |= RHS;
2351}
2352
2353// CHECK-LABEL: @signed_char_or_unsigned_char
2354void signed_char_or_unsigned_char(signed char *LHS, unsigned char RHS) {
2355  // CHECK: {
2356  // CHECK-NEXT: entry:
2357  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2358  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2359  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2360  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2361  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2362  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
2363  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2364  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2365  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2366  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]
2367  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2368  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2369  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2370  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2371  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2372  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2373  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2374  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2375  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_6900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2376  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2377  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2378  // CHECK-SANITIZE: [[CONT]]:
2379  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2380  // CHECK-NEXT: ret void
2381  // CHECK-NEXT: }
2382#line 6900
2383  (*LHS) |= RHS;
2384}
2385
2386// CHECK-LABEL: @signed_char_or_signed_char
2387void signed_char_or_signed_char(signed char *LHS, signed char RHS) {
2388  // CHECK: {
2389  // CHECK-NEXT: entry:
2390  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2391  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2392  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2393  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2394  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2395  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
2396  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2397  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2398  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2399  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]
2400  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2401  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2402  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2403  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2404  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2405  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2406  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2407  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2408  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2409  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2410  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2411  // CHECK-SANITIZE: [[CONT]]:
2412  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2413  // CHECK-NEXT: ret void
2414  // CHECK-NEXT: }
2415#line 7000
2416  (*LHS) |= RHS;
2417}
2418
2419// CHECK-LABEL: @signed_char_or_signed_char_unsigned_int
2420void signed_char_or_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
2421  // CHECK: {
2422  // CHECK-NEXT: entry:
2423  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2424  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2425  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2426  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2427  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2428  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2429  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2430  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2431  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]
2432  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2433  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2434  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2435  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2436  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2437  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2438  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2439  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2440  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7100_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2441  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2442  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2443  // CHECK-SANITIZE: [[CONT]]:
2444  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2445  // CHECK-NEXT: ret void
2446  // CHECK-NEXT: }
2447#line 7100
2448  (*LHS) |= RHS;
2449}
2450
2451// CHECK-LABEL: @signed_char_or_signed_char_signed_int
2452void signed_char_or_signed_char_signed_int(signed char *LHS, signed int RHS) {
2453  // CHECK: {
2454  // CHECK-NEXT: entry:
2455  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2456  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2457  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2458  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2459  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2460  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2461  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2462  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2463  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]
2464  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2465  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2466  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2467  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2468  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2469  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2470  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2471  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2472  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7200_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2473  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2474  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2475  // CHECK-SANITIZE: [[CONT]]:
2476  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2477  // CHECK-NEXT: ret void
2478  // CHECK-NEXT: }
2479#line 7200
2480  (*LHS) |= RHS;
2481}
2482
2483//----------------------------------------------------------------------------//
2484// Compound or operator.                                                      //
2485//----------------------------------------------------------------------------//
2486
2487// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_char
2488void unsigned_char_xor_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {
2489  // CHECK: {
2490  // CHECK-NEXT: entry:
2491  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2492  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2493  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2494  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2495  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2496  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
2497  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2498  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2499  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2500  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]
2501  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2502  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2503  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2504  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2505  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2506  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2507  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2508  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2509  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7300_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2510  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2511  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2512  // CHECK-SANITIZE: [[CONT]]:
2513  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2514  // CHECK-NEXT: ret void
2515  // CHECK-NEXT: }
2516#line 7300
2517  (*LHS) ^= RHS;
2518}
2519
2520// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_char
2521void unsigned_char_xor_signed_char_signed_char(unsigned char *LHS, signed char RHS) {
2522  // CHECK: {
2523  // CHECK-NEXT: entry:
2524  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2525  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2526  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2527  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2528  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2529  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
2530  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2531  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2532  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2533  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]
2534  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2535  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2536  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2537  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2538  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2539  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2540  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2541  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2542  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7400_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2543  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2544  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2545  // CHECK-SANITIZE: [[CONT]]:
2546  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2547  // CHECK-NEXT: ret void
2548  // CHECK-NEXT: }
2549#line 7400
2550  (*LHS) ^= RHS;
2551}
2552
2553// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_int
2554void unsigned_char_xor_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {
2555  // CHECK: {
2556  // CHECK-NEXT: entry:
2557  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2558  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2559  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2560  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2561  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2562  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2563  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2564  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2565  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]
2566  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2567  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2568  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2569  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2570  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2571  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2572  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2573  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7500_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2574  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7500_UNSIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2575  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2576  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2577  // CHECK-SANITIZE: [[CONT]]:
2578  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2579  // CHECK-NEXT: ret void
2580  // CHECK-NEXT: }
2581#line 7500
2582  (*LHS) ^= RHS;
2583}
2584
2585// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_int
2586void unsigned_char_xor_signed_char_signed_int(unsigned char *LHS, signed int RHS) {
2587  // CHECK: {
2588  // CHECK-NEXT: entry:
2589  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2590  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2591  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2592  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2593  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2594  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2595  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2596  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32
2597  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]
2598  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2599  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize
2600  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2601  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2602  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2603  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2604  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2605  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2606  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7600_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2607  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2608  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2609  // CHECK-SANITIZE: [[CONT]]:
2610  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2611  // CHECK-NEXT: ret void
2612  // CHECK-NEXT: }
2613#line 7600
2614  (*LHS) ^= RHS;
2615}
2616
2617// CHECK-LABEL: @signed_char_xor_unsigned_char
2618void signed_char_xor_unsigned_char(signed char *LHS, unsigned char RHS) {
2619  // CHECK: {
2620  // CHECK-NEXT: entry:
2621  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2622  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2623  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2624  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2625  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2626  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32
2627  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2628  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2629  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2630  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]
2631  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2632  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2633  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2634  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2635  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2636  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2637  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2638  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2639  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7700_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2640  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2641  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2642  // CHECK-SANITIZE: [[CONT]]:
2643  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2644  // CHECK-NEXT: ret void
2645  // CHECK-NEXT: }
2646#line 7700
2647  (*LHS) ^= RHS;
2648}
2649
2650// CHECK-LABEL: @signed_char_xor_signed_char
2651void signed_char_xor_signed_char(signed char *LHS, signed char RHS) {
2652  // CHECK: {
2653  // CHECK-NEXT: entry:
2654  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2655  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1
2656  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2657  // CHECK-NEXT: store i8 %[[ARG1:.*]], i8* %[[RHSADDR]], align 1
2658  // CHECK-NEXT: %[[RHS:.*]] = load i8, i8* %[[RHSADDR]], align 1
2659  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32
2660  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2661  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2662  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2663  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]
2664  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2665  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2666  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2667  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2668  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2669  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2670  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2671  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2672  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7800_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2673  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2674  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2675  // CHECK-SANITIZE: [[CONT]]:
2676  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2677  // CHECK-NEXT: ret void
2678  // CHECK-NEXT: }
2679#line 7800
2680  (*LHS) ^= RHS;
2681}
2682
2683// CHECK-LABEL: @signed_char_xor_signed_char_unsigned_int
2684void signed_char_xor_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {
2685  // CHECK: {
2686  // CHECK-NEXT: entry:
2687  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2688  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2689  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2690  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2691  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2692  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2693  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2694  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2695  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]
2696  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2697  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2698  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2699  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2700  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2701  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2702  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2703  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2704  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_7900_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2705  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2706  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2707  // CHECK-SANITIZE: [[CONT]]:
2708  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2709  // CHECK-NEXT: ret void
2710  // CHECK-NEXT: }
2711#line 7900
2712  (*LHS) ^= RHS;
2713}
2714
2715// CHECK-LABEL: @signed_char_xor_signed_char_signed_int
2716void signed_char_xor_signed_char_signed_int(signed char *LHS, signed int RHS) {
2717  // CHECK: {
2718  // CHECK-NEXT: entry:
2719  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca i8*, align 8
2720  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4
2721  // CHECK-NEXT: store i8* %[[ARG0:.*]], i8** %[[ADDRESS]], align 8
2722  // CHECK-NEXT: store i32 %[[ARG1:.*]], i32* %[[RHSADDR]], align 4
2723  // CHECK-NEXT: %[[RHS:.*]] = load i32, i32* %[[RHSADDR]], align 4
2724  // CHECK-NEXT: %[[LHSADDR:.*]] = load i8*, i8** %[[ADDRESS]], align 8
2725  // CHECK-NEXT: %[[LHS:.*]] = load i8, i8* %[[LHSADDR]], align 1
2726  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32
2727  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]
2728  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8
2729  // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize
2730  // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize
2731  // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
2732  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
2733  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize
2734  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
2735  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_8000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2736  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_8000_SIGNED_TRUNCATION]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
2737  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.trap(){{.*}}, !nosanitize
2738  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
2739  // CHECK-SANITIZE: [[CONT]]:
2740  // CHECK-NEXT: store i8 %[[DST]], i8* %[[LHSADDR]], align 1
2741  // CHECK-NEXT: ret void
2742  // CHECK-NEXT: }
2743#line 8000
2744  (*LHS) ^= RHS;
2745}
2746
CodeThinker, Enjoy your reading code