2554 lines · c
1// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK2 3// RUN: %clang_cc1 -fsanitize=implicit-signed-integer-truncation,implicit-integer-sign-change -fno-sanitize-recover=implicit-signed-integer-truncation,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-UNREACHABLE4// RUN: %clang_cc1 -fsanitize=implicit-signed-integer-truncation,implicit-integer-sign-change -fsanitize-recover=implicit-signed-integer-truncation,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-RECOVER5// RUN: %clang_cc1 -fsanitize=implicit-signed-integer-truncation,implicit-integer-sign-change -fsanitize-trap=implicit-signed-integer-truncation,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-UNREACHABLE6 7// LHS can be of 2 types: unsigned char and signed char8// RHS can be of 4 types: unsigned char, signed char, unsigned int, signed int.9// Therefore there are total of 8 tests per group.10 11// Also there are total of 10 compound operators (+=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=)12 13// CHECK-SANITIZE-ANYRECOVER: @[[INT:.*]] = {{.*}} c"'int'\00" }14// CHECK-SANITIZE-ANYRECOVER: @[[UNSIGNED_CHAR:.*]] = {{.*}} c"'unsigned char'\00" }15// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }16// CHECK-SANITIZE-ANYRECOVER: @[[LINE_200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }17// CHECK-SANITIZE-ANYRECOVER: @[[LINE_400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }18// CHECK-SANITIZE-ANYRECOVER: @[[SIGNED_CHAR:.*]] = {{.*}} c"'signed char'\00" }19// CHECK-SANITIZE-ANYRECOVER: @[[LINE_500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }20// CHECK-SANITIZE-ANYRECOVER: @[[LINE_600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }21// CHECK-SANITIZE-ANYRECOVER: @[[UNSIGNED_INT:.*]] = {{.*}} c"'unsigned int'\00" }22// CHECK-SANITIZE-ANYRECOVER: @[[LINE_700_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 700, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }23// CHECK-SANITIZE-ANYRECOVER: @[[LINE_800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }24 25// CHECK-SANITIZE-ANYRECOVER: @[[LINE_900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 900, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }26// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }27// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }28// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1300, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }29// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }30// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1500_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 1500, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }31// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }32 33// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1700, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }34// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }35// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }36// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2100, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }37// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }38// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2300_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 2300, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }39// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }40 41// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2500, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }42// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }43// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }44// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2900, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }45// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }46// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3100_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 3100, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }47// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }48 49// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }50// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }51// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }52// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }53// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }54// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3900_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 3900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }55// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }56 57// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }58// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }59// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }60// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }61// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }62// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }63// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }64// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }65 66// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4900, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }67// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }68// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }69// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }70// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5300, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }71// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }72// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }73// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }74 75// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5700, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }76// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }77// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }78// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6100, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }79// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }80// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6300_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 6300, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }81// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }82 83// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6500, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }84// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }85// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }86// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6900, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }87// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }88// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7100_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 7100, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }89// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }90 91// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }92// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }93// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }94// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }95// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }96// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7900_SIGNED_TRUNCATION_OR_SIGN_CHANGE:.*]] = {{.*}}, i32 7900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 4, i32 0 }97// CHECK-SANITIZE-ANYRECOVER: @[[LINE_8000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 8000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }98 99//----------------------------------------------------------------------------//100// Compound add operator. //101//----------------------------------------------------------------------------//102 103// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_char104void unsigned_char_add_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {105 // CHECK: {106 // CHECK-NEXT: entry:107 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8108 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1109 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8110 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1111 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1112 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32113 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8114 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1115 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32116 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]117 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8118 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize119 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize120 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize121 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:122 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize123 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize124 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize125 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize126 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize127 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize128 // CHECK-SANITIZE: [[CONT]]:129 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1130 // CHECK-NEXT: ret void131 // CHECK-NEXT: }132#line 100133 (*LHS) += RHS;134}135 136// CHECK-LABEL: @unsigned_char_add_signed_char_signed_char137void unsigned_char_add_signed_char_signed_char(unsigned char *LHS, signed char RHS) {138 // CHECK: {139 // CHECK-NEXT: entry:140 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8141 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1142 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8143 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1144 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1145 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32146 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8147 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1148 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32149 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]150 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8151 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize152 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize153 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize154 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:155 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize156 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize157 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize158 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize159 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize160 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize161 // CHECK-SANITIZE: [[CONT]]:162 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1163 // CHECK-NEXT: ret void164 // CHECK-NEXT: }165#line 200166 (*LHS) += RHS;167}168 169// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_int170void unsigned_char_add_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {171#line 300172 (*LHS) += RHS;173}174 175// CHECK-LABEL: @unsigned_char_add_signed_char_signed_int176void unsigned_char_add_signed_char_signed_int(unsigned char *LHS, signed int RHS) {177 // CHECK: {178 // CHECK-NEXT: entry:179 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8180 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4181 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8182 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4183 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4184 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8185 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1186 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32187 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHS]]188 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8189 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize190 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize191 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize192 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:193 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize194 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize195 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize196 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize197 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize198 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize199 // CHECK-SANITIZE: [[CONT]]:200 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1201 // CHECK-NEXT: ret void202 // CHECK-NEXT: }203#line 400204 (*LHS) += RHS;205}206 207// CHECK-LABEL: @signed_char_add_unsigned_char208void signed_char_add_unsigned_char(signed char *LHS, unsigned char RHS) {209 // CHECK: {210 // CHECK-NEXT: entry:211 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8212 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1213 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8214 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1215 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1216 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32217 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8218 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1219 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32220 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]221 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8222 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize223 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize224 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize225 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:226 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize227 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize228 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize229 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize230 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize231 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize232 // CHECK-SANITIZE: [[CONT]]:233 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1234 // CHECK-NEXT: ret void235 // CHECK-NEXT: }236#line 500237 (*LHS) += RHS;238}239 240// CHECK-LABEL: @signed_char_add_signed_char241void signed_char_add_signed_char(signed char *LHS, signed char RHS) {242 // CHECK: {243 // CHECK-NEXT: entry:244 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8245 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1246 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8247 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1248 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1249 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32250 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8251 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1252 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32253 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]254 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8255 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize256 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize257 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize258 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:259 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize260 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize261 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize262 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize263 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize264 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize265 // CHECK-SANITIZE: [[CONT]]:266 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1267 // CHECK-NEXT: ret void268 // CHECK-NEXT: }269#line 600270 (*LHS) += RHS;271}272 273// CHECK-LABEL: @signed_char_add_signed_char_unsigned_int274void signed_char_add_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {275 // CHECK: {276 // CHECK-NEXT: entry:277 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8278 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4279 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8280 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4281 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4282 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8283 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1284 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32285 // CHECK-NEXT: %[[SRC:.*]] = add i32 %[[LHSEXT]], %[[RHS]]286 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8287 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize288 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize289 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize290 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize291 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize292 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize293 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:294 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize295 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize296 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_700_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize297 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_700_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize298 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize299 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize300 // CHECK-SANITIZE: [[CONT]]:301 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1302 // CHECK-NEXT: ret void303 // CHECK-NEXT: }304#line 700305 (*LHS) += RHS;306}307 308// CHECK-LABEL: @signed_char_add_signed_char_signed_int309void signed_char_add_signed_char_signed_int(signed char *LHS, signed int RHS) {310 // CHECK: {311 // CHECK-NEXT: entry:312 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8313 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4314 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8315 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4316 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4317 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8318 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1319 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32320 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHS]]321 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8322 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize323 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize324 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize325 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:326 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize327 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize328 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize329 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize330 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize331 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize332 // CHECK-SANITIZE: [[CONT]]:333 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1334 // CHECK-NEXT: ret void335 // CHECK-NEXT: }336#line 800337 (*LHS) += RHS;338}339 340//----------------------------------------------------------------------------//341// Compound subtract operator. //342//----------------------------------------------------------------------------//343 344// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_char345void unsigned_char_sub_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {346 // CHECK: {347 // CHECK-NEXT: entry:348 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8349 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1350 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8351 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1352 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1353 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32354 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8355 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1356 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32357 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]358 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8359 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize360 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize361 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize362 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:363 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize364 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize365 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize366 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize367 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize368 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize369 // CHECK-SANITIZE: [[CONT]]:370 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1371 // CHECK-NEXT: ret void372 // CHECK-NEXT: }373#line 900374 (*LHS) -= RHS;375}376 377// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_char378void unsigned_char_sub_signed_char_signed_char(unsigned char *LHS, signed char RHS) {379 // CHECK: {380 // CHECK-NEXT: entry:381 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8382 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1383 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8384 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1385 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1386 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32387 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8388 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1389 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32390 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]391 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8392 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize393 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize394 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize395 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:396 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize397 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize398 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize399 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize400 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize401 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize402 // CHECK-SANITIZE: [[CONT]]:403 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1404 // CHECK-NEXT: ret void405 // CHECK-NEXT: }406#line 1000407 (*LHS) -= RHS;408}409 410// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_int411void unsigned_char_sub_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {412#line 1100413 (*LHS) -= RHS;414}415 416// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_int417void unsigned_char_sub_signed_char_signed_int(unsigned char *LHS, signed int RHS) {418 // CHECK: {419 // CHECK-NEXT: entry:420 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8421 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4422 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8423 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4424 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4425 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8426 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1427 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32428 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]429 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8430 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize431 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize432 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize433 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:434 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize435 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize436 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize437 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize438 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize439 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize440 // CHECK-SANITIZE: [[CONT]]:441 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1442 // CHECK-NEXT: ret void443 // CHECK-NEXT: }444#line 1200445 (*LHS) -= RHS;446}447 448// CHECK-LABEL: @signed_char_sub_unsigned_char449void signed_char_sub_unsigned_char(signed char *LHS, unsigned char RHS) {450 // CHECK: {451 // CHECK-NEXT: entry:452 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8453 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1454 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8455 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1456 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1457 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32458 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8459 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1460 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32461 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]462 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8463 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize464 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize465 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize466 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:467 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize468 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize469 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize470 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize471 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize472 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize473 // CHECK-SANITIZE: [[CONT]]:474 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1475 // CHECK-NEXT: ret void476 // CHECK-NEXT: }477#line 1300478 (*LHS) -= RHS;479}480 481// CHECK-LABEL: @signed_char_sub_signed_char482void signed_char_sub_signed_char(signed char *LHS, signed char RHS) {483 // CHECK: {484 // CHECK-NEXT: entry:485 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8486 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1487 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8488 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1489 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1490 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32491 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8492 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1493 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32494 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]495 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8496 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize497 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize498 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize499 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:500 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize501 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize502 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize503 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize504 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize505 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize506 // CHECK-SANITIZE: [[CONT]]:507 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1508 // CHECK-NEXT: ret void509 // CHECK-NEXT: }510#line 1400511 (*LHS) -= RHS;512}513 514// CHECK-LABEL: @signed_char_sub_signed_char_unsigned_int515void signed_char_sub_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {516 // CHECK: {517 // CHECK-NEXT: entry:518 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8519 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4520 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8521 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4522 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4523 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8524 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1525 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32526 // CHECK-NEXT: %[[SRC:.*]] = sub i32 %[[LHSEXT]], %[[RHS]]527 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8528 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize529 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize530 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize531 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize532 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize533 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize534 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:535 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize536 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize537 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1500_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize538 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1500_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize539 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize540 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize541 // CHECK-SANITIZE: [[CONT]]:542 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1543 // CHECK-NEXT: ret void544 // CHECK-NEXT: }545#line 1500546 (*LHS) -= RHS;547}548 549// CHECK-LABEL: @signed_char_sub_signed_char_signed_int550void signed_char_sub_signed_char_signed_int(signed char *LHS, signed int RHS) {551 // CHECK: {552 // CHECK-NEXT: entry:553 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8554 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4555 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8556 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4557 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4558 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8559 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1560 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32561 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]562 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8563 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize564 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize565 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize566 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:567 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize568 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize569 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize570 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize571 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize572 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize573 // CHECK-SANITIZE: [[CONT]]:574 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1575 // CHECK-NEXT: ret void576 // CHECK-NEXT: }577#line 1600578 (*LHS) -= RHS;579}580 581//----------------------------------------------------------------------------//582// Compound multiply operator. //583//----------------------------------------------------------------------------//584 585// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_char586void unsigned_char_mul_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {587 // CHECK: {588 // CHECK-NEXT: entry:589 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8590 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1591 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8592 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1593 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1594 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32595 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8596 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1597 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32598 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]599 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8600 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize601 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize602 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize603 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:604 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize605 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize606 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize607 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize608 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize609 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize610 // CHECK-SANITIZE: [[CONT]]:611 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1612 // CHECK-NEXT: ret void613 // CHECK-NEXT: }614#line 1700615 (*LHS) *= RHS;616}617 618// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_char619void unsigned_char_mul_signed_char_signed_char(unsigned char *LHS, signed char RHS) {620 // CHECK: {621 // CHECK-NEXT: entry:622 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8623 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1624 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8625 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1626 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1627 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32628 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8629 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1630 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32631 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]632 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8633 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize634 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize635 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize636 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:637 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize638 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize639 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize640 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize641 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize642 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize643 // CHECK-SANITIZE: [[CONT]]:644 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1645 // CHECK-NEXT: ret void646 // CHECK-NEXT: }647#line 1800648 (*LHS) *= RHS;649}650 651// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_int652void unsigned_char_mul_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {653#line 1900654 (*LHS) *= RHS;655}656 657// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_int658void unsigned_char_mul_signed_char_signed_int(unsigned char *LHS, signed int RHS) {659 // CHECK: {660 // CHECK-NEXT: entry:661 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8662 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4663 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8664 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4665 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4666 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8667 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1668 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32669 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]670 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8671 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize672 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize673 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize674 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:675 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize676 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize677 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize678 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize679 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize680 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize681 // CHECK-SANITIZE: [[CONT]]:682 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1683 // CHECK-NEXT: ret void684 // CHECK-NEXT: }685#line 2000686 (*LHS) *= RHS;687}688 689// CHECK-LABEL: @signed_char_mul_unsigned_char690void signed_char_mul_unsigned_char(signed char *LHS, unsigned char RHS) {691 // CHECK: {692 // CHECK-NEXT: entry:693 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8694 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1695 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8696 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1697 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1698 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32699 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8700 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1701 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32702 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]703 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8704 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize705 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize706 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize707 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:708 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize709 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize710 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize711 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize712 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize713 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize714 // CHECK-SANITIZE: [[CONT]]:715 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1716 // CHECK-NEXT: ret void717 // CHECK-NEXT: }718#line 2100719 (*LHS) *= RHS;720}721 722// CHECK-LABEL: @signed_char_mul_signed_char723void signed_char_mul_signed_char(signed char *LHS, signed char RHS) {724 // CHECK: {725 // CHECK-NEXT: entry:726 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8727 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1728 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8729 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1730 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1731 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32732 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8733 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1734 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32735 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]736 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8737 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize738 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize739 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize740 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:741 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize742 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize743 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize744 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize745 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize746 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize747 // CHECK-SANITIZE: [[CONT]]:748 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1749 // CHECK-NEXT: ret void750 // CHECK-NEXT: }751#line 2200752 (*LHS) *= RHS;753}754 755// CHECK-LABEL: @signed_char_mul_signed_char_unsigned_int756void signed_char_mul_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {757 // CHECK: {758 // CHECK-NEXT: entry:759 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8760 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4761 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8762 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4763 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4764 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8765 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1766 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32767 // CHECK-NEXT: %[[SRC:.*]] = mul i32 %[[LHSEXT]], %[[RHS]]768 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8769 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize770 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize771 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize772 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize773 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize774 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize775 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:776 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize777 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize778 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2300_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize779 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2300_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize780 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize781 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize782 // CHECK-SANITIZE: [[CONT]]:783 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1784 // CHECK-NEXT: ret void785 // CHECK-NEXT: }786#line 2300787 (*LHS) *= RHS;788}789 790// CHECK-LABEL: @signed_char_mul_signed_char_signed_int791void signed_char_mul_signed_char_signed_int(signed char *LHS, signed int RHS) {792 // CHECK: {793 // CHECK-NEXT: entry:794 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8795 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4796 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8797 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4798 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4799 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8800 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1801 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32802 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]803 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8804 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize805 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize806 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize807 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:808 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize809 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize810 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize811 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize812 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize813 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize814 // CHECK-SANITIZE: [[CONT]]:815 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1816 // CHECK-NEXT: ret void817 // CHECK-NEXT: }818#line 2400819 (*LHS) *= RHS;820}821 822//----------------------------------------------------------------------------//823// Compound divide operator. //824//----------------------------------------------------------------------------//825 826// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_char827void unsigned_char_div_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {828 // CHECK: {829 // CHECK-NEXT: entry:830 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8831 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1832 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8833 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1834 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1835 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32836 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8837 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1838 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32839 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]840 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8841 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize842 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize843 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize844 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:845 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize846 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize847 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize848 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize849 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize850 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize851 // CHECK-SANITIZE: [[CONT]]:852 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1853 // CHECK-NEXT: ret void854 // CHECK-NEXT: }855#line 2500856 (*LHS) /= RHS;857}858 859// CHECK-LABEL: @unsigned_char_div_signed_char_signed_char860void unsigned_char_div_signed_char_signed_char(unsigned char *LHS, signed char RHS) {861 // CHECK: {862 // CHECK-NEXT: entry:863 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8864 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1865 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8866 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1867 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1868 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32869 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8870 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1871 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32872 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]873 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8874 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize875 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize876 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize877 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:878 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize879 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize880 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize881 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize882 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize883 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize884 // CHECK-SANITIZE: [[CONT]]:885 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1886 // CHECK-NEXT: ret void887 // CHECK-NEXT: }888#line 2600889 (*LHS) /= RHS;890}891 892// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_int893void unsigned_char_div_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {894#line 2700895 (*LHS) /= RHS;896}897 898// CHECK-LABEL: @unsigned_char_div_signed_char_signed_int899void unsigned_char_div_signed_char_signed_int(unsigned char *LHS, signed int RHS) {900 // CHECK: {901 // CHECK-NEXT: entry:902 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8903 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4904 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8905 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4906 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4907 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8908 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1909 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32910 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]911 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8912 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize913 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize914 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize915 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:916 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize917 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize918 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize919 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize920 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize921 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize922 // CHECK-SANITIZE: [[CONT]]:923 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1924 // CHECK-NEXT: ret void925 // CHECK-NEXT: }926#line 2800927 (*LHS) /= RHS;928}929 930// CHECK-LABEL: @signed_char_div_unsigned_char931void signed_char_div_unsigned_char(signed char *LHS, unsigned char RHS) {932 // CHECK: {933 // CHECK-NEXT: entry:934 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8935 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1936 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8937 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1938 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1939 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32940 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8941 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1942 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32943 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]944 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8945 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize946 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize947 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize948 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:949 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize950 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize951 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize952 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize953 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize954 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize955 // CHECK-SANITIZE: [[CONT]]:956 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1957 // CHECK-NEXT: ret void958 // CHECK-NEXT: }959#line 2900960 (*LHS) /= RHS;961}962 963// CHECK-LABEL: @signed_char_div_signed_char964void signed_char_div_signed_char(signed char *LHS, signed char RHS) {965 // CHECK: {966 // CHECK-NEXT: entry:967 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8968 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1969 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8970 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1971 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1972 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32973 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8974 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1975 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32976 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]977 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8978 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize979 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize980 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize981 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:982 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize983 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize984 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize985 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize986 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize987 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize988 // CHECK-SANITIZE: [[CONT]]:989 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1990 // CHECK-NEXT: ret void991 // CHECK-NEXT: }992#line 3000993 (*LHS) /= RHS;994}995 996// CHECK-LABEL: @signed_char_div_signed_char_unsigned_int997void signed_char_div_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {998 // CHECK: {999 // CHECK-NEXT: entry:1000 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81001 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41002 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81003 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41004 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41005 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81006 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11007 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321008 // CHECK-NEXT: %[[SRC:.*]] = udiv i32 %[[LHSEXT]], %[[RHS]]1009 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81010 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1011 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize1012 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1013 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1014 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize1015 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1016 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1017 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1018 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1019 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3100_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1020 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3100_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1021 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1022 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1023 // CHECK-SANITIZE: [[CONT]]:1024 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11025 // CHECK-NEXT: ret void1026 // CHECK-NEXT: }1027#line 31001028 (*LHS) /= RHS;1029}1030 1031// CHECK-LABEL: @signed_char_div_signed_char_signed_int1032void signed_char_div_signed_char_signed_int(signed char *LHS, signed int RHS) {1033 // CHECK: {1034 // CHECK-NEXT: entry:1035 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81036 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41037 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81038 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41039 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41040 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81041 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11042 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321043 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]1044 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81045 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1046 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1047 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1048 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1049 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1050 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1051 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1052 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1053 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1054 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1055 // CHECK-SANITIZE: [[CONT]]:1056 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11057 // CHECK-NEXT: ret void1058 // CHECK-NEXT: }1059#line 32001060 (*LHS) /= RHS;1061}1062 1063//----------------------------------------------------------------------------//1064// Compound remainder operator. //1065//----------------------------------------------------------------------------//1066 1067// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_char1068void unsigned_char_rem_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1069 // CHECK: {1070 // CHECK-NEXT: entry:1071 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81072 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11073 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81074 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11075 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11076 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321077 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81078 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11079 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321080 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1081 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81082 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1083 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1084 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1085 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1086 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1087 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1088 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1089 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1090 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1091 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1092 // CHECK-SANITIZE: [[CONT]]:1093 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11094 // CHECK-NEXT: ret void1095 // CHECK-NEXT: }1096#line 33001097 (*LHS) %= RHS;1098}1099 1100// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_char1101void unsigned_char_rem_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1102 // CHECK: {1103 // CHECK-NEXT: entry:1104 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81105 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11106 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81107 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11108 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11109 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321110 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81111 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11112 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321113 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1114 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81115 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1116 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1117 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1118 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1119 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1120 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1121 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1122 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1123 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1124 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1125 // CHECK-SANITIZE: [[CONT]]:1126 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11127 // CHECK-NEXT: ret void1128 // CHECK-NEXT: }1129#line 34001130 (*LHS) %= RHS;1131}1132 1133// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_int1134void unsigned_char_rem_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1135#line 35001136 (*LHS) %= RHS;1137}1138 1139// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_int1140void unsigned_char_rem_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1141 // CHECK: {1142 // CHECK-NEXT: entry:1143 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81144 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41145 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81146 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41147 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41148 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81149 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11150 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321151 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]1152 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81153 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1154 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1155 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1156 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1157 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1158 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1159 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1160 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1161 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1162 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1163 // CHECK-SANITIZE: [[CONT]]:1164 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11165 // CHECK-NEXT: ret void1166 // CHECK-NEXT: }1167#line 36001168 (*LHS) %= RHS;1169}1170 1171// CHECK-LABEL: @signed_char_rem_unsigned_char1172void signed_char_rem_unsigned_char(signed char *LHS, unsigned char RHS) {1173 // CHECK: {1174 // CHECK-NEXT: entry:1175 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81176 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11177 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81178 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11179 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11180 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321181 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81182 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11183 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321184 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1185 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81186 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1187 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1188 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1189 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1190 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1191 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1192 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1193 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1194 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1195 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1196 // CHECK-SANITIZE: [[CONT]]:1197 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11198 // CHECK-NEXT: ret void1199 // CHECK-NEXT: }1200#line 37001201 (*LHS) %= RHS;1202}1203 1204// CHECK-LABEL: @signed_char_rem_signed_char1205void signed_char_rem_signed_char(signed char *LHS, signed char RHS) {1206 // CHECK: {1207 // CHECK-NEXT: entry:1208 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81209 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11210 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81211 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11212 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11213 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321214 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81215 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11216 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321217 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1218 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81219 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1220 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1221 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1222 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1223 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1224 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1225 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1226 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1227 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1228 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1229 // CHECK-SANITIZE: [[CONT]]:1230 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11231 // CHECK-NEXT: ret void1232 // CHECK-NEXT: }1233#line 38001234 (*LHS) %= RHS;1235}1236 1237// CHECK-LABEL: @signed_char_rem_signed_char_unsigned_int1238void signed_char_rem_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1239 // CHECK: {1240 // CHECK-NEXT: entry:1241 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81242 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41243 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81244 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41245 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41246 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81247 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11248 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321249 // CHECK-NEXT: %[[SRC:.*]] = urem i32 %[[LHSEXT]], %[[RHS]]1250 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81251 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1252 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize1253 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1254 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1255 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize1256 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1257 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1258 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1259 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1260 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3900_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1261 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3900_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1262 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1263 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1264 // CHECK-SANITIZE: [[CONT]]:1265 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11266 // CHECK-NEXT: ret void1267 // CHECK-NEXT: }1268#line 39001269 (*LHS) %= RHS;1270}1271 1272// CHECK-LABEL: @signed_char_rem_signed_char_signed_int1273void signed_char_rem_signed_char_signed_int(signed char *LHS, signed int RHS) {1274 // CHECK: {1275 // CHECK-NEXT: entry:1276 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81277 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41278 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81279 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41280 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41281 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81282 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11283 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321284 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]1285 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81286 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1287 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1288 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1289 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1290 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1291 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1292 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1293 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1294 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1295 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1296 // CHECK-SANITIZE: [[CONT]]:1297 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11298 // CHECK-NEXT: ret void1299 // CHECK-NEXT: }1300#line 40001301 (*LHS) %= RHS;1302}1303 1304//----------------------------------------------------------------------------//1305// Compound left-shift operator. //1306//----------------------------------------------------------------------------//1307 1308// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_char1309void unsigned_char_shl_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1310 // CHECK: {1311 // CHECK-NEXT: entry:1312 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81313 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11314 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81315 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11316 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11317 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321318 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81319 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11320 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321321 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1322 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81323 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1324 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1325 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1326 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1327 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1328 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1329 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1330 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1331 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1332 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1333 // CHECK-SANITIZE: [[CONT]]:1334 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11335 // CHECK-NEXT: ret void1336 // CHECK-NEXT: }1337#line 41001338 (*LHS) <<= RHS;1339}1340 1341// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_char1342void unsigned_char_shl_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1343 // CHECK: {1344 // CHECK-NEXT: entry:1345 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81346 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11347 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81348 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11349 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11350 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321351 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81352 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11353 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321354 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1355 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81356 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1357 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1358 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1359 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1360 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1361 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1362 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1363 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1364 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1365 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1366 // CHECK-SANITIZE: [[CONT]]:1367 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11368 // CHECK-NEXT: ret void1369 // CHECK-NEXT: }1370#line 42001371 (*LHS) <<= RHS;1372}1373 1374// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_int1375void unsigned_char_shl_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1376 // CHECK: {1377 // CHECK-NEXT: entry:1378 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81379 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41380 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81381 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41382 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41383 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81384 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11385 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321386 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1387 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81388 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1389 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1390 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1391 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1392 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1393 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1394 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1395 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1396 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1397 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1398 // CHECK-SANITIZE: [[CONT]]:1399 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11400 // CHECK-NEXT: ret void1401 // CHECK-NEXT: }1402#line 43001403 (*LHS) <<= RHS;1404}1405 1406// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_int1407void unsigned_char_shl_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1408 // CHECK: {1409 // CHECK-NEXT: entry:1410 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81411 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41412 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81413 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41414 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41415 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81416 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11417 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321418 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1419 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81420 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1421 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1422 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1423 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1424 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1425 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1426 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1427 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1428 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1429 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1430 // CHECK-SANITIZE: [[CONT]]:1431 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11432 // CHECK-NEXT: ret void1433 // CHECK-NEXT: }1434#line 44001435 (*LHS) <<= RHS;1436}1437 1438// CHECK-LABEL: @signed_char_shl_unsigned_char1439void signed_char_shl_unsigned_char(signed char *LHS, unsigned char RHS) {1440 // CHECK: {1441 // CHECK-NEXT: entry:1442 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81443 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11444 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81445 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11446 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11447 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321448 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81449 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11450 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321451 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1452 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81453 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1454 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1455 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1456 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1457 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1458 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1459 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1460 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1461 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1462 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1463 // CHECK-SANITIZE: [[CONT]]:1464 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11465 // CHECK-NEXT: ret void1466 // CHECK-NEXT: }1467#line 45001468 (*LHS) <<= RHS;1469}1470 1471// CHECK-LABEL: @signed_char_shl_signed_char1472void signed_char_shl_signed_char(signed char *LHS, signed char RHS) {1473 // CHECK: {1474 // CHECK-NEXT: entry:1475 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81476 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11477 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81478 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11479 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11480 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321481 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81482 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11483 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321484 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1485 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81486 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1487 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1488 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1489 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1490 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1491 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1492 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1493 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1494 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1495 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1496 // CHECK-SANITIZE: [[CONT]]:1497 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11498 // CHECK-NEXT: ret void1499 // CHECK-NEXT: }1500#line 46001501 (*LHS) <<= RHS;1502}1503 1504// CHECK-LABEL: @signed_char_shl_signed_char_unsigned_int1505void signed_char_shl_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1506 // CHECK: {1507 // CHECK-NEXT: entry:1508 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81509 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41510 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81511 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41512 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41513 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81514 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11515 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321516 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1517 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81518 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1519 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1520 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1521 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1522 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1523 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1524 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1525 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1526 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1527 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1528 // CHECK-SANITIZE: [[CONT]]:1529 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11530 // CHECK-NEXT: ret void1531 // CHECK-NEXT: }1532#line 47001533 (*LHS) <<= RHS;1534}1535 1536// CHECK-LABEL: @signed_char_shl_signed_char_signed_int1537void signed_char_shl_signed_char_signed_int(signed char *LHS, signed int RHS) {1538 // CHECK: {1539 // CHECK-NEXT: entry:1540 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81541 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41542 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81543 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41544 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41545 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81546 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11547 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321548 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1549 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81550 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1551 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1552 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1553 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1554 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1555 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1556 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1557 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1558 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1559 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1560 // CHECK-SANITIZE: [[CONT]]:1561 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11562 // CHECK-NEXT: ret void1563 // CHECK-NEXT: }1564#line 48001565 (*LHS) <<= RHS;1566}1567 1568//----------------------------------------------------------------------------//1569// Compound right-shift operator. //1570//----------------------------------------------------------------------------//1571 1572// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_char1573void unsigned_char_shr_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1574 // CHECK: {1575 // CHECK-NEXT: entry:1576 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81577 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11578 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81579 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11580 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11581 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321582 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81583 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11584 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321585 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1586 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81587 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1588 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1589 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1590 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1591 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1592 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1593 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1594 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1595 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1596 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1597 // CHECK-SANITIZE: [[CONT]]:1598 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11599 // CHECK-NEXT: ret void1600 // CHECK-NEXT: }1601#line 49001602 (*LHS) >>= RHS;1603}1604 1605// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_char1606void unsigned_char_shr_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1607 // CHECK: {1608 // CHECK-NEXT: entry:1609 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81610 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11611 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81612 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11613 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11614 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321615 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81616 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11617 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321618 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1619 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81620 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1621 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1622 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1623 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1624 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1625 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1626 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1627 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1628 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1629 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1630 // CHECK-SANITIZE: [[CONT]]:1631 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11632 // CHECK-NEXT: ret void1633 // CHECK-NEXT: }1634#line 50001635 (*LHS) >>= RHS;1636}1637 1638// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_int1639void unsigned_char_shr_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1640 // CHECK: {1641 // CHECK-NEXT: entry:1642 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81643 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41644 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81645 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41646 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41647 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81648 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11649 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321650 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1651 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81652 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1653 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1654 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1655 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1656 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1657 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1658 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1659 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1660 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1661 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1662 // CHECK-SANITIZE: [[CONT]]:1663 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11664 // CHECK-NEXT: ret void1665 // CHECK-NEXT: }1666#line 51001667 (*LHS) >>= RHS;1668}1669 1670// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_int1671void unsigned_char_shr_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1672 // CHECK: {1673 // CHECK-NEXT: entry:1674 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81675 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41676 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81677 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41678 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41679 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81680 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11681 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321682 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1683 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81684 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1685 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1686 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1687 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1688 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1689 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1690 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1691 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1692 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1693 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1694 // CHECK-SANITIZE: [[CONT]]:1695 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11696 // CHECK-NEXT: ret void1697 // CHECK-NEXT: }1698#line 52001699 (*LHS) >>= RHS;1700}1701 1702// CHECK-LABEL: @signed_char_shr_unsigned_char1703void signed_char_shr_unsigned_char(signed char *LHS, unsigned char RHS) {1704 // CHECK: {1705 // CHECK-NEXT: entry:1706 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81707 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11708 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81709 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11710 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11711 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321712 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81713 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11714 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321715 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1716 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81717 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1718 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1719 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1720 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1721 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1722 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1723 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1724 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1725 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1726 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1727 // CHECK-SANITIZE: [[CONT]]:1728 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11729 // CHECK-NEXT: ret void1730 // CHECK-NEXT: }1731#line 53001732 (*LHS) >>= RHS;1733}1734 1735// CHECK-LABEL: @signed_char_shr_signed_char1736void signed_char_shr_signed_char(signed char *LHS, signed char RHS) {1737 // CHECK: {1738 // CHECK-NEXT: entry:1739 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81740 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11741 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81742 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11743 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11744 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321745 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81746 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11747 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321748 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1749 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81750 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1751 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1752 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1753 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1754 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1755 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1756 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1757 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1758 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1759 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1760 // CHECK-SANITIZE: [[CONT]]:1761 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11762 // CHECK-NEXT: ret void1763 // CHECK-NEXT: }1764#line 54001765 (*LHS) >>= RHS;1766}1767 1768// CHECK-LABEL: @signed_char_shr_signed_char_unsigned_int1769void signed_char_shr_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1770 // CHECK: {1771 // CHECK-NEXT: entry:1772 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81773 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41774 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81775 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41776 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41777 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81778 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11779 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321780 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1781 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81782 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1783 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1784 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1785 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1786 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1787 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1788 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1789 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1790 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1791 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1792 // CHECK-SANITIZE: [[CONT]]:1793 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11794 // CHECK-NEXT: ret void1795 // CHECK-NEXT: }1796#line 55001797 (*LHS) >>= RHS;1798}1799 1800// CHECK-LABEL: @signed_char_shr_signed_char_signed_int1801void signed_char_shr_signed_char_signed_int(signed char *LHS, signed int RHS) {1802 // CHECK: {1803 // CHECK-NEXT: entry:1804 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81805 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41806 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81807 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41808 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41809 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81810 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11811 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321812 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1813 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81814 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1815 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1816 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1817 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1818 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1819 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1820 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1821 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1822 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1823 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1824 // CHECK-SANITIZE: [[CONT]]:1825 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11826 // CHECK-NEXT: ret void1827 // CHECK-NEXT: }1828#line 56001829 (*LHS) >>= RHS;1830}1831 1832//----------------------------------------------------------------------------//1833// Compound and operator. //1834//----------------------------------------------------------------------------//1835 1836// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_char1837void unsigned_char_and_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1838 // CHECK: {1839 // CHECK-NEXT: entry:1840 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81841 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11842 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81843 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11844 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11845 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321846 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81847 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11848 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321849 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1850 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81851 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1852 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1853 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1854 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1855 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1856 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1857 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1858 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1859 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1860 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1861 // CHECK-SANITIZE: [[CONT]]:1862 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11863 // CHECK-NEXT: ret void1864 // CHECK-NEXT: }1865#line 57001866 (*LHS) &= RHS;1867}1868 1869// CHECK-LABEL: @unsigned_char_and_signed_char_signed_char1870void unsigned_char_and_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1871 // CHECK: {1872 // CHECK-NEXT: entry:1873 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81874 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11875 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81876 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11877 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11878 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321879 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81880 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11881 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321882 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1883 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81884 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1885 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1886 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1887 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1888 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1889 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1890 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1891 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1892 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1893 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1894 // CHECK-SANITIZE: [[CONT]]:1895 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11896 // CHECK-NEXT: ret void1897 // CHECK-NEXT: }1898#line 58001899 (*LHS) &= RHS;1900}1901 1902// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_int1903void unsigned_char_and_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1904#line 59001905 (*LHS) &= RHS;1906}1907 1908// CHECK-LABEL: @unsigned_char_and_signed_char_signed_int1909void unsigned_char_and_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1910 // CHECK: {1911 // CHECK-NEXT: entry:1912 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81913 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41914 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81915 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41916 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41917 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81918 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11919 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321920 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]1921 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81922 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1923 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1924 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1925 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1926 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1927 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1928 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1929 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1930 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1931 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1932 // CHECK-SANITIZE: [[CONT]]:1933 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11934 // CHECK-NEXT: ret void1935 // CHECK-NEXT: }1936#line 60001937 (*LHS) &= RHS;1938}1939 1940// CHECK-LABEL: @signed_char_and_unsigned_char1941void signed_char_and_unsigned_char(signed char *LHS, unsigned char RHS) {1942 // CHECK: {1943 // CHECK-NEXT: entry:1944 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81945 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11946 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81947 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11948 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11949 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321950 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81951 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11952 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321953 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1954 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81955 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1956 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1957 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1958 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1959 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1960 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1961 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1962 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1963 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1964 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1965 // CHECK-SANITIZE: [[CONT]]:1966 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11967 // CHECK-NEXT: ret void1968 // CHECK-NEXT: }1969#line 61001970 (*LHS) &= RHS;1971}1972 1973// CHECK-LABEL: @signed_char_and_signed_char1974void signed_char_and_signed_char(signed char *LHS, signed char RHS) {1975 // CHECK: {1976 // CHECK-NEXT: entry:1977 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81978 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11979 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81980 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11981 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11982 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321983 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81984 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11985 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321986 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1987 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81988 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1989 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1990 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1991 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1992 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1993 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1994 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1995 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1996 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1997 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1998 // CHECK-SANITIZE: [[CONT]]:1999 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12000 // CHECK-NEXT: ret void2001 // CHECK-NEXT: }2002#line 62002003 (*LHS) &= RHS;2004}2005 2006// CHECK-LABEL: @signed_char_and_signed_char_unsigned_int2007void signed_char_and_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2008 // CHECK: {2009 // CHECK-NEXT: entry:2010 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82011 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42012 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82013 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42014 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42015 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82016 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12017 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322018 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2019 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82020 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2021 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize2022 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2023 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2024 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize2025 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2026 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2027 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2028 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2029 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6300_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2030 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6300_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2031 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2032 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2033 // CHECK-SANITIZE: [[CONT]]:2034 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12035 // CHECK-NEXT: ret void2036 // CHECK-NEXT: }2037#line 63002038 (*LHS) &= RHS;2039}2040 2041// CHECK-LABEL: @signed_char_and_signed_char_signed_int2042void signed_char_and_signed_char_signed_int(signed char *LHS, signed int RHS) {2043 // CHECK: {2044 // CHECK-NEXT: entry:2045 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82046 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42047 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82048 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42049 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42050 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82051 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12052 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322053 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2054 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82055 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2056 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2057 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2058 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2059 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2060 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2061 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2062 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2063 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2064 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2065 // CHECK-SANITIZE: [[CONT]]:2066 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12067 // CHECK-NEXT: ret void2068 // CHECK-NEXT: }2069#line 64002070 (*LHS) &= RHS;2071}2072 2073//----------------------------------------------------------------------------//2074// Compound xor operator. //2075//----------------------------------------------------------------------------//2076 2077// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_char2078void unsigned_char_or_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {2079 // CHECK: {2080 // CHECK-NEXT: entry:2081 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82082 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12083 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82084 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12085 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12086 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322087 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82088 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12089 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322090 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2091 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82092 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2093 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2094 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2095 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2096 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2097 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2098 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2099 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2100 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2101 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2102 // CHECK-SANITIZE: [[CONT]]:2103 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12104 // CHECK-NEXT: ret void2105 // CHECK-NEXT: }2106#line 65002107 (*LHS) |= RHS;2108}2109 2110// CHECK-LABEL: @unsigned_char_or_signed_char_signed_char2111void unsigned_char_or_signed_char_signed_char(unsigned char *LHS, signed char RHS) {2112 // CHECK: {2113 // CHECK-NEXT: entry:2114 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82115 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12116 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82117 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12118 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12119 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322120 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82121 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12122 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322123 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2124 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82125 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2126 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2127 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2128 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2129 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2130 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2131 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2132 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2133 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2134 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2135 // CHECK-SANITIZE: [[CONT]]:2136 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12137 // CHECK-NEXT: ret void2138 // CHECK-NEXT: }2139#line 66002140 (*LHS) |= RHS;2141}2142 2143// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_int2144void unsigned_char_or_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {2145#line 67002146 (*LHS) |= RHS;2147}2148 2149// CHECK-LABEL: @unsigned_char_or_signed_char_signed_int2150void unsigned_char_or_signed_char_signed_int(unsigned char *LHS, signed int RHS) {2151 // CHECK: {2152 // CHECK-NEXT: entry:2153 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82154 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42155 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82156 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42157 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42158 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82159 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12160 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322161 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2162 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82163 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2164 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2165 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2166 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2167 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2168 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2169 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2170 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2171 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2172 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2173 // CHECK-SANITIZE: [[CONT]]:2174 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12175 // CHECK-NEXT: ret void2176 // CHECK-NEXT: }2177#line 68002178 (*LHS) |= RHS;2179}2180 2181// CHECK-LABEL: @signed_char_or_unsigned_char2182void signed_char_or_unsigned_char(signed char *LHS, unsigned char RHS) {2183 // CHECK: {2184 // CHECK-NEXT: entry:2185 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82186 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12187 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82188 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12189 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12190 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322191 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82192 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12193 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322194 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2195 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82196 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2197 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2198 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2199 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2200 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2201 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2202 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2203 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2204 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2205 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2206 // CHECK-SANITIZE: [[CONT]]:2207 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12208 // CHECK-NEXT: ret void2209 // CHECK-NEXT: }2210#line 69002211 (*LHS) |= RHS;2212}2213 2214// CHECK-LABEL: @signed_char_or_signed_char2215void signed_char_or_signed_char(signed char *LHS, signed char RHS) {2216 // CHECK: {2217 // CHECK-NEXT: entry:2218 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82219 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12220 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82221 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12222 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12223 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322224 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82225 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12226 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322227 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2228 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82229 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2230 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2231 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2232 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2233 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2234 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2235 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2236 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2237 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2238 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2239 // CHECK-SANITIZE: [[CONT]]:2240 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12241 // CHECK-NEXT: ret void2242 // CHECK-NEXT: }2243#line 70002244 (*LHS) |= RHS;2245}2246 2247// CHECK-LABEL: @signed_char_or_signed_char_unsigned_int2248void signed_char_or_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2249 // CHECK: {2250 // CHECK-NEXT: entry:2251 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82252 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42253 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82254 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42255 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42256 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82257 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12258 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322259 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2260 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82261 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2262 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize2263 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2264 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2265 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize2266 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2267 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2268 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2269 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2270 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7100_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2271 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7100_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2272 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2273 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2274 // CHECK-SANITIZE: [[CONT]]:2275 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12276 // CHECK-NEXT: ret void2277 // CHECK-NEXT: }2278#line 71002279 (*LHS) |= RHS;2280}2281 2282// CHECK-LABEL: @signed_char_or_signed_char_signed_int2283void signed_char_or_signed_char_signed_int(signed char *LHS, signed int RHS) {2284 // CHECK: {2285 // CHECK-NEXT: entry:2286 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82287 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42288 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82289 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42290 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42291 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82292 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12293 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322294 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2295 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82296 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2297 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2298 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2299 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2300 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2301 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2302 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2303 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2304 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2305 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2306 // CHECK-SANITIZE: [[CONT]]:2307 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12308 // CHECK-NEXT: ret void2309 // CHECK-NEXT: }2310#line 72002311 (*LHS) |= RHS;2312}2313 2314//----------------------------------------------------------------------------//2315// Compound or operator. //2316//----------------------------------------------------------------------------//2317 2318// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_char2319void unsigned_char_xor_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {2320 // CHECK: {2321 // CHECK-NEXT: entry:2322 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82323 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12324 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82325 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12326 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12327 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322328 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82329 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12330 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322331 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2332 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82333 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2334 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2335 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2336 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2337 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2338 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2339 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2340 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2341 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2342 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2343 // CHECK-SANITIZE: [[CONT]]:2344 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12345 // CHECK-NEXT: ret void2346 // CHECK-NEXT: }2347#line 73002348 (*LHS) ^= RHS;2349}2350 2351// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_char2352void unsigned_char_xor_signed_char_signed_char(unsigned char *LHS, signed char RHS) {2353 // CHECK: {2354 // CHECK-NEXT: entry:2355 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82356 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12357 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82358 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12359 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12360 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322361 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82362 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12363 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322364 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2365 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82366 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2367 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2368 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2369 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2370 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2371 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2372 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2373 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2374 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2375 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2376 // CHECK-SANITIZE: [[CONT]]:2377 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12378 // CHECK-NEXT: ret void2379 // CHECK-NEXT: }2380#line 74002381 (*LHS) ^= RHS;2382}2383 2384// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_int2385void unsigned_char_xor_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {2386#line 75002387 (*LHS) ^= RHS;2388}2389 2390// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_int2391void unsigned_char_xor_signed_char_signed_int(unsigned char *LHS, signed int RHS) {2392 // CHECK: {2393 // CHECK-NEXT: entry:2394 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82395 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42396 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82397 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42398 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42399 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82400 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12401 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322402 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2403 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82404 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2405 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2406 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2407 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2408 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2409 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2410 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2411 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2412 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2413 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2414 // CHECK-SANITIZE: [[CONT]]:2415 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12416 // CHECK-NEXT: ret void2417 // CHECK-NEXT: }2418#line 76002419 (*LHS) ^= RHS;2420}2421 2422// CHECK-LABEL: @signed_char_xor_unsigned_char2423void signed_char_xor_unsigned_char(signed char *LHS, unsigned char RHS) {2424 // CHECK: {2425 // CHECK-NEXT: entry:2426 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82427 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12428 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82429 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12430 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12431 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322432 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82433 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12434 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322435 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2436 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82437 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2438 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2439 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2440 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2441 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2442 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2443 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2444 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2445 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2446 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2447 // CHECK-SANITIZE: [[CONT]]:2448 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12449 // CHECK-NEXT: ret void2450 // CHECK-NEXT: }2451#line 77002452 (*LHS) ^= RHS;2453}2454 2455// CHECK-LABEL: @signed_char_xor_signed_char2456void signed_char_xor_signed_char(signed char *LHS, signed char RHS) {2457 // CHECK: {2458 // CHECK-NEXT: entry:2459 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82460 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12461 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82462 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12463 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12464 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322465 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82466 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12467 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322468 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2469 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82470 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2471 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2472 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2473 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2474 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2475 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2476 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2477 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2478 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2479 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2480 // CHECK-SANITIZE: [[CONT]]:2481 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12482 // CHECK-NEXT: ret void2483 // CHECK-NEXT: }2484#line 78002485 (*LHS) ^= RHS;2486}2487 2488// CHECK-LABEL: @signed_char_xor_signed_char_unsigned_int2489void signed_char_xor_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2490 // CHECK: {2491 // CHECK-NEXT: entry:2492 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82493 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42494 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82495 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42496 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42497 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82498 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12499 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322500 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2501 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82502 // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2503 // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize2504 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2505 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2506 // CHECK-SANITIZE-NEXT: %[[BOTHCHECKS:.*]] = and i1 %[[SIGNCHANGECHECK]], %[[TRUNCHECK]], !nosanitize2507 // CHECK-SANITIZE-NEXT: br i1 %[[BOTHCHECKS]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2508 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2509 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2510 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2511 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7900_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2512 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7900_SIGNED_TRUNCATION_OR_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2513 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2514 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2515 // CHECK-SANITIZE: [[CONT]]:2516 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12517 // CHECK-NEXT: ret void2518 // CHECK-NEXT: }2519#line 79002520 (*LHS) ^= RHS;2521}2522 2523// CHECK-LABEL: @signed_char_xor_signed_char_signed_int2524void signed_char_xor_signed_char_signed_int(signed char *LHS, signed int RHS) {2525 // CHECK: {2526 // CHECK-NEXT: entry:2527 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82528 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42529 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82530 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42531 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42532 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82533 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12534 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322535 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2536 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82537 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2538 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2539 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2540 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2541 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2542 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2543 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_8000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2544 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_8000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2545 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2546 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2547 // CHECK-SANITIZE: [[CONT]]:2548 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12549 // CHECK-NEXT: ret void2550 // CHECK-NEXT: }2551#line 80002552 (*LHS) ^= RHS;2553}2554