brintos / llvm-project-archived public Read only

1// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefix=CHECK2 3// RUN: %clang_cc1 -fsanitize=implicit-integer-sign-change -fno-sanitize-recover=implicit-integer-sign-change -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE4// RUN: %clang_cc1 -fsanitize=implicit-integer-sign-change -fsanitize-recover=implicit-integer-sign-change -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER5// RUN: %clang_cc1 -fsanitize=implicit-integer-sign-change -fsanitize-trap=implicit-integer-sign-change -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_implicit_conversion" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-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_SIGN_CHANGE:.*]] = {{.*}}, i32 100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }16// CHECK-SANITIZE-ANYRECOVER: @[[LINE_200_SIGN_CHANGE:.*]] = {{.*}}, i32 200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }17// CHECK-SANITIZE-ANYRECOVER: @[[LINE_400_SIGN_CHANGE:.*]] = {{.*}}, i32 400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }18// CHECK-SANITIZE-ANYRECOVER: @[[SIGNED_CHAR:.*]] = {{.*}} c"'signed char'\00" }19// CHECK-SANITIZE-ANYRECOVER: @[[LINE_500_SIGN_CHANGE:.*]] = {{.*}}, i32 500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }20// CHECK-SANITIZE-ANYRECOVER: @[[LINE_600_SIGN_CHANGE:.*]] = {{.*}}, i32 600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }21// CHECK-SANITIZE-ANYRECOVER: @[[UNSIGNED_INT:.*]] = {{.*}} c"'unsigned int'\00" }22// CHECK-SANITIZE-ANYRECOVER: @[[LINE_700_SIGN_CHANGE:.*]] = {{.*}}, i32 700, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }23// CHECK-SANITIZE-ANYRECOVER: @[[LINE_800_SIGN_CHANGE:.*]] = {{.*}}, i32 800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }24 25// CHECK-SANITIZE-ANYRECOVER: @[[LINE_900_SIGN_CHANGE:.*]] = {{.*}}, i32 900, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }26// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1000_SIGN_CHANGE:.*]] = {{.*}}, i32 1000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }27// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1200_SIGN_CHANGE:.*]] = {{.*}}, i32 1200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }28// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1300_SIGN_CHANGE:.*]] = {{.*}}, i32 1300, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }29// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1400_SIGN_CHANGE:.*]] = {{.*}}, i32 1400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }30// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1500_SIGN_CHANGE:.*]] = {{.*}}, i32 1500, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }31// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1600_SIGN_CHANGE:.*]] = {{.*}}, i32 1600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }32 33// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1700_SIGN_CHANGE:.*]] = {{.*}}, i32 1700, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }34// CHECK-SANITIZE-ANYRECOVER: @[[LINE_1800_SIGN_CHANGE:.*]] = {{.*}}, i32 1800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }35// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2000_SIGN_CHANGE:.*]] = {{.*}}, i32 2000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }36// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2100_SIGN_CHANGE:.*]] = {{.*}}, i32 2100, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }37// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2200_SIGN_CHANGE:.*]] = {{.*}}, i32 2200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }38// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2300_SIGN_CHANGE:.*]] = {{.*}}, i32 2300, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }39// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2400_SIGN_CHANGE:.*]] = {{.*}}, i32 2400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }40 41// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2500_SIGN_CHANGE:.*]] = {{.*}}, i32 2500, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }42// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2600_SIGN_CHANGE:.*]] = {{.*}}, i32 2600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }43// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2800_SIGN_CHANGE:.*]] = {{.*}}, i32 2800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }44// CHECK-SANITIZE-ANYRECOVER: @[[LINE_2900_SIGN_CHANGE:.*]] = {{.*}}, i32 2900, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }45// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3000_SIGN_CHANGE:.*]] = {{.*}}, i32 3000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }46// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3100_SIGN_CHANGE:.*]] = {{.*}}, i32 3100, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }47// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3200_SIGN_CHANGE:.*]] = {{.*}}, i32 3200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }48 49// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3300_SIGN_CHANGE:.*]] = {{.*}}, i32 3300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }50// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3400_SIGN_CHANGE:.*]] = {{.*}}, i32 3400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }51// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3600_SIGN_CHANGE:.*]] = {{.*}}, i32 3600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }52// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3700_SIGN_CHANGE:.*]] = {{.*}}, i32 3700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }53// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3800_SIGN_CHANGE:.*]] = {{.*}}, i32 3800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }54// CHECK-SANITIZE-ANYRECOVER: @[[LINE_3900_SIGN_CHANGE:.*]] = {{.*}}, i32 3900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }55// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4000_SIGN_CHANGE:.*]] = {{.*}}, i32 4000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }56 57// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4100_SIGN_CHANGE:.*]] = {{.*}}, i32 4100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }58// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4200_SIGN_CHANGE:.*]] = {{.*}}, i32 4200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }59// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4300_SIGN_CHANGE:.*]] = {{.*}}, i32 4300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }60// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4400_SIGN_CHANGE:.*]] = {{.*}}, i32 4400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }61// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4500_SIGN_CHANGE:.*]] = {{.*}}, i32 4500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }62// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4600_SIGN_CHANGE:.*]] = {{.*}}, i32 4600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }63// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4700_SIGN_CHANGE:.*]] = {{.*}}, i32 4700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }64// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4800_SIGN_CHANGE:.*]] = {{.*}}, i32 4800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }65 66// CHECK-SANITIZE-ANYRECOVER: @[[LINE_4900_SIGN_CHANGE:.*]] = {{.*}}, i32 4900, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }67// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5000_SIGN_CHANGE:.*]] = {{.*}}, i32 5000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }68// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5100_SIGN_CHANGE:.*]] = {{.*}}, i32 5100, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }69// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5200_SIGN_CHANGE:.*]] = {{.*}}, i32 5200, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }70// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5300_SIGN_CHANGE:.*]] = {{.*}}, i32 5300, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }71// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5400_SIGN_CHANGE:.*]] = {{.*}}, i32 5400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }72// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5500_SIGN_CHANGE:.*]] = {{.*}}, i32 5500, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }73// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5600_SIGN_CHANGE:.*]] = {{.*}}, i32 5600, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }74 75// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5700_SIGN_CHANGE:.*]] = {{.*}}, i32 5700, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }76// CHECK-SANITIZE-ANYRECOVER: @[[LINE_5800_SIGN_CHANGE:.*]] = {{.*}}, i32 5800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }77// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6000_SIGN_CHANGE:.*]] = {{.*}}, i32 6000, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }78// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6100_SIGN_CHANGE:.*]] = {{.*}}, i32 6100, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }79// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6200_SIGN_CHANGE:.*]] = {{.*}}, i32 6200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }80// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6300_SIGN_CHANGE:.*]] = {{.*}}, i32 6300, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }81// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6400_SIGN_CHANGE:.*]] = {{.*}}, i32 6400, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }82 83// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6500_SIGN_CHANGE:.*]] = {{.*}}, i32 6500, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }84// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6600_SIGN_CHANGE:.*]] = {{.*}}, i32 6600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }85// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6800_SIGN_CHANGE:.*]] = {{.*}}, i32 6800, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }86// CHECK-SANITIZE-ANYRECOVER: @[[LINE_6900_SIGN_CHANGE:.*]] = {{.*}}, i32 6900, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }87// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7000_SIGN_CHANGE:.*]] = {{.*}}, i32 7000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }88// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7100_SIGN_CHANGE:.*]] = {{.*}}, i32 7100, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }89// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7200_SIGN_CHANGE:.*]] = {{.*}}, i32 7200, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }90 91// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7300_SIGN_CHANGE:.*]] = {{.*}}, i32 7300, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }92// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7400_SIGN_CHANGE:.*]] = {{.*}}, i32 7400, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }93// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7600_SIGN_CHANGE:.*]] = {{.*}}, i32 7600, i32 10 }, ptr @[[INT]], ptr @[[UNSIGNED_CHAR]], i8 3, i32 0 }94// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7700_SIGN_CHANGE:.*]] = {{.*}}, i32 7700, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }95// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7800_SIGN_CHANGE:.*]] = {{.*}}, i32 7800, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }96// CHECK-SANITIZE-ANYRECOVER: @[[LINE_7900_SIGN_CHANGE:.*]] = {{.*}}, i32 7900, i32 10 }, ptr @[[UNSIGNED_INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }97// CHECK-SANITIZE-ANYRECOVER: @[[LINE_8000_SIGN_CHANGE:.*]] = {{.*}}, i32 8000, i32 10 }, ptr @[[INT]], ptr @[[SIGNED_CHAR]], i8 3, i32 0 }98 99//----------------------------------------------------------------------------//100// Compound add operator.                                                     //101//----------------------------------------------------------------------------//102 103// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_char104void unsigned_char_add_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {105  // CHECK: {106  // CHECK-NEXT: entry:107  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8108  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1109  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8110  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1111  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1112  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32113  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8114  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1115  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32116  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]117  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8118  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize119  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize120  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize121  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:122  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize123  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize124  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize125  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize126  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize127  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize128  // CHECK-SANITIZE: [[CONT]]:129  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1130  // CHECK-NEXT: ret void131  // CHECK-NEXT: }132#line 100133  (*LHS) += RHS;134}135 136// CHECK-LABEL: @unsigned_char_add_signed_char_signed_char137void unsigned_char_add_signed_char_signed_char(unsigned char *LHS, signed char RHS) {138  // CHECK: {139  // CHECK-NEXT: entry:140  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8141  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1142  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8143  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1144  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1145  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32146  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8147  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1148  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32149  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]150  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8151  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize152  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize153  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize154  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:155  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize156  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize157  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize158  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize159  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize160  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize161  // CHECK-SANITIZE: [[CONT]]:162  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1163  // CHECK-NEXT: ret void164  // CHECK-NEXT: }165#line 200166  (*LHS) += RHS;167}168 169// CHECK-LABEL: @unsigned_char_add_signed_char_unsigned_int170void unsigned_char_add_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {171#line 300172  (*LHS) += RHS;173}174 175// CHECK-LABEL: @unsigned_char_add_signed_char_signed_int176void unsigned_char_add_signed_char_signed_int(unsigned char *LHS, signed int RHS) {177  // CHECK: {178  // CHECK-NEXT: entry:179  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8180  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4181  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8182  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4183  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4184  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8185  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1186  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32187  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHS]]188  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8189  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize190  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize191  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize192  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:193  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize194  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize195  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize196  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize197  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize198  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize199  // CHECK-SANITIZE: [[CONT]]:200  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1201  // CHECK-NEXT: ret void202  // CHECK-NEXT: }203#line 400204  (*LHS) += RHS;205}206 207// CHECK-LABEL: @signed_char_add_unsigned_char208void signed_char_add_unsigned_char(signed char *LHS, unsigned char RHS) {209  // CHECK: {210  // CHECK-NEXT: entry:211  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8212  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1213  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8214  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1215  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1216  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32217  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8218  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1219  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32220  // CHECK-NEXT: %[[SRC:.*]] = add nsw i32 %[[LHSEXT]], %[[RHSEXT]]221  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8222  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize223  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize224  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize225  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], 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_500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize230  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_500_SIGN_CHANGE]], 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 500238  (*LHS) += RHS;239}240 241// CHECK-LABEL: @signed_char_add_signed_char242void signed_char_add_signed_char(signed char *LHS, signed 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:.*]] = sext 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: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize257  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize258  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize259  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize260  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:261  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize262  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize263  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize264  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize265  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize266  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize267  // CHECK-SANITIZE: [[CONT]]:268  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1269  // CHECK-NEXT: ret void270  // CHECK-NEXT: }271#line 600272  (*LHS) += RHS;273}274 275// CHECK-LABEL: @signed_char_add_signed_char_unsigned_int276void signed_char_add_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {277  // CHECK: {278  // CHECK-NEXT: entry:279  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8280  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4281  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8282  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4283  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4284  // 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 i32 %[[LHSEXT]], %[[RHS]]288  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8289  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize290  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize291  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], 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_700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize296  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_700_SIGN_CHANGE]], 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 700304  (*LHS) += RHS;305}306 307// CHECK-LABEL: @signed_char_add_signed_char_signed_int308void signed_char_add_signed_char_signed_int(signed char *LHS, signed 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 nsw i32 %[[LHSEXT]], %[[RHS]]320  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8321  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize322  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize323  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize324  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize325  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:326  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize327  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize328  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize329  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize330  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize331  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize332  // CHECK-SANITIZE: [[CONT]]:333  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1334  // CHECK-NEXT: ret void335  // CHECK-NEXT: }336#line 800337  (*LHS) += RHS;338}339 340//----------------------------------------------------------------------------//341// Compound subtract operator.                                                //342//----------------------------------------------------------------------------//343 344// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_char345void unsigned_char_sub_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {346  // CHECK: {347  // CHECK-NEXT: entry:348  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8349  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1350  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8351  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1352  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1353  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32354  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8355  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1356  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32357  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]358  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8359  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize360  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize361  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize362  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:363  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize364  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize365  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize366  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize367  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize368  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize369  // CHECK-SANITIZE: [[CONT]]:370  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1371  // CHECK-NEXT: ret void372  // CHECK-NEXT: }373#line 900374  (*LHS) -= RHS;375}376 377// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_char378void unsigned_char_sub_signed_char_signed_char(unsigned char *LHS, signed char RHS) {379  // CHECK: {380  // CHECK-NEXT: entry:381  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8382  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1383  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8384  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1385  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1386  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32387  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8388  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1389  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32390  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]391  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8392  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize393  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize394  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize395  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:396  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize397  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize398  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize399  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize400  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize401  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize402  // CHECK-SANITIZE: [[CONT]]:403  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1404  // CHECK-NEXT: ret void405  // CHECK-NEXT: }406#line 1000407  (*LHS) -= RHS;408}409 410// CHECK-LABEL: @unsigned_char_sub_signed_char_unsigned_int411void unsigned_char_sub_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {412#line 1100413  (*LHS) -= RHS;414}415 416// CHECK-LABEL: @unsigned_char_sub_signed_char_signed_int417void unsigned_char_sub_signed_char_signed_int(unsigned char *LHS, signed int RHS) {418  // CHECK: {419  // CHECK-NEXT: entry:420  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8421  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4422  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8423  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4424  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4425  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8426  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1427  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32428  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]429  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8430  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize431  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize432  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize433  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:434  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize435  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize436  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize437  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize438  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize439  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize440  // CHECK-SANITIZE: [[CONT]]:441  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1442  // CHECK-NEXT: ret void443  // CHECK-NEXT: }444#line 1200445  (*LHS) -= RHS;446}447 448// CHECK-LABEL: @signed_char_sub_unsigned_char449void signed_char_sub_unsigned_char(signed char *LHS, unsigned char RHS) {450  // CHECK: {451  // CHECK-NEXT: entry:452  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8453  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1454  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8455  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1456  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1457  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32458  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8459  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1460  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32461  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]462  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8463  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize464  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize465  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize466  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize467  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:468  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize469  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize470  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize471  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize472  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize473  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize474  // CHECK-SANITIZE: [[CONT]]:475  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1476  // CHECK-NEXT: ret void477  // CHECK-NEXT: }478#line 1300479  (*LHS) -= RHS;480}481 482// CHECK-LABEL: @signed_char_sub_signed_char483void signed_char_sub_signed_char(signed char *LHS, signed char RHS) {484  // CHECK: {485  // CHECK-NEXT: entry:486  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8487  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1488  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8489  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1490  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1491  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32492  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8493  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1494  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32495  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHSEXT]]496  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8497  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize498  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize499  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize500  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize501  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:502  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize503  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize504  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize505  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize506  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize507  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize508  // CHECK-SANITIZE: [[CONT]]:509  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1510  // CHECK-NEXT: ret void511  // CHECK-NEXT: }512#line 1400513  (*LHS) -= RHS;514}515 516// CHECK-LABEL: @signed_char_sub_signed_char_unsigned_int517void signed_char_sub_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {518  // CHECK: {519  // CHECK-NEXT: entry:520  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8521  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4522  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8523  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4524  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4525  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8526  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1527  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32528  // CHECK-NEXT: %[[SRC:.*]] = sub i32 %[[LHSEXT]], %[[RHS]]529  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8530  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize531  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize532  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize533  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:534  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize535  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize536  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize537  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize538  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize539  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize540  // CHECK-SANITIZE: [[CONT]]:541  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1542  // CHECK-NEXT: ret void543  // CHECK-NEXT: }544#line 1500545  (*LHS) -= RHS;546}547 548// CHECK-LABEL: @signed_char_sub_signed_char_signed_int549void signed_char_sub_signed_char_signed_int(signed char *LHS, signed int RHS) {550  // CHECK: {551  // CHECK-NEXT: entry:552  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8553  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4554  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8555  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4556  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4557  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8558  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1559  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32560  // CHECK-NEXT: %[[SRC:.*]] = sub nsw i32 %[[LHSEXT]], %[[RHS]]561  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8562  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize563  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize564  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize565  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize566  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:567  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize568  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize569  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize570  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize571  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize572  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize573  // CHECK-SANITIZE: [[CONT]]:574  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1575  // CHECK-NEXT: ret void576  // CHECK-NEXT: }577#line 1600578  (*LHS) -= RHS;579}580 581//----------------------------------------------------------------------------//582// Compound multiply operator.                                                //583//----------------------------------------------------------------------------//584 585// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_char586void unsigned_char_mul_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {587  // CHECK: {588  // CHECK-NEXT: entry:589  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8590  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1591  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8592  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1593  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1594  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32595  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8596  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1597  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32598  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]599  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8600  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize601  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize602  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize603  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:604  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize605  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize606  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize607  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize608  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize609  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize610  // CHECK-SANITIZE: [[CONT]]:611  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1612  // CHECK-NEXT: ret void613  // CHECK-NEXT: }614#line 1700615  (*LHS) *= RHS;616}617 618// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_char619void unsigned_char_mul_signed_char_signed_char(unsigned char *LHS, signed char RHS) {620  // CHECK: {621  // CHECK-NEXT: entry:622  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8623  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1624  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8625  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1626  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1627  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32628  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8629  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1630  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32631  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]632  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8633  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize634  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize635  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize636  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:637  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize638  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize639  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_1800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize640  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_1800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize641  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize642  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize643  // CHECK-SANITIZE: [[CONT]]:644  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1645  // CHECK-NEXT: ret void646  // CHECK-NEXT: }647#line 1800648  (*LHS) *= RHS;649}650 651// CHECK-LABEL: @unsigned_char_mul_signed_char_unsigned_int652void unsigned_char_mul_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {653#line 1900654  (*LHS) *= RHS;655}656 657// CHECK-LABEL: @unsigned_char_mul_signed_char_signed_int658void unsigned_char_mul_signed_char_signed_int(unsigned char *LHS, signed int RHS) {659  // CHECK: {660  // CHECK-NEXT: entry:661  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8662  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4663  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8664  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4665  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4666  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8667  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1668  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32669  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]670  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8671  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize672  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize673  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize674  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:675  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize676  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize677  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize678  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize679  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize680  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize681  // CHECK-SANITIZE: [[CONT]]:682  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1683  // CHECK-NEXT: ret void684  // CHECK-NEXT: }685#line 2000686  (*LHS) *= RHS;687}688 689// CHECK-LABEL: @signed_char_mul_unsigned_char690void signed_char_mul_unsigned_char(signed char *LHS, unsigned char RHS) {691  // CHECK: {692  // CHECK-NEXT: entry:693  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8694  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1695  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8696  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1697  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1698  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32699  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8700  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1701  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32702  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]703  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8704  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize705  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize706  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize707  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize708  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:709  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize710  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize711  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize712  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize713  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize714  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize715  // CHECK-SANITIZE: [[CONT]]:716  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1717  // CHECK-NEXT: ret void718  // CHECK-NEXT: }719#line 2100720  (*LHS) *= RHS;721}722 723// CHECK-LABEL: @signed_char_mul_signed_char724void signed_char_mul_signed_char(signed char *LHS, signed char RHS) {725  // CHECK: {726  // CHECK-NEXT: entry:727  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8728  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1729  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8730  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1731  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1732  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32733  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8734  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1735  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32736  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHSEXT]]737  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8738  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize739  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize740  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize741  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize742  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:743  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize744  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize745  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize746  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize747  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize748  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize749  // CHECK-SANITIZE: [[CONT]]:750  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1751  // CHECK-NEXT: ret void752  // CHECK-NEXT: }753#line 2200754  (*LHS) *= RHS;755}756 757// CHECK-LABEL: @signed_char_mul_signed_char_unsigned_int758void signed_char_mul_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {759  // CHECK: {760  // CHECK-NEXT: entry:761  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8762  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4763  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8764  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4765  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4766  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8767  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1768  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32769  // CHECK-NEXT: %[[SRC:.*]] = mul i32 %[[LHSEXT]], %[[RHS]]770  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8771  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize772  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize773  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize774  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:775  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize776  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize777  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize778  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize779  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize780  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize781  // CHECK-SANITIZE: [[CONT]]:782  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1783  // CHECK-NEXT: ret void784  // CHECK-NEXT: }785#line 2300786  (*LHS) *= RHS;787}788 789// CHECK-LABEL: @signed_char_mul_signed_char_signed_int790void signed_char_mul_signed_char_signed_int(signed char *LHS, signed int RHS) {791  // CHECK: {792  // CHECK-NEXT: entry:793  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8794  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4795  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8796  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4797  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4798  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8799  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1800  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32801  // CHECK-NEXT: %[[SRC:.*]] = mul nsw i32 %[[LHSEXT]], %[[RHS]]802  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8803  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize804  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize805  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize806  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize807  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:808  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize809  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize810  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize811  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize812  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize813  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize814  // CHECK-SANITIZE: [[CONT]]:815  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1816  // CHECK-NEXT: ret void817  // CHECK-NEXT: }818#line 2400819  (*LHS) *= RHS;820}821 822//----------------------------------------------------------------------------//823// Compound divide operator.                                                  //824//----------------------------------------------------------------------------//825 826// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_char827void unsigned_char_div_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {828  // CHECK: {829  // CHECK-NEXT: entry:830  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8831  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1832  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8833  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1834  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1835  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32836  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8837  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1838  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32839  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]840  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8841  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize842  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize843  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize844  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:845  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize846  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize847  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize848  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize849  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize850  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize851  // CHECK-SANITIZE: [[CONT]]:852  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1853  // CHECK-NEXT: ret void854  // CHECK-NEXT: }855#line 2500856  (*LHS) /= RHS;857}858 859// CHECK-LABEL: @unsigned_char_div_signed_char_signed_char860void unsigned_char_div_signed_char_signed_char(unsigned char *LHS, signed char RHS) {861  // CHECK: {862  // CHECK-NEXT: entry:863  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8864  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1865  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8866  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1867  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1868  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32869  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8870  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1871  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32872  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]873  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8874  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize875  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize876  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize877  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:878  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize879  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize880  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize881  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize882  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize883  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize884  // CHECK-SANITIZE: [[CONT]]:885  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1886  // CHECK-NEXT: ret void887  // CHECK-NEXT: }888#line 2600889  (*LHS) /= RHS;890}891 892// CHECK-LABEL: @unsigned_char_div_signed_char_unsigned_int893void unsigned_char_div_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {894#line 2700895  (*LHS) /= RHS;896}897 898// CHECK-LABEL: @unsigned_char_div_signed_char_signed_int899void unsigned_char_div_signed_char_signed_int(unsigned char *LHS, signed int RHS) {900  // CHECK: {901  // CHECK-NEXT: entry:902  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8903  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 4904  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8905  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 4906  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 4907  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8908  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1909  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i32910  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]911  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8912  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize913  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize914  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize915  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:916  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize917  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize918  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize919  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize920  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize921  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize922  // CHECK-SANITIZE: [[CONT]]:923  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1924  // CHECK-NEXT: ret void925  // CHECK-NEXT: }926#line 2800927  (*LHS) /= RHS;928}929 930// CHECK-LABEL: @signed_char_div_unsigned_char931void signed_char_div_unsigned_char(signed char *LHS, unsigned char RHS) {932  // CHECK: {933  // CHECK-NEXT: entry:934  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8935  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1936  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8937  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1938  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1939  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i32940  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8941  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1942  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32943  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]944  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8945  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize946  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize947  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize948  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize949  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:950  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize951  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize952  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_2900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize953  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_2900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize954  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize955  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize956  // CHECK-SANITIZE: [[CONT]]:957  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1958  // CHECK-NEXT: ret void959  // CHECK-NEXT: }960#line 2900961  (*LHS) /= RHS;962}963 964// CHECK-LABEL: @signed_char_div_signed_char965void signed_char_div_signed_char(signed char *LHS, signed char RHS) {966  // CHECK: {967  // CHECK-NEXT: entry:968  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 8969  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 1970  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 8971  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 1972  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 1973  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i32974  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 8975  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 1976  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i32977  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHSEXT]]978  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i8979  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize980  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize981  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize982  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize983  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:984  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize985  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize986  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize987  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize988  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize989  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize990  // CHECK-SANITIZE: [[CONT]]:991  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 1992  // CHECK-NEXT: ret void993  // CHECK-NEXT: }994#line 3000995  (*LHS) /= RHS;996}997 998// CHECK-LABEL: @signed_char_div_signed_char_unsigned_int999void signed_char_div_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1000  // CHECK: {1001  // CHECK-NEXT: entry:1002  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81003  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41004  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81005  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41006  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41007  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81008  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11009  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321010  // CHECK-NEXT: %[[SRC:.*]] = udiv i32 %[[LHSEXT]], %[[RHS]]1011  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81012  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1013  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize1014  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1015  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1016  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1017  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1018  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1019  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1020  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1021  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1022  // CHECK-SANITIZE: [[CONT]]:1023  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11024  // CHECK-NEXT: ret void1025  // CHECK-NEXT: }1026#line 31001027  (*LHS) /= RHS;1028}1029 1030// CHECK-LABEL: @signed_char_div_signed_char_signed_int1031void signed_char_div_signed_char_signed_int(signed char *LHS, signed int RHS) {1032  // CHECK: {1033  // CHECK-NEXT: entry:1034  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81035  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41036  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81037  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41038  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41039  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81040  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11041  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321042  // CHECK-NEXT: %[[SRC:.*]] = sdiv i32 %[[LHSEXT]], %[[RHS]]1043  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81044  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1045  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1046  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1047  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1048  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1049  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1050  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1051  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1052  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1053  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1054  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1055  // CHECK-SANITIZE: [[CONT]]:1056  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11057  // CHECK-NEXT: ret void1058  // CHECK-NEXT: }1059#line 32001060  (*LHS) /= RHS;1061}1062 1063//----------------------------------------------------------------------------//1064// Compound remainder operator.                                               //1065//----------------------------------------------------------------------------//1066 1067// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_char1068void unsigned_char_rem_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1069  // CHECK: {1070  // CHECK-NEXT: entry:1071  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81072  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11073  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81074  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11075  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11076  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321077  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81078  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11079  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321080  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1081  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81082  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1083  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1084  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1085  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1086  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1087  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1088  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1089  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1090  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1091  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1092  // CHECK-SANITIZE: [[CONT]]:1093  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11094  // CHECK-NEXT: ret void1095  // CHECK-NEXT: }1096#line 33001097  (*LHS) %= RHS;1098}1099 1100// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_char1101void unsigned_char_rem_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1102  // CHECK: {1103  // CHECK-NEXT: entry:1104  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81105  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11106  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81107  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11108  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11109  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321110  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81111  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11112  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321113  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1114  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81115  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1116  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1117  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1118  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1119  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1120  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1121  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1122  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1123  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1124  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1125  // CHECK-SANITIZE: [[CONT]]:1126  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11127  // CHECK-NEXT: ret void1128  // CHECK-NEXT: }1129#line 34001130  (*LHS) %= RHS;1131}1132 1133// CHECK-LABEL: @unsigned_char_rem_signed_char_unsigned_int1134void unsigned_char_rem_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1135#line 35001136  (*LHS) %= RHS;1137}1138 1139// CHECK-LABEL: @unsigned_char_rem_signed_char_signed_int1140void unsigned_char_rem_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1141  // CHECK: {1142  // CHECK-NEXT: entry:1143  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81144  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41145  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81146  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41147  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41148  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81149  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11150  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321151  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]1152  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81153  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1154  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1155  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1156  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1157  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1158  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1159  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1160  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1161  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1162  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1163  // CHECK-SANITIZE: [[CONT]]:1164  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11165  // CHECK-NEXT: ret void1166  // CHECK-NEXT: }1167#line 36001168  (*LHS) %= RHS;1169}1170 1171// CHECK-LABEL: @signed_char_rem_unsigned_char1172void signed_char_rem_unsigned_char(signed char *LHS, unsigned char RHS) {1173  // CHECK: {1174  // CHECK-NEXT: entry:1175  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81176  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11177  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81178  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11179  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11180  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321181  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81182  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11183  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321184  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1185  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81186  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1187  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1188  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1189  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1190  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1191  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1192  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1193  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1194  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1195  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1196  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1197  // CHECK-SANITIZE: [[CONT]]:1198  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11199  // CHECK-NEXT: ret void1200  // CHECK-NEXT: }1201#line 37001202  (*LHS) %= RHS;1203}1204 1205// CHECK-LABEL: @signed_char_rem_signed_char1206void signed_char_rem_signed_char(signed char *LHS, signed char RHS) {1207  // CHECK: {1208  // CHECK-NEXT: entry:1209  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81210  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11211  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81212  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11213  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11214  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321215  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81216  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11217  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321218  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHSEXT]]1219  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81220  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1221  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1222  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1223  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1224  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1225  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1226  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1227  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1228  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1229  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1230  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1231  // CHECK-SANITIZE: [[CONT]]:1232  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11233  // CHECK-NEXT: ret void1234  // CHECK-NEXT: }1235#line 38001236  (*LHS) %= RHS;1237}1238 1239// CHECK-LABEL: @signed_char_rem_signed_char_unsigned_int1240void signed_char_rem_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1241  // CHECK: {1242  // CHECK-NEXT: entry:1243  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81244  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41245  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81246  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41247  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41248  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81249  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11250  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321251  // CHECK-NEXT: %[[SRC:.*]] = urem i32 %[[LHSEXT]], %[[RHS]]1252  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81253  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1254  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize1255  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1256  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1257  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1258  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1259  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_3900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1260  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_3900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1261  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1262  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1263  // CHECK-SANITIZE: [[CONT]]:1264  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11265  // CHECK-NEXT: ret void1266  // CHECK-NEXT: }1267#line 39001268  (*LHS) %= RHS;1269}1270 1271// CHECK-LABEL: @signed_char_rem_signed_char_signed_int1272void signed_char_rem_signed_char_signed_int(signed char *LHS, signed int RHS) {1273  // CHECK: {1274  // CHECK-NEXT: entry:1275  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81276  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41277  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81278  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41279  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41280  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81281  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11282  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321283  // CHECK-NEXT: %[[SRC:.*]] = srem i32 %[[LHSEXT]], %[[RHS]]1284  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81285  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1286  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1287  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1288  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1289  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1290  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1291  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1292  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1293  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1294  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1295  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1296  // CHECK-SANITIZE: [[CONT]]:1297  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11298  // CHECK-NEXT: ret void1299  // CHECK-NEXT: }1300#line 40001301  (*LHS) %= RHS;1302}1303 1304//----------------------------------------------------------------------------//1305// Compound left-shift operator.                                              //1306//----------------------------------------------------------------------------//1307 1308// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_char1309void unsigned_char_shl_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1310  // CHECK: {1311  // CHECK-NEXT: entry:1312  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81313  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11314  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81315  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11316  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11317  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321318  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81319  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11320  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321321  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1322  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81323  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1324  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1325  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1326  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1327  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1328  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1329  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1330  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1331  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1332  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1333  // CHECK-SANITIZE: [[CONT]]:1334  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11335  // CHECK-NEXT: ret void1336  // CHECK-NEXT: }1337#line 41001338  (*LHS) <<= RHS;1339}1340 1341// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_char1342void unsigned_char_shl_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1343  // CHECK: {1344  // CHECK-NEXT: entry:1345  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81346  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11347  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81348  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11349  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11350  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321351  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81352  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11353  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321354  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1355  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81356  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1357  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1358  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1359  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1360  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1361  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1362  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1363  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1364  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1365  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1366  // CHECK-SANITIZE: [[CONT]]:1367  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11368  // CHECK-NEXT: ret void1369  // CHECK-NEXT: }1370#line 42001371  (*LHS) <<= RHS;1372}1373 1374// CHECK-LABEL: @unsigned_char_shl_signed_char_unsigned_int1375void unsigned_char_shl_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1376  // CHECK: {1377  // CHECK-NEXT: entry:1378  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81379  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41380  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81381  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41382  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41383  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81384  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11385  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321386  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1387  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81388  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1389  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1390  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1391  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1392  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1393  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1394  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1395  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1396  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1397  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1398  // CHECK-SANITIZE: [[CONT]]:1399  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11400  // CHECK-NEXT: ret void1401  // CHECK-NEXT: }1402#line 43001403  (*LHS) <<= RHS;1404}1405 1406// CHECK-LABEL: @unsigned_char_shl_signed_char_signed_int1407void unsigned_char_shl_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1408  // CHECK: {1409  // CHECK-NEXT: entry:1410  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81411  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41412  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81413  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41414  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41415  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81416  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11417  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321418  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1419  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81420  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1421  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1422  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1423  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1424  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1425  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1426  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1427  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1428  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1429  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1430  // CHECK-SANITIZE: [[CONT]]:1431  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11432  // CHECK-NEXT: ret void1433  // CHECK-NEXT: }1434#line 44001435  (*LHS) <<= RHS;1436}1437 1438// CHECK-LABEL: @signed_char_shl_unsigned_char1439void signed_char_shl_unsigned_char(signed char *LHS, unsigned char RHS) {1440  // CHECK: {1441  // CHECK-NEXT: entry:1442  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81443  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11444  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81445  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11446  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11447  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321448  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81449  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11450  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321451  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1452  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81453  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1454  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1455  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1456  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1457  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1458  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1459  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1460  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1461  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1462  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1463  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1464  // CHECK-SANITIZE: [[CONT]]:1465  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11466  // CHECK-NEXT: ret void1467  // CHECK-NEXT: }1468#line 45001469  (*LHS) <<= RHS;1470}1471 1472// CHECK-LABEL: @signed_char_shl_signed_char1473void signed_char_shl_signed_char(signed char *LHS, signed char RHS) {1474  // CHECK: {1475  // CHECK-NEXT: entry:1476  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81477  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11478  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81479  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11480  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11481  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321482  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81483  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11484  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321485  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHSEXT]]1486  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81487  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1488  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1489  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1490  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1491  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1492  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1493  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1494  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1495  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1496  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1497  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1498  // CHECK-SANITIZE: [[CONT]]:1499  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11500  // CHECK-NEXT: ret void1501  // CHECK-NEXT: }1502#line 46001503  (*LHS) <<= RHS;1504}1505 1506// CHECK-LABEL: @signed_char_shl_signed_char_unsigned_int1507void signed_char_shl_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1508  // CHECK: {1509  // CHECK-NEXT: entry:1510  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81511  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41512  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81513  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41514  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41515  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81516  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11517  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321518  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1519  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81520  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1521  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1522  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1523  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1524  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1525  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1526  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1527  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1528  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1529  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1530  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1531  // CHECK-SANITIZE: [[CONT]]:1532  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11533  // CHECK-NEXT: ret void1534  // CHECK-NEXT: }1535#line 47001536  (*LHS) <<= RHS;1537}1538 1539// CHECK-LABEL: @signed_char_shl_signed_char_signed_int1540void signed_char_shl_signed_char_signed_int(signed char *LHS, signed int RHS) {1541  // CHECK: {1542  // CHECK-NEXT: entry:1543  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81544  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41545  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81546  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41547  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41548  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81549  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11550  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321551  // CHECK-NEXT: %[[SRC:.*]] = shl i32 %[[LHSEXT]], %[[RHS]]1552  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81553  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1554  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1555  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1556  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1557  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1558  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1559  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1560  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1561  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1562  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1563  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1564  // CHECK-SANITIZE: [[CONT]]:1565  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11566  // CHECK-NEXT: ret void1567  // CHECK-NEXT: }1568#line 48001569  (*LHS) <<= RHS;1570}1571 1572//----------------------------------------------------------------------------//1573// Compound right-shift operator.                                             //1574//----------------------------------------------------------------------------//1575 1576// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_char1577void unsigned_char_shr_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1578  // CHECK: {1579  // CHECK-NEXT: entry:1580  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81581  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11582  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81583  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11584  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11585  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321586  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81587  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11588  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321589  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1590  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81591  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1592  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1593  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1594  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1595  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1596  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1597  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_4900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1598  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_4900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1599  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1600  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1601  // CHECK-SANITIZE: [[CONT]]:1602  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11603  // CHECK-NEXT: ret void1604  // CHECK-NEXT: }1605#line 49001606  (*LHS) >>= RHS;1607}1608 1609// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_char1610void unsigned_char_shr_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1611  // CHECK: {1612  // CHECK-NEXT: entry:1613  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81614  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11615  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81616  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11617  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11618  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321619  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81620  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11621  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321622  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1623  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81624  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1625  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1626  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1627  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1628  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1629  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1630  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1631  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1632  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1633  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1634  // CHECK-SANITIZE: [[CONT]]:1635  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11636  // CHECK-NEXT: ret void1637  // CHECK-NEXT: }1638#line 50001639  (*LHS) >>= RHS;1640}1641 1642// CHECK-LABEL: @unsigned_char_shr_signed_char_unsigned_int1643void unsigned_char_shr_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1644  // CHECK: {1645  // CHECK-NEXT: entry:1646  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81647  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41648  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81649  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41650  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41651  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81652  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11653  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321654  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1655  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81656  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1657  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1658  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1659  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1660  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1661  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1662  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1663  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1664  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1665  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1666  // CHECK-SANITIZE: [[CONT]]:1667  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11668  // CHECK-NEXT: ret void1669  // CHECK-NEXT: }1670#line 51001671  (*LHS) >>= RHS;1672}1673 1674// CHECK-LABEL: @unsigned_char_shr_signed_char_signed_int1675void unsigned_char_shr_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1676  // CHECK: {1677  // CHECK-NEXT: entry:1678  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81679  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41680  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81681  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41682  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41683  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81684  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11685  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321686  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1687  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81688  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1689  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1690  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1691  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1692  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1693  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1694  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1695  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1696  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1697  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1698  // CHECK-SANITIZE: [[CONT]]:1699  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11700  // CHECK-NEXT: ret void1701  // CHECK-NEXT: }1702#line 52001703  (*LHS) >>= RHS;1704}1705 1706// CHECK-LABEL: @signed_char_shr_unsigned_char1707void signed_char_shr_unsigned_char(signed char *LHS, unsigned char RHS) {1708  // CHECK: {1709  // CHECK-NEXT: entry:1710  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81711  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11712  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81713  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11714  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11715  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321716  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81717  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11718  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321719  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1720  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81721  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1722  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1723  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1724  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1725  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1726  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1727  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1728  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1729  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1730  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1731  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1732  // CHECK-SANITIZE: [[CONT]]:1733  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11734  // CHECK-NEXT: ret void1735  // CHECK-NEXT: }1736#line 53001737  (*LHS) >>= RHS;1738}1739 1740// CHECK-LABEL: @signed_char_shr_signed_char1741void signed_char_shr_signed_char(signed char *LHS, signed char RHS) {1742  // CHECK: {1743  // CHECK-NEXT: entry:1744  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81745  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11746  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81747  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11748  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11749  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321750  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81751  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11752  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321753  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHSEXT]]1754  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81755  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1756  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1757  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1758  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1759  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1760  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1761  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1762  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1763  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1764  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1765  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1766  // CHECK-SANITIZE: [[CONT]]:1767  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11768  // CHECK-NEXT: ret void1769  // CHECK-NEXT: }1770#line 54001771  (*LHS) >>= RHS;1772}1773 1774// CHECK-LABEL: @signed_char_shr_signed_char_unsigned_int1775void signed_char_shr_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {1776  // CHECK: {1777  // CHECK-NEXT: entry:1778  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81779  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41780  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81781  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41782  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41783  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81784  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11785  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321786  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1787  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81788  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1789  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1790  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1791  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1792  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1793  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1794  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1795  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1796  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1797  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1798  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1799  // CHECK-SANITIZE: [[CONT]]:1800  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11801  // CHECK-NEXT: ret void1802  // CHECK-NEXT: }1803#line 55001804  (*LHS) >>= RHS;1805}1806 1807// CHECK-LABEL: @signed_char_shr_signed_char_signed_int1808void signed_char_shr_signed_char_signed_int(signed char *LHS, signed int RHS) {1809  // CHECK: {1810  // CHECK-NEXT: entry:1811  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81812  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41813  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81814  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41815  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41816  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81817  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11818  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321819  // CHECK-NEXT: %[[SRC:.*]] = ashr i32 %[[LHSEXT]], %[[RHS]]1820  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81821  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1822  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1823  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1824  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1825  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1826  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1827  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1828  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1829  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1830  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1831  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1832  // CHECK-SANITIZE: [[CONT]]:1833  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11834  // CHECK-NEXT: ret void1835  // CHECK-NEXT: }1836#line 56001837  (*LHS) >>= RHS;1838}1839 1840//----------------------------------------------------------------------------//1841// Compound and operator.                                                     //1842//----------------------------------------------------------------------------//1843 1844// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_char1845void unsigned_char_and_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {1846  // CHECK: {1847  // CHECK-NEXT: entry:1848  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81849  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11850  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81851  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11852  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11853  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321854  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81855  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11856  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321857  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1858  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81859  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1860  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1861  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1862  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1863  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1864  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1865  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1866  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1867  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1868  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1869  // CHECK-SANITIZE: [[CONT]]:1870  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11871  // CHECK-NEXT: ret void1872  // CHECK-NEXT: }1873#line 57001874  (*LHS) &= RHS;1875}1876 1877// CHECK-LABEL: @unsigned_char_and_signed_char_signed_char1878void unsigned_char_and_signed_char_signed_char(unsigned char *LHS, signed char RHS) {1879  // CHECK: {1880  // CHECK-NEXT: entry:1881  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81882  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11883  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81884  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11885  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11886  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321887  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81888  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11889  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321890  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1891  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81892  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1893  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1894  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1895  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1896  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1897  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1898  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_5800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1899  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_5800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1900  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1901  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1902  // CHECK-SANITIZE: [[CONT]]:1903  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11904  // CHECK-NEXT: ret void1905  // CHECK-NEXT: }1906#line 58001907  (*LHS) &= RHS;1908}1909 1910// CHECK-LABEL: @unsigned_char_and_signed_char_unsigned_int1911void unsigned_char_and_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {1912#line 59001913  (*LHS) &= RHS;1914}1915 1916// CHECK-LABEL: @unsigned_char_and_signed_char_signed_int1917void unsigned_char_and_signed_char_signed_int(unsigned char *LHS, signed int RHS) {1918  // CHECK: {1919  // CHECK-NEXT: entry:1920  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81921  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 41922  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81923  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 41924  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 41925  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81926  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11927  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i321928  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]1929  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81930  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1931  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize1932  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1933  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1934  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1935  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1936  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1937  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1938  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1939  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1940  // CHECK-SANITIZE: [[CONT]]:1941  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11942  // CHECK-NEXT: ret void1943  // CHECK-NEXT: }1944#line 60001945  (*LHS) &= RHS;1946}1947 1948// CHECK-LABEL: @signed_char_and_unsigned_char1949void signed_char_and_unsigned_char(signed char *LHS, unsigned char RHS) {1950  // CHECK: {1951  // CHECK-NEXT: entry:1952  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81953  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11954  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81955  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11956  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11957  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i321958  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81959  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11960  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321961  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1962  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81963  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1964  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1965  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize1966  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize1967  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:1968  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize1969  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize1970  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1971  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize1972  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize1973  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize1974  // CHECK-SANITIZE: [[CONT]]:1975  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 11976  // CHECK-NEXT: ret void1977  // CHECK-NEXT: }1978#line 61001979  (*LHS) &= RHS;1980}1981 1982// CHECK-LABEL: @signed_char_and_signed_char1983void signed_char_and_signed_char(signed char *LHS, signed char RHS) {1984  // CHECK: {1985  // CHECK-NEXT: entry:1986  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 81987  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 11988  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 81989  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 11990  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 11991  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i321992  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 81993  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 11994  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i321995  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHSEXT]]1996  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i81997  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize1998  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize1999  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2000  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2001  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2002  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2003  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2004  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2005  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2006  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2007  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2008  // CHECK-SANITIZE: [[CONT]]:2009  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12010  // CHECK-NEXT: ret void2011  // CHECK-NEXT: }2012#line 62002013  (*LHS) &= RHS;2014}2015 2016// CHECK-LABEL: @signed_char_and_signed_char_unsigned_int2017void signed_char_and_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2018  // CHECK: {2019  // CHECK-NEXT: entry:2020  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82021  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42022  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82023  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42024  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42025  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82026  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12027  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322028  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2029  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82030  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2031  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize2032  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2033  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2034  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2035  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2036  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2037  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2038  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2039  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2040  // CHECK-SANITIZE: [[CONT]]:2041  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12042  // CHECK-NEXT: ret void2043  // CHECK-NEXT: }2044#line 63002045  (*LHS) &= RHS;2046}2047 2048// CHECK-LABEL: @signed_char_and_signed_char_signed_int2049void signed_char_and_signed_char_signed_int(signed char *LHS, signed int RHS) {2050  // CHECK: {2051  // CHECK-NEXT: entry:2052  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82053  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42054  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82055  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42056  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42057  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82058  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12059  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322060  // CHECK-NEXT: %[[SRC:.*]] = and i32 %[[LHSEXT]], %[[RHS]]2061  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82062  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2063  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2064  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2065  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2066  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2067  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2068  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2069  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2070  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2071  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2072  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2073  // CHECK-SANITIZE: [[CONT]]:2074  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12075  // CHECK-NEXT: ret void2076  // CHECK-NEXT: }2077#line 64002078  (*LHS) &= RHS;2079}2080 2081//----------------------------------------------------------------------------//2082// Compound xor operator.                                                     //2083//----------------------------------------------------------------------------//2084 2085// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_char2086void unsigned_char_or_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {2087  // CHECK: {2088  // CHECK-NEXT: entry:2089  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82090  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12091  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82092  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12093  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12094  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322095  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82096  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12097  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322098  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2099  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82100  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2101  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize2102  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2103  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2104  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2105  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2106  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2107  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6500_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2108  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2109  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2110  // CHECK-SANITIZE: [[CONT]]:2111  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12112  // CHECK-NEXT: ret void2113  // CHECK-NEXT: }2114#line 65002115  (*LHS) |= RHS;2116}2117 2118// CHECK-LABEL: @unsigned_char_or_signed_char_signed_char2119void unsigned_char_or_signed_char_signed_char(unsigned char *LHS, signed char RHS) {2120  // CHECK: {2121  // CHECK-NEXT: entry:2122  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82123  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12124  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82125  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12126  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12127  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322128  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82129  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12130  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322131  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2132  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82133  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2134  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize2135  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2136  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2137  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2138  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2139  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2140  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2141  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2142  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2143  // CHECK-SANITIZE: [[CONT]]:2144  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12145  // CHECK-NEXT: ret void2146  // CHECK-NEXT: }2147#line 66002148  (*LHS) |= RHS;2149}2150 2151// CHECK-LABEL: @unsigned_char_or_signed_char_unsigned_int2152void unsigned_char_or_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {2153#line 67002154  (*LHS) |= RHS;2155}2156 2157// CHECK-LABEL: @unsigned_char_or_signed_char_signed_int2158void unsigned_char_or_signed_char_signed_int(unsigned char *LHS, signed int RHS) {2159  // CHECK: {2160  // CHECK-NEXT: entry:2161  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82162  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42163  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82164  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42165  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42166  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82167  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12168  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322169  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2170  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82171  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2172  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize2173  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2174  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2175  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2176  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2177  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2178  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2179  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2180  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2181  // CHECK-SANITIZE: [[CONT]]:2182  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12183  // CHECK-NEXT: ret void2184  // CHECK-NEXT: }2185#line 68002186  (*LHS) |= RHS;2187}2188 2189// CHECK-LABEL: @signed_char_or_unsigned_char2190void signed_char_or_unsigned_char(signed char *LHS, unsigned char RHS) {2191  // CHECK: {2192  // CHECK-NEXT: entry:2193  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82194  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12195  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82196  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12197  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12198  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322199  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82200  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12201  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322202  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2203  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82204  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2205  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2206  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2207  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2208  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2209  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2210  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2211  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_6900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2212  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_6900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2213  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2214  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2215  // CHECK-SANITIZE: [[CONT]]:2216  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12217  // CHECK-NEXT: ret void2218  // CHECK-NEXT: }2219#line 69002220  (*LHS) |= RHS;2221}2222 2223// CHECK-LABEL: @signed_char_or_signed_char2224void signed_char_or_signed_char(signed char *LHS, signed 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:.*]] = sext 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:.*]] = sext i8 %[[LHS]] to i322236  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHSEXT]]2237  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82238  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2239  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2240  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2241  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2242  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2243  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2244  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2245  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2246  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2247  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2248  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2249  // CHECK-SANITIZE: [[CONT]]:2250  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12251  // CHECK-NEXT: ret void2252  // CHECK-NEXT: }2253#line 70002254  (*LHS) |= RHS;2255}2256 2257// CHECK-LABEL: @signed_char_or_signed_char_unsigned_int2258void signed_char_or_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2259  // CHECK: {2260  // CHECK-NEXT: entry:2261  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82262  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42263  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82264  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42265  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42266  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82267  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12268  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322269  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2270  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82271  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2272  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize2273  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], 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_7100_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2278  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7100_SIGN_CHANGE]], 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 71002286  (*LHS) |= RHS;2287}2288 2289// CHECK-LABEL: @signed_char_or_signed_char_signed_int2290void signed_char_or_signed_char_signed_int(signed char *LHS, signed 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:.*]] = sext i8 %[[LHS]] to i322301  // CHECK-NEXT: %[[SRC:.*]] = or i32 %[[LHSEXT]], %[[RHS]]2302  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82303  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2304  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2305  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2306  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2307  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2308  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2309  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2310  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2311  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7200_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2312  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2313  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2314  // CHECK-SANITIZE: [[CONT]]:2315  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12316  // CHECK-NEXT: ret void2317  // CHECK-NEXT: }2318#line 72002319  (*LHS) |= RHS;2320}2321 2322//----------------------------------------------------------------------------//2323// Compound or operator.                                                      //2324//----------------------------------------------------------------------------//2325 2326// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_char2327void unsigned_char_xor_signed_char_unsigned_char(unsigned char *LHS, unsigned char RHS) {2328  // CHECK: {2329  // CHECK-NEXT: entry:2330  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82331  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12332  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82333  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12334  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12335  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322336  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82337  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12338  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322339  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2340  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82341  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2342  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize2343  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2344  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2345  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2346  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2347  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2348  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7300_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2349  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2350  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2351  // CHECK-SANITIZE: [[CONT]]:2352  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12353  // CHECK-NEXT: ret void2354  // CHECK-NEXT: }2355#line 73002356  (*LHS) ^= RHS;2357}2358 2359// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_char2360void unsigned_char_xor_signed_char_signed_char(unsigned char *LHS, signed char RHS) {2361  // CHECK: {2362  // CHECK-NEXT: entry:2363  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82364  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12365  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82366  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12367  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12368  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322369  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82370  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12371  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322372  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2373  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82374  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2375  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize2376  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2377  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2378  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2379  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2380  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2381  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7400_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2382  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2383  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2384  // CHECK-SANITIZE: [[CONT]]:2385  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12386  // CHECK-NEXT: ret void2387  // CHECK-NEXT: }2388#line 74002389  (*LHS) ^= RHS;2390}2391 2392// CHECK-LABEL: @unsigned_char_xor_signed_char_unsigned_int2393void unsigned_char_xor_signed_char_unsigned_int(unsigned char *LHS, unsigned int RHS) {2394#line 75002395  (*LHS) ^= RHS;2396}2397 2398// CHECK-LABEL: @unsigned_char_xor_signed_char_signed_int2399void unsigned_char_xor_signed_char_signed_int(unsigned char *LHS, signed int RHS) {2400  // CHECK: {2401  // CHECK-NEXT: entry:2402  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82403  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42404  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82405  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42406  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42407  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82408  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12409  // CHECK-NEXT: %[[LHSEXT:.*]] = zext i8 %[[LHS]] to i322410  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2411  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82412  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2413  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize2414  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2415  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2416  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2417  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2418  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2419  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7600_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2420  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2421  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2422  // CHECK-SANITIZE: [[CONT]]:2423  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12424  // CHECK-NEXT: ret void2425  // CHECK-NEXT: }2426#line 76002427  (*LHS) ^= RHS;2428}2429 2430// CHECK-LABEL: @signed_char_xor_unsigned_char2431void signed_char_xor_unsigned_char(signed char *LHS, unsigned char RHS) {2432  // CHECK: {2433  // CHECK-NEXT: entry:2434  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82435  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12436  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82437  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12438  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12439  // CHECK-NEXT: %[[RHSEXT:.*]] = zext i8 %[[RHS]] to i322440  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82441  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12442  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322443  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2444  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82445  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2446  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2447  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2448  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2449  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2450  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2451  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2452  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2453  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7700_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2454  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2455  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2456  // CHECK-SANITIZE: [[CONT]]:2457  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12458  // CHECK-NEXT: ret void2459  // CHECK-NEXT: }2460#line 77002461  (*LHS) ^= RHS;2462}2463 2464// CHECK-LABEL: @signed_char_xor_signed_char2465void signed_char_xor_signed_char(signed char *LHS, signed char RHS) {2466  // CHECK: {2467  // CHECK-NEXT: entry:2468  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82469  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i8, align 12470  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82471  // CHECK-NEXT: store i8 %[[ARG1:.*]], ptr %[[RHSADDR]], align 12472  // CHECK-NEXT: %[[RHS:.*]] = load i8, ptr %[[RHSADDR]], align 12473  // CHECK-NEXT: %[[RHSEXT:.*]] = sext i8 %[[RHS]] to i322474  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82475  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12476  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322477  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHSEXT]]2478  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82479  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2480  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2481  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2482  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2483  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2484  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2485  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2486  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2487  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7800_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2488  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2489  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2490  // CHECK-SANITIZE: [[CONT]]:2491  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12492  // CHECK-NEXT: ret void2493  // CHECK-NEXT: }2494#line 78002495  (*LHS) ^= RHS;2496}2497 2498// CHECK-LABEL: @signed_char_xor_signed_char_unsigned_int2499void signed_char_xor_signed_char_unsigned_int(signed char *LHS, unsigned int RHS) {2500  // CHECK: {2501  // CHECK-NEXT: entry:2502  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82503  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42504  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82505  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42506  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42507  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82508  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12509  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322510  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2511  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82512  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2513  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize2514  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2515  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2516  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2517  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2518  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_7900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2519  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_7900_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2520  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2521  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2522  // CHECK-SANITIZE: [[CONT]]:2523  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12524  // CHECK-NEXT: ret void2525  // CHECK-NEXT: }2526#line 79002527  (*LHS) ^= RHS;2528}2529 2530// CHECK-LABEL: @signed_char_xor_signed_char_signed_int2531void signed_char_xor_signed_char_signed_int(signed char *LHS, signed int RHS) {2532  // CHECK: {2533  // CHECK-NEXT: entry:2534  // CHECK-NEXT: %[[ADDRESS:.*]] = alloca ptr, align 82535  // CHECK-NEXT: %[[RHSADDR:.*]] = alloca i32, align 42536  // CHECK-NEXT: store ptr %[[ARG0:.*]], ptr %[[ADDRESS]], align 82537  // CHECK-NEXT: store i32 %[[ARG1:.*]], ptr %[[RHSADDR]], align 42538  // CHECK-NEXT: %[[RHS:.*]] = load i32, ptr %[[RHSADDR]], align 42539  // CHECK-NEXT: %[[LHSADDR:.*]] = load ptr, ptr %[[ADDRESS]], align 82540  // CHECK-NEXT: %[[LHS:.*]] = load i8, ptr %[[LHSADDR]], align 12541  // CHECK-NEXT: %[[LHSEXT:.*]] = sext i8 %[[LHS]] to i322542  // CHECK-NEXT: %[[SRC:.*]] = xor i32 %[[LHSEXT]], %[[RHS]]2543  // CHECK-NEXT: %[[DST:.*]] = trunc i32 %[[SRC]] to i82544  // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i32 %[[SRC]], 0, !nosanitize2545  // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize2546  // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], %[[DST_NEGATIVITYCHECK]], !nosanitize2547  // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize2548  // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:2549  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i32 %[[SRC]] to i64, !nosanitize2550  // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize2551  // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(ptr @[[LINE_8000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2552  // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(ptr @[[LINE_8000_SIGN_CHANGE]], i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize2553  // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize2554  // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize2555  // CHECK-SANITIZE: [[CONT]]:2556  // CHECK-NEXT: store i8 %[[DST]], ptr %[[LHSADDR]], align 12557  // CHECK-NEXT: ret void2558  // CHECK-NEXT: }2559#line 80002560  (*LHS) ^= RHS;2561}2562