Clang Project

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