2746 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-unsigned-integer-truncation,implicit-signed-integer-truncation -fno-sanitize-recover=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE4// RUN: %clang_cc1 -fsanitize=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -fsanitize-recover=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER5// RUN: %clang_cc1 -fsanitize=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -fsanitize-trap=implicit-unsigned-integer-truncation,implicit-signed-integer-truncation -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-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: @[[UNSIGNED_INT:.*]] = {{.*}} c"'unsigned int'\00" }18// CHECK-SANITIZE-ANYRECOVER: @[[LINE_300_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 300, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }19// CHECK-SANITIZE-ANYRECOVER: @[[LINE_400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }20// CHECK-SANITIZE-ANYRECOVER: @[[SIGNED_CHAR:.*]] = {{.*}} c"'signed char'\00" }21// CHECK-SANITIZE-ANYRECOVER: @[[LINE_500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }22// CHECK-SANITIZE-ANYRECOVER: @[[LINE_600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }23// CHECK-SANITIZE-ANYRECOVER: @[[LINE_700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 700, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }24// CHECK-SANITIZE-ANYRECOVER: @[[LINE_800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }25 26// CHECK-SANITIZE-ANYRECOVER: @[[LINE_900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 900, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }27// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }28// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1100_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 1100, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }29// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }30// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1300, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }31// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }32// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1500, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }33// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }34 35// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1700, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }36// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 1800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }37// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1900_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 1900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }38// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }39// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2100, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }40// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }41// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2300, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }42// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }43 44// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2500, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }45// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }46// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2700_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 2700, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }47// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }48// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 2900, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }49// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }50// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3100, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }51// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }52 53// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }54// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }55// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3500_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 3500, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }56// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }57// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }58// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }59// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 3900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }60// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }61 62// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }63// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }64// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }65// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }66// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }67// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }68// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }69// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }70 71// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 4900, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }72// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }73// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }74// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }75// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5300, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }76// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }77// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }78// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }79 80// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5700, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }81// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 5800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }82// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5900_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 5900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }83// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }84// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6100, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }85// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }86// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6300, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }87// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }88 89// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6500_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6500, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }90// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }91// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6700_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 6700, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }92// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }93// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 6900, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }94// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }95// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7100_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7100, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }96// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7200_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }97 98// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7300_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }99// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7400_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }100// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7500_UNSIGNED_TRUNCATION:.*]] = {{.*}}, i32 7500, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[UNSIGNED_CHAR]], i8 1, i32 0 }101// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7600_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 2, i32 0 }102// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7700_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }103// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7800_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }104// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7900_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 7900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }105// CHECK-SANITIZE-ANYRECOVER: @[[LINE_8000_SIGNED_TRUNCATION:.*]] = {{.*}}, i32 8000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 2, i32 0 }106 107//----------------------------------------------------------------------------//108// Compound add operator. //109//----------------------------------------------------------------------------//110 111// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_char112void unsigned_char_add_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {113 // CHECK: {114 // CHECK-NEXT: entry:115 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8116 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1117 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8118 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1119 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1120 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32121 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8122 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1123 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32124 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]125 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8126 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize127 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize128 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize129 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:130 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize131 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize132 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize133 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize134 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize135 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize136 // CHECK-SANITIZE: [[CONT]]:137 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1138 // CHECK-NEXT: ret void139 // CHECK-NEXT: }140#line 100141 (*LHS) += RHS;142}143 144// CHECK-LABEL: @unsigned_char_add_signed_char_signed_char145void unsigned_char_add_signed_char_signed_char(unsigned char *LHS, signed char RHS) {146 // CHECK: {147 // CHECK-NEXT: entry:148 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8149 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1150 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8151 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1152 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1153 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32154 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8155 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1156 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32157 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]158 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8159 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize160 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize161 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize162 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:163 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize164 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize165 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize166 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize167 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize168 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize169 // CHECK-SANITIZE: [[CONT]]:170 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1171 // CHECK-NEXT: ret void172 // CHECK-NEXT: }173#line 200174 (*LHS) += RHS;175}176 177// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_int178void unsigned_char_add_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {179 // CHECK: {180 // CHECK-NEXT: entry:181 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8182 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4183 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8184 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4185 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4186 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8187 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1188 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32189 // CHECK-NEXT: %[[SRC:.*]] = add i32 %[[LHSEXT]], %[[RHS]]190 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8191 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize192 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize193 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize194 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:195 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize196 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize197 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_300_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize198 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_300_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize199 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize200 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize201 // CHECK-SANITIZE: [[CONT]]:202 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1203 // CHECK-NEXT: ret void204 // CHECK-NEXT: }205#line 300206 (*LHS) += RHS;207}208 209// CHECK-LABEL: @unsigned_char_add_signed_char_signed_int210void unsigned_char_add_signed_char_signed_int(unsigned char *LHS, signed int RHS) {211 // CHECK: {212 // CHECK-NEXT: entry:213 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8214 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4215 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8216 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4217 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4218 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8219 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1220 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32221 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHS]]222 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8223 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize224 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize225 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize226 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:227 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize228 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize229 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize230 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize231 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize232 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize233 // CHECK-SANITIZE: [[CONT]]:234 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1235 // CHECK-NEXT: ret void236 // CHECK-NEXT: }237#line 400238 (*LHS) += RHS;239}240 241// CHECK-LABEL: @signed_char_add_unsigned_char242void signed_char_add_unsigned_char(signed char *LHS, unsigned char RHS) {243 // CHECK: {244 // CHECK-NEXT: entry:245 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8246 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1247 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8248 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1249 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1250 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32251 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8252 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1253 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32254 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]255 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8256 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize257 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize258 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize259 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:260 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize261 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize262 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize263 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize264 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize265 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize266 // CHECK-SANITIZE: [[CONT]]:267 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1268 // CHECK-NEXT: ret void269 // CHECK-NEXT: }270#line 500271 (*LHS) += RHS;272}273 274// CHECK-LABEL: @signed_char_add_signed_char275void signed_char_add_signed_char(signed char *LHS, signed char RHS) {276 // CHECK: {277 // CHECK-NEXT: entry:278 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8279 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1280 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8281 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1282 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1283 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32284 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8285 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1286 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32287 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]288 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8289 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize290 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize291 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize292 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:293 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize294 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize295 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize296 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize297 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize298 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize299 // CHECK-SANITIZE: [[CONT]]:300 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1301 // CHECK-NEXT: ret void302 // CHECK-NEXT: }303#line 600304 (*LHS) += RHS;305}306 307// CHECK-LABEL: @signed_char_add_signed_char_unsigned_int308void signed_char_add_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {309 // CHECK: {310 // CHECK-NEXT: entry:311 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8312 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4313 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8314 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4315 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4316 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8317 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1318 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32319 // CHECK-NEXT: %[[SRC:.*]] = add i32 %[[LHSEXT]], %[[RHS]]320 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8321 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize322 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize323 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize324 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:325 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize326 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize327 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize328 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize329 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize330 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize331 // CHECK-SANITIZE: [[CONT]]:332 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1333 // CHECK-NEXT: ret void334 // CHECK-NEXT: }335#line 700336 (*LHS) += RHS;337}338 339// CHECK-LABEL: @signed_char_add_signed_char_signed_int340void signed_char_add_signed_char_signed_int(signed char *LHS, signed int RHS) {341 // CHECK: {342 // CHECK-NEXT: entry:343 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8344 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4345 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8346 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4347 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4348 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8349 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1350 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32351 // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHS]]352 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8353 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize354 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize355 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize356 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:357 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize358 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize359 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize360 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize361 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize362 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize363 // CHECK-SANITIZE: [[CONT]]:364 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1365 // CHECK-NEXT: ret void366 // CHECK-NEXT: }367#line 800368 (*LHS) += RHS;369}370 371//----------------------------------------------------------------------------//372// Compound subtract operator. //373//----------------------------------------------------------------------------//374 375// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_char376void unsigned_char_sub_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {377 // CHECK: {378 // CHECK-NEXT: entry:379 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8380 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1381 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8382 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1383 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1384 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32385 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8386 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1387 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32388 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]389 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8390 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize391 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize392 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize393 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:394 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize395 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize396 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize397 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize398 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize399 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize400 // CHECK-SANITIZE: [[CONT]]:401 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1402 // CHECK-NEXT: ret void403 // CHECK-NEXT: }404#line 900405 (*LHS) -= RHS;406}407 408// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_char409void unsigned_char_sub_signed_char_signed_char(unsigned char *LHS, signed char RHS) {410 // CHECK: {411 // CHECK-NEXT: entry:412 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8413 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1414 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8415 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1416 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1417 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32418 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8419 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1420 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32421 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]422 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8423 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize424 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize425 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize426 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:427 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize428 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize429 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize430 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize431 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize432 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize433 // CHECK-SANITIZE: [[CONT]]:434 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1435 // CHECK-NEXT: ret void436 // CHECK-NEXT: }437#line 1000438 (*LHS) -= RHS;439}440 441// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_int442void unsigned_char_sub_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {443 // CHECK: {444 // CHECK-NEXT: entry:445 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8446 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4447 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8448 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4449 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4450 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8451 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1452 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32453 // CHECK-NEXT: %[[SRC:.*]] = sub i32 %[[LHSEXT]], %[[RHS]]454 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8455 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize456 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize457 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize458 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:459 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize460 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize461 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1100_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize462 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1100_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize463 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize464 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize465 // CHECK-SANITIZE: [[CONT]]:466 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1467 // CHECK-NEXT: ret void468 // CHECK-NEXT: }469#line 1100470 (*LHS) -= RHS;471}472 473// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_int474void unsigned_char_sub_signed_char_signed_int(unsigned char *LHS, signed int RHS) {475 // CHECK: {476 // CHECK-NEXT: entry:477 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8478 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4479 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8480 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4481 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4482 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8483 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1484 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32485 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]486 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8487 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize488 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize489 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize490 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:491 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize492 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize493 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize494 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize495 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize496 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize497 // CHECK-SANITIZE: [[CONT]]:498 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1499 // CHECK-NEXT: ret void500 // CHECK-NEXT: }501#line 1200502 (*LHS) -= RHS;503}504 505// CHECK-LABEL: @signed_char_sub_unsigned_char506void signed_char_sub_unsigned_char(signed char *LHS, unsigned char RHS) {507 // CHECK: {508 // CHECK-NEXT: entry:509 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8510 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1511 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8512 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1513 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1514 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32515 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8516 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1517 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32518 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]519 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8520 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize521 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize522 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize523 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:524 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize525 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize526 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize527 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize528 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize529 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize530 // CHECK-SANITIZE: [[CONT]]:531 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1532 // CHECK-NEXT: ret void533 // CHECK-NEXT: }534#line 1300535 (*LHS) -= RHS;536}537 538// CHECK-LABEL: @signed_char_sub_signed_char539void signed_char_sub_signed_char(signed char *LHS, signed char RHS) {540 // CHECK: {541 // CHECK-NEXT: entry:542 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8543 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1544 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8545 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1546 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1547 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32548 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8549 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1550 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32551 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]552 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8553 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize554 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize555 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize556 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:557 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize558 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize559 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize560 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize561 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize562 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize563 // CHECK-SANITIZE: [[CONT]]:564 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1565 // CHECK-NEXT: ret void566 // CHECK-NEXT: }567#line 1400568 (*LHS) -= RHS;569}570 571// CHECK-LABEL: @signed_char_sub_signed_char_unsigned_int572void signed_char_sub_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {573 // CHECK: {574 // CHECK-NEXT: entry:575 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8576 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4577 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8578 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4579 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4580 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8581 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1582 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32583 // CHECK-NEXT: %[[SRC:.*]] = sub i32 %[[LHSEXT]], %[[RHS]]584 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8585 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize586 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize587 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize588 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:589 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize590 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize591 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize592 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize593 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize594 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize595 // CHECK-SANITIZE: [[CONT]]:596 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1597 // CHECK-NEXT: ret void598 // CHECK-NEXT: }599#line 1500600 (*LHS) -= RHS;601}602 603// CHECK-LABEL: @signed_char_sub_signed_char_signed_int604void signed_char_sub_signed_char_signed_int(signed char *LHS, signed int RHS) {605 // CHECK: {606 // CHECK-NEXT: entry:607 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8608 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4609 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8610 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4611 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4612 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8613 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1614 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32615 // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]616 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8617 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize618 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize619 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize620 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:621 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize622 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize623 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize624 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize625 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize626 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize627 // CHECK-SANITIZE: [[CONT]]:628 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1629 // CHECK-NEXT: ret void630 // CHECK-NEXT: }631#line 1600632 (*LHS) -= RHS;633}634 635//----------------------------------------------------------------------------//636// Compound multiply operator. //637//----------------------------------------------------------------------------//638 639// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_char640void unsigned_char_mul_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {641 // CHECK: {642 // CHECK-NEXT: entry:643 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8644 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1645 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8646 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1647 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1648 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32649 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8650 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1651 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32652 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]653 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8654 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize655 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize656 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize657 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:658 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize659 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize660 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize661 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize662 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize663 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize664 // CHECK-SANITIZE: [[CONT]]:665 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1666 // CHECK-NEXT: ret void667 // CHECK-NEXT: }668#line 1700669 (*LHS) *= RHS;670}671 672// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_char673void unsigned_char_mul_signed_char_signed_char(unsigned char *LHS, signed char RHS) {674 // CHECK: {675 // CHECK-NEXT: entry:676 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8677 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1678 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8679 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1680 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1681 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32682 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8683 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1684 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32685 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]686 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8687 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize688 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize689 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize690 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:691 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize692 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize693 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize694 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize695 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize696 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize697 // CHECK-SANITIZE: [[CONT]]:698 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1699 // CHECK-NEXT: ret void700 // CHECK-NEXT: }701#line 1800702 (*LHS) *= RHS;703}704 705// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_int706void unsigned_char_mul_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {707 // CHECK: {708 // CHECK-NEXT: entry:709 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8710 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4711 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8712 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4713 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4714 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8715 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1716 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32717 // CHECK-NEXT: %[[SRC:.*]] = mul i32 %[[LHSEXT]], %[[RHS]]718 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8719 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize720 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize721 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize722 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:723 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize724 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize725 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1900_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize726 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1900_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize727 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize728 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize729 // CHECK-SANITIZE: [[CONT]]:730 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1731 // CHECK-NEXT: ret void732 // CHECK-NEXT: }733#line 1900734 (*LHS) *= RHS;735}736 737// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_int738void unsigned_char_mul_signed_char_signed_int(unsigned char *LHS, signed int RHS) {739 // CHECK: {740 // CHECK-NEXT: entry:741 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8742 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4743 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8744 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4745 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4746 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8747 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1748 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32749 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]750 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8751 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize752 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize753 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize754 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:755 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize756 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize757 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize758 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize759 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize760 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize761 // CHECK-SANITIZE: [[CONT]]:762 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1763 // CHECK-NEXT: ret void764 // CHECK-NEXT: }765#line 2000766 (*LHS) *= RHS;767}768 769// CHECK-LABEL: @signed_char_mul_unsigned_char770void signed_char_mul_unsigned_char(signed char *LHS, unsigned char RHS) {771 // CHECK: {772 // CHECK-NEXT: entry:773 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8774 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1775 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8776 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1777 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1778 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32779 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8780 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1781 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32782 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]783 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8784 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize785 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize786 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize787 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:788 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize789 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize790 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize791 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize792 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize793 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize794 // CHECK-SANITIZE: [[CONT]]:795 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1796 // CHECK-NEXT: ret void797 // CHECK-NEXT: }798#line 2100799 (*LHS) *= RHS;800}801 802// CHECK-LABEL: @signed_char_mul_signed_char803void signed_char_mul_signed_char(signed char *LHS, signed char RHS) {804 // CHECK: {805 // CHECK-NEXT: entry:806 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8807 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1808 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8809 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1810 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1811 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32812 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8813 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1814 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32815 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]816 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8817 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize818 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize819 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize820 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:821 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize822 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize823 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize824 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize825 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize826 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize827 // CHECK-SANITIZE: [[CONT]]:828 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1829 // CHECK-NEXT: ret void830 // CHECK-NEXT: }831#line 2200832 (*LHS) *= RHS;833}834 835// CHECK-LABEL: @signed_char_mul_signed_char_unsigned_int836void signed_char_mul_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {837 // CHECK: {838 // CHECK-NEXT: entry:839 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8840 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4841 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8842 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4843 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4844 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8845 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1846 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32847 // CHECK-NEXT: %[[SRC:.*]] = mul i32 %[[LHSEXT]], %[[RHS]]848 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8849 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize850 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize851 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize852 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:853 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize854 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize855 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize856 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize857 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize858 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize859 // CHECK-SANITIZE: [[CONT]]:860 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1861 // CHECK-NEXT: ret void862 // CHECK-NEXT: }863#line 2300864 (*LHS) *= RHS;865}866 867// CHECK-LABEL: @signed_char_mul_signed_char_signed_int868void signed_char_mul_signed_char_signed_int(signed char *LHS, signed int RHS) {869 // CHECK: {870 // CHECK-NEXT: entry:871 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8872 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4873 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8874 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4875 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4876 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8877 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1878 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32879 // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]880 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8881 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize882 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize883 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize884 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:885 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize886 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize887 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize888 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize889 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize890 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize891 // CHECK-SANITIZE: [[CONT]]:892 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1893 // CHECK-NEXT: ret void894 // CHECK-NEXT: }895#line 2400896 (*LHS) *= RHS;897}898 899//----------------------------------------------------------------------------//900// Compound divide operator. //901//----------------------------------------------------------------------------//902 903// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_char904void unsigned_char_div_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {905 // CHECK: {906 // CHECK-NEXT: entry:907 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8908 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1909 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8910 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1911 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1912 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32913 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8914 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1915 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32916 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]917 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8918 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize919 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize920 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize921 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:922 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize923 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize924 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize925 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize926 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize927 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize928 // CHECK-SANITIZE: [[CONT]]:929 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1930 // CHECK-NEXT: ret void931 // CHECK-NEXT: }932#line 2500933 (*LHS) /= RHS;934}935 936// CHECK-LABEL: @unsigned_char_div_signed_char_signed_char937void unsigned_char_div_signed_char_signed_char(unsigned char *LHS, signed char RHS) {938 // CHECK: {939 // CHECK-NEXT: entry:940 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8941 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1942 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8943 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1944 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1945 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32946 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8947 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1948 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32949 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]950 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8951 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize952 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize953 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize954 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:955 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize956 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize957 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize958 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize959 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize960 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize961 // CHECK-SANITIZE: [[CONT]]:962 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1963 // CHECK-NEXT: ret void964 // CHECK-NEXT: }965#line 2600966 (*LHS) /= RHS;967}968 969// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_int970void unsigned_char_div_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {971 // CHECK: {972 // CHECK-NEXT: entry:973 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8974 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4975 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8976 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4977 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4978 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8979 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1980 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32981 // CHECK-NEXT: %[[SRC:.*]] = udiv i32 %[[LHSEXT]], %[[RHS]]982 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8983 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize984 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize985 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize986 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:987 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize988 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize989 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2700_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize990 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2700_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize991 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize992 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize993 // CHECK-SANITIZE: [[CONT]]:994 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1995 // CHECK-NEXT: ret void996 // CHECK-NEXT: }997#line 2700998 (*LHS) /= RHS;999}1000 1001// CHECK-LABEL: @unsigned_char_div_signed_char_signed_int1002void unsigned_char_div_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1003 // CHECK: {1004 // CHECK-NEXT: entry:1005 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81006 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41007 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81008 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41009 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41010 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81011 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11012 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321013 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]1014 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81015 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1016 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1017 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1018 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1019 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1020 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1021 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1022 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1023 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1024 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1025 // CHECK-SANITIZE: [[CONT]]:1026 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11027 // CHECK-NEXT: ret void1028 // CHECK-NEXT: }1029#line 28001030 (*LHS) /= RHS;1031}1032 1033// CHECK-LABEL: @signed_char_div_unsigned_char1034void signed_char_div_unsigned_char(signed char *LHS, unsigned char RHS) {1035 // CHECK: {1036 // CHECK-NEXT: entry:1037 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81038 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11039 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81040 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11041 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11042 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321043 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81044 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11045 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321046 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]1047 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81048 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1049 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1050 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1051 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1052 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1053 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1054 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1055 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1056 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1057 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1058 // CHECK-SANITIZE: [[CONT]]:1059 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11060 // CHECK-NEXT: ret void1061 // CHECK-NEXT: }1062#line 29001063 (*LHS) /= RHS;1064}1065 1066// CHECK-LABEL: @signed_char_div_signed_char1067void signed_char_div_signed_char(signed char *LHS, signed char RHS) {1068 // CHECK: {1069 // CHECK-NEXT: entry:1070 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81071 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11072 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81073 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11074 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11075 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321076 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81077 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11078 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321079 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]1080 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81081 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1082 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1083 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1084 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1085 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1086 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1087 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1088 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1089 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1090 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1091 // CHECK-SANITIZE: [[CONT]]:1092 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11093 // CHECK-NEXT: ret void1094 // CHECK-NEXT: }1095#line 30001096 (*LHS) /= RHS;1097}1098 1099// CHECK-LABEL: @signed_char_div_signed_char_unsigned_int1100void signed_char_div_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1101 // CHECK: {1102 // CHECK-NEXT: entry:1103 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81104 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41105 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81106 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41107 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41108 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81109 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11110 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321111 // CHECK-NEXT: %[[SRC:.*]] = udiv i32 %[[LHSEXT]], %[[RHS]]1112 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81113 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1114 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1115 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1116 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1117 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1118 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1119 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1120 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1121 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1122 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1123 // CHECK-SANITIZE: [[CONT]]:1124 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11125 // CHECK-NEXT: ret void1126 // CHECK-NEXT: }1127#line 31001128 (*LHS) /= RHS;1129}1130 1131// CHECK-LABEL: @signed_char_div_signed_char_signed_int1132void signed_char_div_signed_char_signed_int(signed char *LHS, signed int RHS) {1133 // CHECK: {1134 // CHECK-NEXT: entry:1135 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81136 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41137 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81138 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41139 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41140 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81141 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11142 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321143 // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]1144 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81145 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1146 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1147 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1148 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1149 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1150 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1151 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1152 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1153 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1154 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1155 // CHECK-SANITIZE: [[CONT]]:1156 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11157 // CHECK-NEXT: ret void1158 // CHECK-NEXT: }1159#line 32001160 (*LHS) /= RHS;1161}1162 1163//----------------------------------------------------------------------------//1164// Compound remainder operator. //1165//----------------------------------------------------------------------------//1166 1167// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_char1168void unsigned_char_rem_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1169 // CHECK: {1170 // CHECK-NEXT: entry:1171 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81172 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11173 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81174 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11175 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11176 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321177 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81178 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11179 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321180 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1181 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81182 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1183 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1184 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1185 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1186 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1187 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1188 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1189 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1190 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1191 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1192 // CHECK-SANITIZE: [[CONT]]:1193 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11194 // CHECK-NEXT: ret void1195 // CHECK-NEXT: }1196#line 33001197 (*LHS) %= RHS;1198}1199 1200// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_char1201void unsigned_char_rem_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1202 // CHECK: {1203 // CHECK-NEXT: entry:1204 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81205 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11206 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81207 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11208 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11209 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321210 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81211 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11212 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321213 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1214 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81215 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1216 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1217 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1218 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1219 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1220 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1221 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1222 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1223 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1224 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1225 // CHECK-SANITIZE: [[CONT]]:1226 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11227 // CHECK-NEXT: ret void1228 // CHECK-NEXT: }1229#line 34001230 (*LHS) %= RHS;1231}1232 1233// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_int1234void unsigned_char_rem_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1235 // CHECK: {1236 // CHECK-NEXT: entry:1237 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81238 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41239 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81240 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41241 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41242 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81243 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11244 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321245 // CHECK-NEXT: %[[SRC:.*]] = urem i32 %[[LHSEXT]], %[[RHS]]1246 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81247 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1248 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1249 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1250 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1251 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1252 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1253 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3500_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1254 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3500_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1255 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1256 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1257 // CHECK-SANITIZE: [[CONT]]:1258 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11259 // CHECK-NEXT: ret void1260 // CHECK-NEXT: }1261#line 35001262 (*LHS) %= RHS;1263}1264 1265// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_int1266void unsigned_char_rem_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1267 // CHECK: {1268 // CHECK-NEXT: entry:1269 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81270 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41271 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81272 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41273 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41274 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81275 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11276 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321277 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]1278 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81279 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1280 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1281 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1282 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1283 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1284 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1285 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1286 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1287 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1288 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1289 // CHECK-SANITIZE: [[CONT]]:1290 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11291 // CHECK-NEXT: ret void1292 // CHECK-NEXT: }1293#line 36001294 (*LHS) %= RHS;1295}1296 1297// CHECK-LABEL: @signed_char_rem_unsigned_char1298void signed_char_rem_unsigned_char(signed char *LHS, unsigned char RHS) {1299 // CHECK: {1300 // CHECK-NEXT: entry:1301 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81302 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11303 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81304 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11305 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11306 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321307 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81308 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11309 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321310 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1311 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81312 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1313 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1314 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1315 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1316 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1317 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1318 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1319 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1320 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1321 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1322 // CHECK-SANITIZE: [[CONT]]:1323 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11324 // CHECK-NEXT: ret void1325 // CHECK-NEXT: }1326#line 37001327 (*LHS) %= RHS;1328}1329 1330// CHECK-LABEL: @signed_char_rem_signed_char1331void signed_char_rem_signed_char(signed char *LHS, signed char RHS) {1332 // CHECK: {1333 // CHECK-NEXT: entry:1334 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81335 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11336 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81337 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11338 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11339 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321340 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81341 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11342 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321343 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1344 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81345 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1346 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1347 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1348 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1349 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1350 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1351 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1352 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1353 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1354 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1355 // CHECK-SANITIZE: [[CONT]]:1356 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11357 // CHECK-NEXT: ret void1358 // CHECK-NEXT: }1359#line 38001360 (*LHS) %= RHS;1361}1362 1363// CHECK-LABEL: @signed_char_rem_signed_char_unsigned_int1364void signed_char_rem_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1365 // CHECK: {1366 // CHECK-NEXT: entry:1367 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81368 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41369 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81370 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41371 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41372 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81373 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11374 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321375 // CHECK-NEXT: %[[SRC:.*]] = urem i32 %[[LHSEXT]], %[[RHS]]1376 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81377 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1378 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1379 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1380 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1381 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1382 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1383 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1384 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1385 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1386 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1387 // CHECK-SANITIZE: [[CONT]]:1388 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11389 // CHECK-NEXT: ret void1390 // CHECK-NEXT: }1391#line 39001392 (*LHS) %= RHS;1393}1394 1395// CHECK-LABEL: @signed_char_rem_signed_char_signed_int1396void signed_char_rem_signed_char_signed_int(signed char *LHS, signed int RHS) {1397 // CHECK: {1398 // CHECK-NEXT: entry:1399 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81400 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41401 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81402 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41403 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41404 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81405 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11406 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321407 // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]1408 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81409 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1410 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1411 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1412 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1413 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1414 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1415 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1416 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1417 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1418 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1419 // CHECK-SANITIZE: [[CONT]]:1420 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11421 // CHECK-NEXT: ret void1422 // CHECK-NEXT: }1423#line 40001424 (*LHS) %= RHS;1425}1426 1427//----------------------------------------------------------------------------//1428// Compound left-shift operator. //1429//----------------------------------------------------------------------------//1430 1431// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_char1432void unsigned_char_shl_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1433 // CHECK: {1434 // CHECK-NEXT: entry:1435 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81436 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11437 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81438 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11439 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11440 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321441 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81442 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11443 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321444 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1445 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81446 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1447 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1448 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1449 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1450 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1451 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1452 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1453 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1454 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1455 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1456 // CHECK-SANITIZE: [[CONT]]:1457 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11458 // CHECK-NEXT: ret void1459 // CHECK-NEXT: }1460#line 41001461 (*LHS) <<= RHS;1462}1463 1464// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_char1465void unsigned_char_shl_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1466 // CHECK: {1467 // CHECK-NEXT: entry:1468 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81469 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11470 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81471 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11472 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11473 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321474 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81475 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11476 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321477 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1478 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81479 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1480 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1481 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1482 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1483 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1484 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1485 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1486 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1487 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1488 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1489 // CHECK-SANITIZE: [[CONT]]:1490 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11491 // CHECK-NEXT: ret void1492 // CHECK-NEXT: }1493#line 42001494 (*LHS) <<= RHS;1495}1496 1497// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_int1498void unsigned_char_shl_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1499 // CHECK: {1500 // CHECK-NEXT: entry:1501 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81502 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41503 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81504 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41505 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41506 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81507 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11508 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321509 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1510 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81511 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1512 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1513 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1514 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1515 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1516 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1517 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1518 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1519 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1520 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1521 // CHECK-SANITIZE: [[CONT]]:1522 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11523 // CHECK-NEXT: ret void1524 // CHECK-NEXT: }1525#line 43001526 (*LHS) <<= RHS;1527}1528 1529// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_int1530void unsigned_char_shl_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1531 // CHECK: {1532 // CHECK-NEXT: entry:1533 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81534 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41535 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81536 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41537 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41538 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81539 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11540 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321541 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1542 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81543 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1544 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1545 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1546 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1547 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1548 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1549 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1550 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1551 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1552 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1553 // CHECK-SANITIZE: [[CONT]]:1554 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11555 // CHECK-NEXT: ret void1556 // CHECK-NEXT: }1557#line 44001558 (*LHS) <<= RHS;1559}1560 1561// CHECK-LABEL: @signed_char_shl_unsigned_char1562void signed_char_shl_unsigned_char(signed char *LHS, unsigned char RHS) {1563 // CHECK: {1564 // CHECK-NEXT: entry:1565 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81566 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11567 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81568 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11569 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11570 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321571 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81572 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11573 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321574 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1575 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81576 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1577 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1578 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1579 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1580 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1581 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1582 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1583 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1584 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1585 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1586 // CHECK-SANITIZE: [[CONT]]:1587 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11588 // CHECK-NEXT: ret void1589 // CHECK-NEXT: }1590#line 45001591 (*LHS) <<= RHS;1592}1593 1594// CHECK-LABEL: @signed_char_shl_signed_char1595void signed_char_shl_signed_char(signed char *LHS, signed char RHS) {1596 // CHECK: {1597 // CHECK-NEXT: entry:1598 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81599 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11600 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81601 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11602 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11603 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321604 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81605 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11606 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321607 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1608 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81609 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1610 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1611 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1612 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1613 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1614 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1615 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1616 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1617 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1618 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1619 // CHECK-SANITIZE: [[CONT]]:1620 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11621 // CHECK-NEXT: ret void1622 // CHECK-NEXT: }1623#line 46001624 (*LHS) <<= RHS;1625}1626 1627// CHECK-LABEL: @signed_char_shl_signed_char_unsigned_int1628void signed_char_shl_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1629 // CHECK: {1630 // CHECK-NEXT: entry:1631 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81632 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41633 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81634 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41635 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41636 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81637 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11638 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321639 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1640 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81641 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1642 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1643 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1644 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1645 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1646 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1647 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1648 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1649 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1650 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1651 // CHECK-SANITIZE: [[CONT]]:1652 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11653 // CHECK-NEXT: ret void1654 // CHECK-NEXT: }1655#line 47001656 (*LHS) <<= RHS;1657}1658 1659// CHECK-LABEL: @signed_char_shl_signed_char_signed_int1660void signed_char_shl_signed_char_signed_int(signed char *LHS, signed int RHS) {1661 // CHECK: {1662 // CHECK-NEXT: entry:1663 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81664 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41665 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81666 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41667 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41668 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81669 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11670 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321671 // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1672 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81673 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1674 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1675 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1676 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1677 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1678 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1679 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1680 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1681 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1682 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1683 // CHECK-SANITIZE: [[CONT]]:1684 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11685 // CHECK-NEXT: ret void1686 // CHECK-NEXT: }1687#line 48001688 (*LHS) <<= RHS;1689}1690 1691//----------------------------------------------------------------------------//1692// Compound right-shift operator. //1693//----------------------------------------------------------------------------//1694 1695// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_char1696void unsigned_char_shr_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1697 // CHECK: {1698 // CHECK-NEXT: entry:1699 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81700 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11701 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81702 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11703 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11704 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321705 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81706 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11707 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321708 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1709 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81710 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1711 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1712 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1713 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1714 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1715 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1716 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1717 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1718 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1719 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1720 // CHECK-SANITIZE: [[CONT]]:1721 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11722 // CHECK-NEXT: ret void1723 // CHECK-NEXT: }1724#line 49001725 (*LHS) >>= RHS;1726}1727 1728// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_char1729void unsigned_char_shr_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1730 // CHECK: {1731 // CHECK-NEXT: entry:1732 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81733 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11734 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81735 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11736 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11737 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321738 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81739 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11740 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321741 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1742 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81743 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1744 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1745 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1746 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1747 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1748 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1749 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1750 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1751 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1752 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1753 // CHECK-SANITIZE: [[CONT]]:1754 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11755 // CHECK-NEXT: ret void1756 // CHECK-NEXT: }1757#line 50001758 (*LHS) >>= RHS;1759}1760 1761// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_int1762void unsigned_char_shr_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1763 // CHECK: {1764 // CHECK-NEXT: entry:1765 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81766 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41767 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81768 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41769 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41770 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81771 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11772 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321773 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1774 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81775 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1776 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1777 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1778 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1779 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1780 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1781 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1782 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1783 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1784 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1785 // CHECK-SANITIZE: [[CONT]]:1786 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11787 // CHECK-NEXT: ret void1788 // CHECK-NEXT: }1789#line 51001790 (*LHS) >>= RHS;1791}1792 1793// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_int1794void unsigned_char_shr_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1795 // CHECK: {1796 // CHECK-NEXT: entry:1797 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81798 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41799 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81800 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41801 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41802 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81803 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11804 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321805 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1806 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81807 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1808 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1809 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1810 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1811 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1812 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1813 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1814 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1815 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1816 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1817 // CHECK-SANITIZE: [[CONT]]:1818 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11819 // CHECK-NEXT: ret void1820 // CHECK-NEXT: }1821#line 52001822 (*LHS) >>= RHS;1823}1824 1825// CHECK-LABEL: @signed_char_shr_unsigned_char1826void signed_char_shr_unsigned_char(signed char *LHS, unsigned char RHS) {1827 // CHECK: {1828 // CHECK-NEXT: entry:1829 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81830 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11831 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81832 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11833 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11834 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321835 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81836 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11837 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321838 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1839 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81840 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1841 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1842 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1843 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1844 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1845 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1846 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1847 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1848 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1849 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1850 // CHECK-SANITIZE: [[CONT]]:1851 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11852 // CHECK-NEXT: ret void1853 // CHECK-NEXT: }1854#line 53001855 (*LHS) >>= RHS;1856}1857 1858// CHECK-LABEL: @signed_char_shr_signed_char1859void signed_char_shr_signed_char(signed char *LHS, signed char RHS) {1860 // CHECK: {1861 // CHECK-NEXT: entry:1862 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81863 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11864 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81865 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11866 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11867 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321868 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81869 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11870 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321871 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1872 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81873 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1874 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1875 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1876 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1877 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1878 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1879 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1880 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1881 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1882 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1883 // CHECK-SANITIZE: [[CONT]]:1884 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11885 // CHECK-NEXT: ret void1886 // CHECK-NEXT: }1887#line 54001888 (*LHS) >>= RHS;1889}1890 1891// CHECK-LABEL: @signed_char_shr_signed_char_unsigned_int1892void signed_char_shr_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1893 // CHECK: {1894 // CHECK-NEXT: entry:1895 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81896 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41897 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81898 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41899 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41900 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81901 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11902 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321903 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1904 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81905 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1906 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1907 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1908 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1909 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1910 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1911 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1912 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1913 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1914 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1915 // CHECK-SANITIZE: [[CONT]]:1916 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11917 // CHECK-NEXT: ret void1918 // CHECK-NEXT: }1919#line 55001920 (*LHS) >>= RHS;1921}1922 1923// CHECK-LABEL: @signed_char_shr_signed_char_signed_int1924void signed_char_shr_signed_char_signed_int(signed char *LHS, signed int RHS) {1925 // CHECK: {1926 // CHECK-NEXT: entry:1927 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81928 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41929 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81930 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41931 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41932 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81933 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11934 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321935 // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1936 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81937 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize1938 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1939 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1940 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1941 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1942 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1943 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1944 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1945 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1946 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1947 // CHECK-SANITIZE: [[CONT]]:1948 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11949 // CHECK-NEXT: ret void1950 // CHECK-NEXT: }1951#line 56001952 (*LHS) >>= RHS;1953}1954 1955//----------------------------------------------------------------------------//1956// Compound and operator. //1957//----------------------------------------------------------------------------//1958 1959// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_char1960void unsigned_char_and_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1961 // CHECK: {1962 // CHECK-NEXT: entry:1963 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81964 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11965 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81966 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11967 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11968 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321969 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81970 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11971 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321972 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1973 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81974 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize1975 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize1976 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1977 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1978 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1979 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1980 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1981 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1982 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1983 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1984 // CHECK-SANITIZE: [[CONT]]:1985 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11986 // CHECK-NEXT: ret void1987 // CHECK-NEXT: }1988#line 57001989 (*LHS) &= RHS;1990}1991 1992// CHECK-LABEL: @unsigned_char_and_signed_char_signed_char1993void unsigned_char_and_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1994 // CHECK: {1995 // CHECK-NEXT: entry:1996 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81997 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11998 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81999 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12000 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12001 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322002 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82003 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12004 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322005 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]2006 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82007 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2008 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2009 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2010 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2011 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2012 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2013 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2014 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2015 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2016 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2017 // CHECK-SANITIZE: [[CONT]]:2018 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12019 // CHECK-NEXT: ret void2020 // CHECK-NEXT: }2021#line 58002022 (*LHS) &= RHS;2023}2024 2025// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_int2026void unsigned_char_and_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {2027 // CHECK: {2028 // CHECK-NEXT: entry:2029 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82030 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42031 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82032 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42033 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42034 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82035 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12036 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322037 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2038 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82039 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2040 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2041 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2042 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2043 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2044 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2045 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5900_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2046 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5900_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2047 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2048 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2049 // CHECK-SANITIZE: [[CONT]]:2050 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12051 // CHECK-NEXT: ret void2052 // CHECK-NEXT: }2053#line 59002054 (*LHS) &= RHS;2055}2056 2057// CHECK-LABEL: @unsigned_char_and_signed_char_signed_int2058void unsigned_char_and_signed_char_signed_int(unsigned char *LHS, signed int RHS) {2059 // CHECK: {2060 // CHECK-NEXT: entry:2061 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82062 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42063 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82064 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42065 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42066 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82067 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12068 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322069 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2070 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82071 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2072 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2073 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2074 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2075 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2076 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2077 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2078 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2079 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2080 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2081 // CHECK-SANITIZE: [[CONT]]:2082 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12083 // CHECK-NEXT: ret void2084 // CHECK-NEXT: }2085#line 60002086 (*LHS) &= RHS;2087}2088 2089// CHECK-LABEL: @signed_char_and_unsigned_char2090void signed_char_and_unsigned_char(signed char *LHS, unsigned char RHS) {2091 // CHECK: {2092 // CHECK-NEXT: entry:2093 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82094 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12095 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82096 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12097 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12098 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322099 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82100 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12101 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322102 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]2103 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82104 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2105 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2106 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2107 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2108 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2109 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2110 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2111 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2112 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2113 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2114 // CHECK-SANITIZE: [[CONT]]:2115 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12116 // CHECK-NEXT: ret void2117 // CHECK-NEXT: }2118#line 61002119 (*LHS) &= RHS;2120}2121 2122// CHECK-LABEL: @signed_char_and_signed_char2123void signed_char_and_signed_char(signed char *LHS, signed char RHS) {2124 // CHECK: {2125 // CHECK-NEXT: entry:2126 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82127 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12128 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82129 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12130 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12131 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322132 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82133 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12134 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322135 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]2136 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82137 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2138 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2139 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2140 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2141 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2142 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2143 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2144 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2145 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2146 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2147 // CHECK-SANITIZE: [[CONT]]:2148 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12149 // CHECK-NEXT: ret void2150 // CHECK-NEXT: }2151#line 62002152 (*LHS) &= RHS;2153}2154 2155// CHECK-LABEL: @signed_char_and_signed_char_unsigned_int2156void signed_char_and_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2157 // CHECK: {2158 // CHECK-NEXT: entry:2159 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82160 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42161 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82162 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42163 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42164 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82165 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12166 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322167 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2168 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82169 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2170 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2171 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2172 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2173 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2174 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2175 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2176 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2177 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2178 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2179 // CHECK-SANITIZE: [[CONT]]:2180 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12181 // CHECK-NEXT: ret void2182 // CHECK-NEXT: }2183#line 63002184 (*LHS) &= RHS;2185}2186 2187// CHECK-LABEL: @signed_char_and_signed_char_signed_int2188void signed_char_and_signed_char_signed_int(signed char *LHS, signed int RHS) {2189 // CHECK: {2190 // CHECK-NEXT: entry:2191 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82192 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42193 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82194 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42195 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42196 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82197 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12198 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322199 // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2200 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82201 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2202 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2203 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2204 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2205 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2206 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2207 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2208 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2209 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2210 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2211 // CHECK-SANITIZE: [[CONT]]:2212 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12213 // CHECK-NEXT: ret void2214 // CHECK-NEXT: }2215#line 64002216 (*LHS) &= RHS;2217}2218 2219//----------------------------------------------------------------------------//2220// Compound xor operator. //2221//----------------------------------------------------------------------------//2222 2223// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_char2224void unsigned_char_or_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {2225 // CHECK: {2226 // CHECK-NEXT: entry:2227 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82228 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12229 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82230 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12231 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12232 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322233 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82234 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12235 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322236 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2237 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82238 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2239 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2240 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2241 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2242 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2243 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2244 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2245 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6500_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2246 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2247 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2248 // CHECK-SANITIZE: [[CONT]]:2249 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12250 // CHECK-NEXT: ret void2251 // CHECK-NEXT: }2252#line 65002253 (*LHS) |= RHS;2254}2255 2256// CHECK-LABEL: @unsigned_char_or_signed_char_signed_char2257void unsigned_char_or_signed_char_signed_char(unsigned char *LHS, signed char RHS) {2258 // CHECK: {2259 // CHECK-NEXT: entry:2260 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82261 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12262 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82263 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12264 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12265 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322266 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82267 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12268 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322269 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2270 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82271 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2272 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2273 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2274 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2275 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2276 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2277 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2278 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2279 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2280 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2281 // CHECK-SANITIZE: [[CONT]]:2282 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12283 // CHECK-NEXT: ret void2284 // CHECK-NEXT: }2285#line 66002286 (*LHS) |= RHS;2287}2288 2289// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_int2290void unsigned_char_or_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {2291 // CHECK: {2292 // CHECK-NEXT: entry:2293 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82294 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42295 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82296 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42297 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42298 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82299 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12300 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322301 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2302 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82303 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2304 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2305 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2306 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2307 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2308 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2309 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6700_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2310 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6700_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2311 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2312 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2313 // CHECK-SANITIZE: [[CONT]]:2314 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12315 // CHECK-NEXT: ret void2316 // CHECK-NEXT: }2317#line 67002318 (*LHS) |= RHS;2319}2320 2321// CHECK-LABEL: @unsigned_char_or_signed_char_signed_int2322void unsigned_char_or_signed_char_signed_int(unsigned char *LHS, signed int RHS) {2323 // CHECK: {2324 // CHECK-NEXT: entry:2325 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82326 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42327 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82328 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42329 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42330 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82331 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12332 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322333 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2334 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82335 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2336 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2337 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2338 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2339 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2340 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2341 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2342 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2343 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2344 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2345 // CHECK-SANITIZE: [[CONT]]:2346 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12347 // CHECK-NEXT: ret void2348 // CHECK-NEXT: }2349#line 68002350 (*LHS) |= RHS;2351}2352 2353// CHECK-LABEL: @signed_char_or_unsigned_char2354void signed_char_or_unsigned_char(signed char *LHS, unsigned char RHS) {2355 // CHECK: {2356 // CHECK-NEXT: entry:2357 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82358 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12359 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82360 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12361 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12362 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322363 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82364 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12365 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322366 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2367 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82368 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2369 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2370 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2371 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2372 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2373 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2374 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2375 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2376 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2377 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2378 // CHECK-SANITIZE: [[CONT]]:2379 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12380 // CHECK-NEXT: ret void2381 // CHECK-NEXT: }2382#line 69002383 (*LHS) |= RHS;2384}2385 2386// CHECK-LABEL: @signed_char_or_signed_char2387void signed_char_or_signed_char(signed char *LHS, signed char RHS) {2388 // CHECK: {2389 // CHECK-NEXT: entry:2390 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82391 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12392 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82393 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12394 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12395 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322396 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82397 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12398 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322399 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2400 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82401 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2402 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2403 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2404 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2405 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2406 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2407 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2408 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2409 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2410 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2411 // CHECK-SANITIZE: [[CONT]]:2412 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12413 // CHECK-NEXT: ret void2414 // CHECK-NEXT: }2415#line 70002416 (*LHS) |= RHS;2417}2418 2419// CHECK-LABEL: @signed_char_or_signed_char_unsigned_int2420void signed_char_or_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2421 // CHECK: {2422 // CHECK-NEXT: entry:2423 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82424 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42425 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82426 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42427 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42428 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82429 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12430 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322431 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2432 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82433 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2434 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2435 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2436 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2437 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2438 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2439 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2440 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7100_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2441 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2442 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2443 // CHECK-SANITIZE: [[CONT]]:2444 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12445 // CHECK-NEXT: ret void2446 // CHECK-NEXT: }2447#line 71002448 (*LHS) |= RHS;2449}2450 2451// CHECK-LABEL: @signed_char_or_signed_char_signed_int2452void signed_char_or_signed_char_signed_int(signed char *LHS, signed int RHS) {2453 // CHECK: {2454 // CHECK-NEXT: entry:2455 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82456 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42457 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82458 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42459 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42460 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82461 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12462 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322463 // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2464 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82465 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2466 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2467 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2468 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2469 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2470 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2471 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2472 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7200_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2473 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2474 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2475 // CHECK-SANITIZE: [[CONT]]:2476 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12477 // CHECK-NEXT: ret void2478 // CHECK-NEXT: }2479#line 72002480 (*LHS) |= RHS;2481}2482 2483//----------------------------------------------------------------------------//2484// Compound or operator. //2485//----------------------------------------------------------------------------//2486 2487// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_char2488void unsigned_char_xor_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {2489 // CHECK: {2490 // CHECK-NEXT: entry:2491 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82492 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12493 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82494 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12495 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12496 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322497 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82498 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12499 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322500 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2501 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82502 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2503 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2504 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2505 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2506 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2507 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2508 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2509 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7300_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2510 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2511 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2512 // CHECK-SANITIZE: [[CONT]]:2513 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12514 // CHECK-NEXT: ret void2515 // CHECK-NEXT: }2516#line 73002517 (*LHS) ^= RHS;2518}2519 2520// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_char2521void unsigned_char_xor_signed_char_signed_char(unsigned char *LHS, signed char RHS) {2522 // CHECK: {2523 // CHECK-NEXT: entry:2524 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82525 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12526 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82527 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12528 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12529 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322530 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82531 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12532 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322533 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2534 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82535 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2536 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2537 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2538 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2539 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2540 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2541 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2542 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7400_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2543 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2544 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2545 // CHECK-SANITIZE: [[CONT]]:2546 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12547 // CHECK-NEXT: ret void2548 // CHECK-NEXT: }2549#line 74002550 (*LHS) ^= RHS;2551}2552 2553// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_int2554void unsigned_char_xor_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {2555 // CHECK: {2556 // CHECK-NEXT: entry:2557 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82558 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42559 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82560 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42561 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42562 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82563 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12564 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322565 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2566 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82567 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2568 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2569 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2570 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2571 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2572 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2573 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7500_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2574 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7500_UNSIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2575 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2576 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2577 // CHECK-SANITIZE: [[CONT]]:2578 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12579 // CHECK-NEXT: ret void2580 // CHECK-NEXT: }2581#line 75002582 (*LHS) ^= RHS;2583}2584 2585// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_int2586void unsigned_char_xor_signed_char_signed_int(unsigned char *LHS, signed int RHS) {2587 // CHECK: {2588 // CHECK-NEXT: entry:2589 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82590 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42591 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82592 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42593 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42594 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82595 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12596 // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322597 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2598 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82599 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = zext i8 %[[DST]] to i32, !nosanitize2600 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2601 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2602 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2603 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2604 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2605 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2606 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7600_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2607 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2608 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2609 // CHECK-SANITIZE: [[CONT]]:2610 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12611 // CHECK-NEXT: ret void2612 // CHECK-NEXT: }2613#line 76002614 (*LHS) ^= RHS;2615}2616 2617// CHECK-LABEL: @signed_char_xor_unsigned_char2618void signed_char_xor_unsigned_char(signed char *LHS, unsigned char RHS) {2619 // CHECK: {2620 // CHECK-NEXT: entry:2621 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82622 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12623 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82624 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12625 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12626 // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322627 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82628 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12629 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322630 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2631 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82632 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2633 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2634 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2635 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2636 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2637 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2638 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2639 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7700_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2640 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2641 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2642 // CHECK-SANITIZE: [[CONT]]:2643 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12644 // CHECK-NEXT: ret void2645 // CHECK-NEXT: }2646#line 77002647 (*LHS) ^= RHS;2648}2649 2650// CHECK-LABEL: @signed_char_xor_signed_char2651void signed_char_xor_signed_char(signed char *LHS, signed char RHS) {2652 // CHECK: {2653 // CHECK-NEXT: entry:2654 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82655 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12656 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82657 // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12658 // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12659 // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322660 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82661 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12662 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322663 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2664 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82665 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2666 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2667 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2668 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2669 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2670 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2671 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2672 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7800_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2673 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2674 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2675 // CHECK-SANITIZE: [[CONT]]:2676 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12677 // CHECK-NEXT: ret void2678 // CHECK-NEXT: }2679#line 78002680 (*LHS) ^= RHS;2681}2682 2683// CHECK-LABEL: @signed_char_xor_signed_char_unsigned_int2684void signed_char_xor_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2685 // CHECK: {2686 // CHECK-NEXT: entry:2687 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82688 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42689 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82690 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42691 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42692 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82693 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12694 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322695 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2696 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82697 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2698 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2699 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2700 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2701 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2702 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2703 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2704 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7900_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2705 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2706 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2707 // CHECK-SANITIZE: [[CONT]]:2708 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12709 // CHECK-NEXT: ret void2710 // CHECK-NEXT: }2711#line 79002712 (*LHS) ^= RHS;2713}2714 2715// CHECK-LABEL: @signed_char_xor_signed_char_signed_int2716void signed_char_xor_signed_char_signed_int(signed char *LHS, signed int RHS) {2717 // CHECK: {2718 // CHECK-NEXT: entry:2719 // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82720 // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42721 // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82722 // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42723 // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42724 // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82725 // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12726 // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322727 // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2728 // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82729 // CHECK-SANITIZE-NEXT: %[[ANYEXT:.*]] = sext i8 %[[DST]] to i32, !nosanitize2730 // CHECK-SANITIZE-NEXT: %[[TRUNCHECK:.*]] = icmp eq i32 %[[ANYEXT]], %[[SRC]], !nosanitize2731 // CHECK-SANITIZE-NEXT: br i1 %[[TRUNCHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2732 // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2733 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2734 // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2735 // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_8000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2736 // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_8000_SIGNED_TRUNCATION]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2737 // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2738 // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2739 // CHECK-SANITIZE: [[CONT]]:2740 // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12741 // CHECK-NEXT: ret void2742 // CHECK-NEXT: }2743#line 80002744 (*LHS) ^= RHS;2745}2746