1// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp=libiomp5 -x c -emit-llvm %s -o - | FileCheck %s 2// RUN: %clang_cc1 -fopenmp=libiomp5 -x c -triple x86_64-apple-darwin10 -emit-pch -o %t %s 3// RUN: %clang_cc1 -fopenmp=libiomp5 -x c -triple x86_64-apple-darwin10 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s 4// expected-no-diagnostics 5 6#ifndef HEADER 7#define HEADER 8 9_Bool bv, bx; 10char cv, cx; 11unsigned char ucv, ucx; 12short sv, sx; 13unsigned short usv, usx; 14int iv, ix; 15unsigned int uiv, uix; 16long lv, lx; 17unsigned long ulv, ulx; 18long long llv, llx; 19unsigned long long ullv, ullx; 20float fv, fx; 21double dv, dx; 22long double ldv, ldx; 23_Complex int civ, cix; 24_Complex float cfv, cfx; 25_Complex double cdv, cdx; 26 27typedef int int4 __attribute__((__vector_size__(16))); 28int4 int4x; 29 30struct BitFields { 31 int : 32; 32 int a : 31; 33} bfx; 34 35struct BitFields_packed { 36 int : 32; 37 int a : 31; 38} __attribute__ ((__packed__)) bfx_packed; 39 40struct BitFields2 { 41 int : 31; 42 int a : 1; 43} bfx2; 44 45struct BitFields2_packed { 46 int : 31; 47 int a : 1; 48} __attribute__ ((__packed__)) bfx2_packed; 49 50struct BitFields3 { 51 int : 11; 52 int a : 14; 53} bfx3; 54 55struct BitFields3_packed { 56 int : 11; 57 int a : 14; 58} __attribute__ ((__packed__)) bfx3_packed; 59 60struct BitFields4 { 61 short : 16; 62 int a: 1; 63 long b : 7; 64} bfx4; 65 66struct BitFields4_packed { 67 short : 16; 68 int a: 1; 69 long b : 7; 70} __attribute__ ((__packed__)) bfx4_packed; 71 72typedef float float2 __attribute__((ext_vector_type(2))); 73float2 float2x; 74 75register int rix __asm__("0"); 76 77int main() { 78// CHECK: atomicrmw add i8* @{{.+}}, i8 1 monotonic 79#pragma omp atomic 80 bx++; 81// CHECK: atomicrmw add i8* @{{.+}}, i8 1 monotonic 82#pragma omp atomic update 83 ++cx; 84// CHECK: atomicrmw sub i8* @{{.+}}, i8 1 monotonic 85#pragma omp atomic 86 ucx--; 87// CHECK: atomicrmw sub i16* @{{.+}}, i16 1 monotonic 88#pragma omp atomic update 89 --sx; 90// CHECK: [[USV:%.+]] = load i16, i16* @{{.+}}, 91// CHECK: [[EXPR:%.+]] = zext i16 [[USV]] to i32 92// CHECK: [[X:%.+]] = load atomic i16, i16* [[X_ADDR:@.+]] monotonic 93// CHECK: br label %[[CONT:.+]] 94// CHECK: [[CONT]] 95// CHECK: [[EXPECTED:%.+]] = phi i16 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 96// CHECK: [[CONV:%.+]] = zext i16 [[EXPECTED]] to i32 97// CHECK: [[ADD:%.+]] = add nsw i32 [[CONV]], [[EXPR]] 98// CHECK: [[DESIRED:%.+]] = trunc i32 [[ADD]] to i16 99// CHECK: [[RES:%.+]] = cmpxchg i16* [[X_ADDR]], i16 [[EXPECTED]], i16 [[DESIRED]] monotonic monotonic 100// CHECK: [[OLD_X]] = extractvalue { i16, i1 } [[RES]], 0 101// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i16, i1 } [[RES]], 1 102// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 103// CHECK: [[EXIT]] 104#pragma omp atomic 105 usx += usv; 106// CHECK: [[EXPR:%.+]] = load i32, i32* @{{.+}}, 107// CHECK: [[X:%.+]] = load atomic i32, i32* [[X_ADDR:@.+]] monotonic 108// CHECK: br label %[[CONT:.+]] 109// CHECK: [[CONT]] 110// CHECK: [[EXPECTED:%.+]] = phi i32 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 111// CHECK: [[DESIRED:%.+]] = mul nsw i32 [[EXPECTED]], [[EXPR]] 112// CHECK: [[RES:%.+]] = cmpxchg i32* [[X_ADDR]], i32 [[EXPECTED]], i32 [[DESIRED]] monotonic monotonic 113// CHECK: [[OLD_X]] = extractvalue { i32, i1 } [[RES]], 0 114// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i32, i1 } [[RES]], 1 115// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 116// CHECK: [[EXIT]] 117#pragma omp atomic update 118 ix *= iv; 119// CHECK: [[EXPR:%.+]] = load i32, i32* @{{.+}}, 120// CHECK: atomicrmw sub i32* @{{.+}}, i32 [[EXPR]] monotonic 121#pragma omp atomic 122 uix -= uiv; 123// CHECK: [[EXPR:%.+]] = load i32, i32* @{{.+}}, 124// CHECK: [[X:%.+]] = load atomic i32, i32* [[X_ADDR:@.+]] monotonic 125// CHECK: br label %[[CONT:.+]] 126// CHECK: [[CONT]] 127// CHECK: [[EXPECTED:%.+]] = phi i32 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 128// CHECK: [[DESIRED:%.+]] = shl i32 [[EXPECTED]], [[EXPR]] 129// CHECK: [[RES:%.+]] = cmpxchg i32* [[X_ADDR]], i32 [[EXPECTED]], i32 [[DESIRED]] monotonic monotonic 130// CHECK: [[OLD_X]] = extractvalue { i32, i1 } [[RES]], 0 131// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i32, i1 } [[RES]], 1 132// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 133// CHECK: [[EXIT]] 134#pragma omp atomic update 135 ix <<= iv; 136// CHECK: [[EXPR:%.+]] = load i32, i32* @{{.+}}, 137// CHECK: [[X:%.+]] = load atomic i32, i32* [[X_ADDR:@.+]] monotonic 138// CHECK: br label %[[CONT:.+]] 139// CHECK: [[CONT]] 140// CHECK: [[EXPECTED:%.+]] = phi i32 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 141// CHECK: [[DESIRED:%.+]] = lshr i32 [[EXPECTED]], [[EXPR]] 142// CHECK: [[RES:%.+]] = cmpxchg i32* [[X_ADDR]], i32 [[EXPECTED]], i32 [[DESIRED]] monotonic monotonic 143// CHECK: [[OLD_X]] = extractvalue { i32, i1 } [[RES]], 0 144// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i32, i1 } [[RES]], 1 145// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 146// CHECK: [[EXIT]] 147#pragma omp atomic 148 uix >>= uiv; 149// CHECK: [[EXPR:%.+]] = load i64, i64* @{{.+}}, 150// CHECK: [[X:%.+]] = load atomic i64, i64* [[X_ADDR:@.+]] monotonic 151// CHECK: br label %[[CONT:.+]] 152// CHECK: [[CONT]] 153// CHECK: [[EXPECTED:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 154// CHECK: [[DESIRED:%.+]] = sdiv i64 [[EXPECTED]], [[EXPR]] 155// CHECK: [[RES:%.+]] = cmpxchg i64* [[X_ADDR]], i64 [[EXPECTED]], i64 [[DESIRED]] monotonic monotonic 156// CHECK: [[OLD_X]] = extractvalue { i64, i1 } [[RES]], 0 157// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i64, i1 } [[RES]], 1 158// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 159// CHECK: [[EXIT]] 160#pragma omp atomic update 161 lx /= lv; 162// CHECK: [[EXPR:%.+]] = load i64, i64* @{{.+}}, 163// CHECK: atomicrmw and i64* @{{.+}}, i64 [[EXPR]] monotonic 164#pragma omp atomic 165 ulx &= ulv; 166// CHECK: [[EXPR:%.+]] = load i64, i64* @{{.+}}, 167// CHECK: atomicrmw xor i64* @{{.+}}, i64 [[EXPR]] monotonic 168#pragma omp atomic update 169 llx ^= llv; 170// CHECK: [[EXPR:%.+]] = load i64, i64* @{{.+}}, 171// CHECK: atomicrmw or i64* @{{.+}}, i64 [[EXPR]] monotonic 172#pragma omp atomic 173 ullx |= ullv; 174// CHECK: [[EXPR:%.+]] = load float, float* @{{.+}}, 175// CHECK: [[OLD:%.+]] = load atomic i32, i32* bitcast (float* [[X_ADDR:@.+]] to i32*) monotonic 176// CHECK: [[X:%.+]] = bitcast i32 [[OLD]] to float 177// CHECK: br label %[[CONT:.+]] 178// CHECK: [[CONT]] 179// CHECK: [[OLD:%.+]] = phi float [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 180// CHECK: [[ADD:%.+]] = fadd float [[OLD]], [[EXPR]] 181// CHECK: [[EXPECTED:%.+]] = bitcast float [[OLD]] to i32 182// CHECK: [[DESIRED:%.+]] = bitcast float [[ADD]] to i32 183// CHECK: [[RES:%.+]] = cmpxchg i32* bitcast (float* [[X_ADDR]] to i32*), i32 [[EXPECTED]], i32 [[DESIRED]] monotonic monotonic 184// CHECK: [[PREV:%.+]] = extractvalue { i32, i1 } [[RES]], 0 185// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i32, i1 } [[RES]], 1 186// CHECK: [[OLD_X]] = bitcast i32 [[PREV]] to float 187// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 188// CHECK: [[EXIT]] 189#pragma omp atomic update 190 fx = fx + fv; 191// CHECK: [[EXPR:%.+]] = load double, double* @{{.+}}, 192// CHECK: [[OLD:%.+]] = load atomic i64, i64* bitcast (double* [[X_ADDR:@.+]] to i64*) monotonic 193// CHECK: [[X:%.+]] = bitcast i64 [[OLD]] to double 194// CHECK: br label %[[CONT:.+]] 195// CHECK: [[CONT]] 196// CHECK: [[OLD:%.+]] = phi double [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 197// CHECK: [[SUB:%.+]] = fsub double [[EXPR]], [[OLD]] 198// CHECK: [[EXPECTED:%.+]] = bitcast double [[OLD]] to i64 199// CHECK: [[DESIRED:%.+]] = bitcast double [[SUB]] to i64 200// CHECK: [[RES:%.+]] = cmpxchg i64* bitcast (double* [[X_ADDR]] to i64*), i64 [[EXPECTED]], i64 [[DESIRED]] monotonic monotonic 201// CHECK: [[PREV:%.+]] = extractvalue { i64, i1 } [[RES]], 0 202// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i64, i1 } [[RES]], 1 203// CHECK: [[OLD_X]] = bitcast i64 [[PREV]] to double 204// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 205// CHECK: [[EXIT]] 206#pragma omp atomic 207 dx = dv - dx; 208// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}}, 209// CHECK: [[OLD:%.+]] = load atomic i128, i128* bitcast (x86_fp80* [[X_ADDR:@.+]] to i128*) monotonic 210// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i128* 211// CHECK: store i128 [[OLD]], i128* [[BITCAST]] 212// CHECK: [[X:%.+]] = load x86_fp80, x86_fp80* [[TEMP]] 213// CHECK: br label %[[CONT:.+]] 214// CHECK: [[CONT]] 215// CHECK: [[OLD:%.+]] = phi x86_fp80 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 216// CHECK: [[MUL:%.+]] = fmul x86_fp80 [[OLD]], [[EXPR]] 217// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i8* 218// CHECK: call void @llvm.memset.p0i8.i64(i8* [[BITCAST]], i8 0, i64 16, i32 16, i1 false) 219// CHECK: store x86_fp80 [[OLD]], x86_fp80* [[TEMP]] 220// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP]] to i128* 221// CHECK: [[EXPECTED:%.+]] = load i128, i128* [[BITCAST]] 222// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i8* 223// CHECK: call void @llvm.memset.p0i8.i64(i8* [[BITCAST]], i8 0, i64 16, i32 16, i1 false) 224// CHECK: store x86_fp80 [[MUL]], x86_fp80* [[TEMP]] 225// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP]] to i128* 226// CHECK: [[DESIRED:%.+]] = load i128, i128* [[BITCAST]] 227// CHECK: [[RES:%.+]] = cmpxchg i128* bitcast (x86_fp80* [[X_ADDR]] to i128*), i128 [[EXPECTED]], i128 [[DESIRED]] monotonic monotonic 228// CHECK: [[PREV:%.+]] = extractvalue { i128, i1 } [[RES]], 0 229// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i128, i1 } [[RES]], 1 230// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i128* 231// CHECK: store i128 [[PREV]], i128* [[BITCAST]] 232// CHECK: [[OLD_X]] = load x86_fp80, x86_fp80* [[TEMP]], 233// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 234// CHECK: [[EXIT]] 235#pragma omp atomic update 236 ldx = ldx * ldv; 237// CHECK: [[EXPR_RE:%.+]] = load i32, i32* getelementptr inbounds ({ i32, i32 }, { i32, i32 }* @{{.+}}, i32 0, i32 0) 238// CHECK: [[EXPR_IM:%.+]] = load i32, i32* getelementptr inbounds ({ i32, i32 }, { i32, i32 }* @{{.+}}, i32 0, i32 1) 239// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP:%.+]] to i8* 240// CHECK: call void @__atomic_load(i64 8, i8* bitcast ({ i32, i32 }* [[X_ADDR:@.+]] to i8*), i8* [[BITCAST]], i32 0) 241// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 0 242// CHECK: [[LD_RE:%.+]] = load i32, i32* [[LD_RE_ADDR]] 243// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 244// CHECK: [[LD_IM:%.+]] = load i32, i32* [[LD_IM_ADDR]] 245// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 246// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 247// CHECK: store i32 [[LD_RE]], i32* [[LD_RE_ADDR]] 248// CHECK: store i32 [[LD_IM]], i32* [[LD_IM_ADDR]] 249// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP]] to i64* 250// CHECK: [[X:%.+]] = load i64, i64* [[BITCAST]] 251// CHECK: br label %[[CONT:.+]] 252// CHECK: [[CONT]] 253// CHECK: [[OLD:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 254// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP:%.+]] to i64* 255// CHECK: store i64 [[OLD]], i64* [[BITCAST]] 256// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 0 257// CHECK: [[X_RE:%.+]] = load i32, i32* [[X_RE_ADDR]] 258// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 259// CHECK: [[X_IM:%.+]] = load i32, i32* [[X_IM_ADDR]] 260// <Skip checks for complex calculations> 261// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[EXPECTED_ADDR:%.+]], i32 0, i32 0 262// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[EXPECTED_ADDR]], i32 0, i32 1 263// CHECK: store i32 [[X_RE]], i32* [[X_RE_ADDR]] 264// CHECK: store i32 [[X_IM]], i32* [[X_IM_ADDR]] 265// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[DESIRED_ADDR:%.+]], i32 0, i32 0 266// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[DESIRED_ADDR]], i32 0, i32 1 267// CHECK: store i32 %{{.+}}, i32* [[X_RE_ADDR]] 268// CHECK: store i32 %{{.+}}, i32* [[X_IM_ADDR]] 269// CHECK: [[EXPECTED:%.+]] = bitcast { i32, i32 }* [[EXPECTED_ADDR]] to i8* 270// CHECK: [[DESIRED:%.+]] = bitcast { i32, i32 }* [[DESIRED_ADDR]] to i8* 271// CHECK: [[SUCCESS_FAIL:%.+]] = call zeroext i1 @__atomic_compare_exchange(i64 8, i8* bitcast ({ i32, i32 }* [[X_ADDR]] to i8*), i8* [[EXPECTED]], i8* [[DESIRED]], i32 0, i32 0) 272// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 273// CHECK: [[X_RE:%.+]] = load i32, i32* [[X_RE_ADDR]] 274// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 275// CHECK: [[X_IM:%.+]] = load i32, i32* [[X_IM_ADDR]] 276// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 277// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 278// CHECK: store i32 [[X_RE]], i32* [[LD_RE_ADDR]] 279// CHECK: store i32 [[X_IM]], i32* [[LD_IM_ADDR]] 280// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP]] to i64* 281// CHECK: [[OLD_X]] = load i64, i64* [[BITCAST]] 282// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 283// CHECK: [[EXIT]] 284#pragma omp atomic 285 cix = civ / cix; 286// CHECK: [[EXPR_RE:%.+]] = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @{{.+}}, i32 0, i32 0) 287// CHECK: [[EXPR_IM:%.+]] = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @{{.+}}, i32 0, i32 1) 288// CHECK: [[BITCAST:%.+]] = bitcast { float, float }* [[TEMP:%.+]] to i8* 289// CHECK: call void @__atomic_load(i64 8, i8* bitcast ({ float, float }* [[X_ADDR:@.+]] to i8*), i8* [[BITCAST]], i32 0) 290// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 0 291// CHECK: [[LD_RE:%.+]] = load float, float* [[LD_RE_ADDR]] 292// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 1 293// CHECK: [[LD_IM:%.+]] = load float, float* [[LD_IM_ADDR]] 294// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP:%.+]], i32 0, i32 0 295// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 1 296// CHECK: store float [[LD_RE]], float* [[LD_RE_ADDR]] 297// CHECK: store float [[LD_IM]], float* [[LD_IM_ADDR]] 298// CHECK: [[BITCAST:%.+]] = bitcast { float, float }* [[TEMP]] to i64* 299// CHECK: [[X:%.+]] = load i64, i64* [[BITCAST]] 300// CHECK: br label %[[CONT:.+]] 301// CHECK: [[CONT]] 302// CHECK: [[OLD:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 303// CHECK: [[BITCAST:%.+]] = bitcast { float, float }* [[TEMP:%.+]] to i64* 304// CHECK: store i64 [[OLD]], i64* [[BITCAST]] 305// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 0 306// CHECK: [[X_RE:%.+]] = load float, float* [[X_RE_ADDR]] 307// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 1 308// CHECK: [[X_IM:%.+]] = load float, float* [[X_IM_ADDR]] 309// <Skip checks for complex calculations> 310// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[EXPECTED_ADDR:%.+]], i32 0, i32 0 311// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[EXPECTED_ADDR]], i32 0, i32 1 312// CHECK: store float [[X_RE]], float* [[X_RE_ADDR]] 313// CHECK: store float [[X_IM]], float* [[X_IM_ADDR]] 314// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[DESIRED_ADDR:%.+]], i32 0, i32 0 315// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[DESIRED_ADDR]], i32 0, i32 1 316// CHECK: store float %{{.+}}, float* [[X_RE_ADDR]] 317// CHECK: store float %{{.+}}, float* [[X_IM_ADDR]] 318// CHECK: [[EXPECTED:%.+]] = bitcast { float, float }* [[EXPECTED_ADDR]] to i8* 319// CHECK: [[DESIRED:%.+]] = bitcast { float, float }* [[DESIRED_ADDR]] to i8* 320// CHECK: [[SUCCESS_FAIL:%.+]] = call zeroext i1 @__atomic_compare_exchange(i64 8, i8* bitcast ({ float, float }* [[X_ADDR]] to i8*), i8* [[EXPECTED]], i8* [[DESIRED]], i32 0, i32 0) 321// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP:%.+]], i32 0, i32 0 322// CHECK: [[X_RE:%.+]] = load float, float* [[X_RE_ADDR]] 323// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 1 324// CHECK: [[X_IM:%.+]] = load float, float* [[X_IM_ADDR]] 325// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP:%.+]], i32 0, i32 0 326// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 1 327// CHECK: store float [[X_RE]], float* [[LD_RE_ADDR]] 328// CHECK: store float [[X_IM]], float* [[LD_IM_ADDR]] 329// CHECK: [[BITCAST:%.+]] = bitcast { float, float }* [[TEMP]] to i64* 330// CHECK: [[OLD_X]] = load i64, i64* [[BITCAST]] 331// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 332// CHECK: [[EXIT]] 333#pragma omp atomic update 334 cfx = cfv + cfx; 335// CHECK: [[EXPR_RE:%.+]] = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @{{.+}}, i32 0, i32 0) 336// CHECK: [[EXPR_IM:%.+]] = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @{{.+}}, i32 0, i32 1) 337// CHECK: [[BITCAST:%.+]] = bitcast { double, double }* [[TEMP:%.+]] to i8* 338// CHECK: call void @__atomic_load(i64 16, i8* bitcast ({ double, double }* [[X_ADDR:@.+]] to i8*), i8* [[BITCAST]], i32 5) 339// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP]], i32 0, i32 0 340// CHECK: [[LD_RE:%.+]] = load double, double* [[LD_RE_ADDR]] 341// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP]], i32 0, i32 1 342// CHECK: [[LD_IM:%.+]] = load double, double* [[LD_IM_ADDR]] 343// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP:%.+]], i32 0, i32 0 344// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP]], i32 0, i32 1 345// CHECK: store double [[LD_RE]], double* [[LD_RE_ADDR]] 346// CHECK: store double [[LD_IM]], double* [[LD_IM_ADDR]] 347// CHECK: [[BITCAST:%.+]] = bitcast { double, double }* [[TEMP]] to i128* 348// CHECK: [[X:%.+]] = load i128, i128* [[BITCAST]] 349// CHECK: br label %[[CONT:.+]] 350// CHECK: [[CONT]] 351// CHECK: [[OLD:%.+]] = phi i128 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 352// CHECK: [[BITCAST:%.+]] = bitcast { double, double }* [[TEMP:%.+]] to i128* 353// CHECK: store i128 [[OLD]], i128* [[BITCAST]] 354// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP]], i32 0, i32 0 355// CHECK: [[X_RE:%.+]] = load double, double* [[X_RE_ADDR]] 356// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP]], i32 0, i32 1 357// CHECK: [[X_IM:%.+]] = load double, double* [[X_IM_ADDR]] 358// <Skip checks for complex calculations> 359// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[EXPECTED_ADDR:%.+]], i32 0, i32 0 360// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[EXPECTED_ADDR]], i32 0, i32 1 361// CHECK: store double [[X_RE]], double* [[X_RE_ADDR]] 362// CHECK: store double [[X_IM]], double* [[X_IM_ADDR]] 363// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[DESIRED_ADDR:%.+]], i32 0, i32 0 364// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[DESIRED_ADDR]], i32 0, i32 1 365// CHECK: store double %{{.+}}, double* [[X_RE_ADDR]] 366// CHECK: store double %{{.+}}, double* [[X_IM_ADDR]] 367// CHECK: [[EXPECTED:%.+]] = bitcast { double, double }* [[EXPECTED_ADDR]] to i8* 368// CHECK: [[DESIRED:%.+]] = bitcast { double, double }* [[DESIRED_ADDR]] to i8* 369// CHECK: [[SUCCESS_FAIL:%.+]] = call zeroext i1 @__atomic_compare_exchange(i64 16, i8* bitcast ({ double, double }* [[X_ADDR]] to i8*), i8* [[EXPECTED]], i8* [[DESIRED]], i32 5, i32 5) 370// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP:%.+]], i32 0, i32 0 371// CHECK: [[X_RE:%.+]] = load double, double* [[X_RE_ADDR]] 372// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP]], i32 0, i32 1 373// CHECK: [[X_IM:%.+]] = load double, double* [[X_IM_ADDR]] 374// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP:%.+]], i32 0, i32 0 375// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { double, double }, { double, double }* [[TEMP]], i32 0, i32 1 376// CHECK: store double [[X_RE]], double* [[LD_RE_ADDR]] 377// CHECK: store double [[X_IM]], double* [[LD_IM_ADDR]] 378// CHECK: [[BITCAST:%.+]] = bitcast { double, double }* [[TEMP]] to i128* 379// CHECK: [[OLD_X]] = load i128, i128* [[BITCAST]] 380// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 381// CHECK: [[EXIT]] 382// CHECK: call{{.*}} @__kmpc_flush( 383#pragma omp atomic seq_cst 384 cdx = cdx - cdv; 385// CHECK: [[BV:%.+]] = load i8, i8* @{{.+}} 386// CHECK: [[BOOL:%.+]] = trunc i8 [[BV]] to i1 387// CHECK: [[EXPR:%.+]] = zext i1 [[BOOL]] to i64 388// CHECK: atomicrmw and i64* @{{.+}}, i64 [[EXPR]] monotonic 389#pragma omp atomic update 390 ulx = ulx & bv; 391// CHECK: [[CV:%.+]] = load i8, i8* @{{.+}}, align 1 392// CHECK: [[EXPR:%.+]] = sext i8 [[CV]] to i32 393// CHECK: [[BX:%.+]] = load atomic i8, i8* [[BX_ADDR:@.+]] monotonic 394// CHECK: [[X:%.+]] = trunc i8 [[BX]] to i1 395// CHECK: br label %[[CONT:.+]] 396// CHECK: [[CONT]] 397// CHECK: [[OLD:%.+]] = phi i1 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 398// CHECK: [[X_RVAL:%.+]] = zext i1 [[OLD]] to i32 399// CHECK: [[AND:%.+]] = and i32 [[EXPR]], [[X_RVAL]] 400// CHECK: [[CAST:%.+]] = icmp ne i32 [[AND]], 0 401// CHECK: [[EXPECTED:%.+]] = zext i1 [[OLD]] to i8 402// CHECK: [[DESIRED:%.+]] = zext i1 [[CAST]] to i8 403// CHECK: [[RES:%.+]] = cmpxchg i8* [[BX_ADDR]], i8 [[EXPECTED]], i8 [[DESIRED]] monotonic monotonic 404// CHECK: [[OLD:%.+]] = extractvalue { i8, i1 } [[RES]], 0 405// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i8, i1 } [[RES]], 1 406// CHECK: [[OLD_X]] = trunc i8 [[OLD]] to i1 407// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 408// CHECK: [[EXIT]] 409#pragma omp atomic 410 bx = cv & bx; 411// CHECK: [[UCV:%.+]] = load i8, i8* @{{.+}}, 412// CHECK: [[EXPR:%.+]] = zext i8 [[UCV]] to i32 413// CHECK: [[X:%.+]] = load atomic i8, i8* [[CX_ADDR:@.+]] seq_cst 414// CHECK: br label %[[CONT:.+]] 415// CHECK: [[CONT]] 416// CHECK: [[EXPECTED:%.+]] = phi i8 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 417// CHECK: [[X_RVAL:%.+]] = sext i8 [[EXPECTED]] to i32 418// CHECK: [[ASHR:%.+]] = ashr i32 [[X_RVAL]], [[EXPR]] 419// CHECK: [[DESIRED:%.+]] = trunc i32 [[ASHR]] to i8 420// CHECK: [[RES:%.+]] = cmpxchg i8* [[CX_ADDR]], i8 [[EXPECTED]], i8 [[DESIRED]] seq_cst seq_cst 421// CHECK: [[OLD_X:%.+]] = extractvalue { i8, i1 } [[RES]], 0 422// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i8, i1 } [[RES]], 1 423// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 424// CHECK: [[EXIT]] 425// CHECK: call{{.*}} @__kmpc_flush( 426#pragma omp atomic update, seq_cst 427 cx = cx >> ucv; 428// CHECK: [[SV:%.+]] = load i16, i16* @{{.+}}, 429// CHECK: [[EXPR:%.+]] = sext i16 [[SV]] to i32 430// CHECK: [[X:%.+]] = load atomic i64, i64* [[ULX_ADDR:@.+]] monotonic 431// CHECK: br label %[[CONT:.+]] 432// CHECK: [[CONT]] 433// CHECK: [[EXPECTED:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 434// CHECK: [[X_RVAL:%.+]] = trunc i64 [[EXPECTED]] to i32 435// CHECK: [[SHL:%.+]] = shl i32 [[EXPR]], [[X_RVAL]] 436// CHECK: [[DESIRED:%.+]] = sext i32 [[SHL]] to i64 437// CHECK: [[RES:%.+]] = cmpxchg i64* [[ULX_ADDR]], i64 [[EXPECTED]], i64 [[DESIRED]] monotonic monotonic 438// CHECK: [[OLD_X:%.+]] = extractvalue { i64, i1 } [[RES]], 0 439// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i64, i1 } [[RES]], 1 440// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 441// CHECK: [[EXIT]] 442#pragma omp atomic update 443 ulx = sv << ulx; 444// CHECK: [[USV:%.+]] = load i16, i16* @{{.+}}, 445// CHECK: [[EXPR:%.+]] = zext i16 [[USV]] to i64 446// CHECK: [[X:%.+]] = load atomic i64, i64* [[LX_ADDR:@.+]] monotonic 447// CHECK: br label %[[CONT:.+]] 448// CHECK: [[CONT]] 449// CHECK: [[EXPECTED:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 450// CHECK: [[DESIRED:%.+]] = srem i64 [[EXPECTED]], [[EXPR]] 451// CHECK: [[RES:%.+]] = cmpxchg i64* [[LX_ADDR]], i64 [[EXPECTED]], i64 [[DESIRED]] monotonic monotonic 452// CHECK: [[OLD_X:%.+]] = extractvalue { i64, i1 } [[RES]], 0 453// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i64, i1 } [[RES]], 1 454// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 455// CHECK: [[EXIT]] 456#pragma omp atomic 457 lx = lx % usv; 458// CHECK: [[EXPR:%.+]] = load i32, i32* @{{.+}} 459// CHECK: atomicrmw or i32* @{{.+}}, i32 [[EXPR]] seq_cst 460// CHECK: call{{.*}} @__kmpc_flush( 461#pragma omp atomic seq_cst, update 462 uix = iv | uix; 463// CHECK: [[EXPR:%.+]] = load i32, i32* @{{.+}} 464// CHECK: atomicrmw and i32* @{{.+}}, i32 [[EXPR]] monotonic 465#pragma omp atomic 466 ix = ix & uiv; 467// CHECK: [[EXPR:%.+]] = load i64, i64* @{{.+}}, 468// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP:%.+]] to i8* 469// CHECK: call void @__atomic_load(i64 8, i8* bitcast ({ i32, i32 }* [[X_ADDR:@.+]] to i8*), i8* [[BITCAST]], i32 0) 470// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 0 471// CHECK: [[LD_RE:%.+]] = load i32, i32* [[LD_RE_ADDR]] 472// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 473// CHECK: [[LD_IM:%.+]] = load i32, i32* [[LD_IM_ADDR]] 474// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 475// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 476// CHECK: store i32 [[LD_RE]], i32* [[LD_RE_ADDR]] 477// CHECK: store i32 [[LD_IM]], i32* [[LD_IM_ADDR]] 478// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP]] to i64* 479// CHECK: [[X:%.+]] = load i64, i64* [[BITCAST]] 480// CHECK: br label %[[CONT:.+]] 481// CHECK: [[CONT]] 482// CHECK: [[OLD:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 483// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP:%.+]] to i64* 484// CHECK: store i64 [[OLD]], i64* [[BITCAST]] 485// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 0 486// CHECK: [[X_RE:%.+]] = load i32, i32* [[X_RE_ADDR]] 487// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 488// CHECK: [[X_IM:%.+]] = load i32, i32* [[X_IM_ADDR]] 489// <Skip checks for complex calculations> 490// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[EXPECTED_ADDR:%.+]], i32 0, i32 0 491// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[EXPECTED_ADDR]], i32 0, i32 1 492// CHECK: store i32 [[X_RE]], i32* [[X_RE_ADDR]] 493// CHECK: store i32 [[X_IM]], i32* [[X_IM_ADDR]] 494// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[DESIRED_ADDR:%.+]], i32 0, i32 0 495// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[DESIRED_ADDR]], i32 0, i32 1 496// CHECK: store i32 %{{.+}}, i32* [[X_RE_ADDR]] 497// CHECK: store i32 %{{.+}}, i32* [[X_IM_ADDR]] 498// CHECK: [[EXPECTED:%.+]] = bitcast { i32, i32 }* [[EXPECTED_ADDR]] to i8* 499// CHECK: [[DESIRED:%.+]] = bitcast { i32, i32 }* [[DESIRED_ADDR]] to i8* 500// CHECK: [[SUCCESS_FAIL:%.+]] = call zeroext i1 @__atomic_compare_exchange(i64 8, i8* bitcast ({ i32, i32 }* [[X_ADDR]] to i8*), i8* [[EXPECTED]], i8* [[DESIRED]], i32 0, i32 0) 501// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 502// CHECK: [[X_RE:%.+]] = load i32, i32* [[X_RE_ADDR]] 503// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 504// CHECK: [[X_IM:%.+]] = load i32, i32* [[X_IM_ADDR]] 505// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 506// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 507// CHECK: store i32 [[X_RE]], i32* [[LD_RE_ADDR]] 508// CHECK: store i32 [[X_IM]], i32* [[LD_IM_ADDR]] 509// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP]] to i64* 510// CHECK: [[OLD_X]] = load i64, i64* [[BITCAST]] 511// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 512// CHECK: [[EXIT]] 513#pragma omp atomic update 514 cix = lv + cix; 515// CHECK: [[ULV:%.+]] = load i64, i64* @{{.+}}, 516// CHECK: [[EXPR:%.+]] = uitofp i64 [[ULV]] to float 517// CHECK: [[OLD:%.+]] = load atomic i32, i32* bitcast (float* [[X_ADDR:@.+]] to i32*) monotonic 518// CHECK: [[X:%.+]] = bitcast i32 [[OLD]] to float 519// CHECK: br label %[[CONT:.+]] 520// CHECK: [[CONT]] 521// CHECK: [[OLD:%.+]] = phi float [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 522// CHECK: [[MUL:%.+]] = fmul float [[OLD]], [[EXPR]] 523// CHECK: [[EXPECTED:%.+]] = bitcast float [[OLD]] to i32 524// CHECK: [[DESIRED:%.+]] = bitcast float [[MUL]] to i32 525// CHECK: [[RES:%.+]] = cmpxchg i32* bitcast (float* [[X_ADDR]] to i32*), i32 [[EXPECTED]], i32 [[DESIRED]] monotonic monotonic 526// CHECK: [[PREV:%.+]] = extractvalue { i32, i1 } [[RES]], 0 527// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i32, i1 } [[RES]], 1 528// CHECK: [[OLD_X]] = bitcast i32 [[PREV]] to float 529// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 530// CHECK: [[EXIT]] 531#pragma omp atomic 532 fx = fx * ulv; 533// CHECK: [[LLV:%.+]] = load i64, i64* @{{.+}}, 534// CHECK: [[EXPR:%.+]] = sitofp i64 [[LLV]] to double 535// CHECK: [[OLD:%.+]] = load atomic i64, i64* bitcast (double* [[X_ADDR:@.+]] to i64*) monotonic 536// CHECK: [[X:%.+]] = bitcast i64 [[OLD]] to double 537// CHECK: br label %[[CONT:.+]] 538// CHECK: [[CONT]] 539// CHECK: [[OLD:%.+]] = phi double [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 540// CHECK: [[DIV:%.+]] = fdiv double [[OLD]], [[EXPR]] 541// CHECK: [[EXPECTED:%.+]] = bitcast double [[OLD]] to i64 542// CHECK: [[DESIRED:%.+]] = bitcast double [[DIV]] to i64 543// CHECK: [[RES:%.+]] = cmpxchg i64* bitcast (double* [[X_ADDR]] to i64*), i64 [[EXPECTED]], i64 [[DESIRED]] monotonic monotonic 544// CHECK: [[PREV:%.+]] = extractvalue { i64, i1 } [[RES]], 0 545// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i64, i1 } [[RES]], 1 546// CHECK: [[OLD_X]] = bitcast i64 [[PREV]] to double 547// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 548// CHECK: [[EXIT]] 549#pragma omp atomic update 550 dx /= llv; 551// CHECK: [[ULLV:%.+]] = load i64, i64* @{{.+}}, 552// CHECK: [[EXPR:%.+]] = uitofp i64 [[ULLV]] to x86_fp80 553// CHECK: [[OLD:%.+]] = load atomic i128, i128* bitcast (x86_fp80* [[X_ADDR:@.+]] to i128*) monotonic 554// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i128* 555// CHECK: store i128 [[OLD]], i128* [[BITCAST]] 556// CHECK: [[X:%.+]] = load x86_fp80, x86_fp80* [[TEMP]] 557// CHECK: br label %[[CONT:.+]] 558// CHECK: [[CONT]] 559// CHECK: [[OLD:%.+]] = phi x86_fp80 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 560// CHECK: [[SUB:%.+]] = fsub x86_fp80 [[OLD]], [[EXPR]] 561// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i8* 562// CHECK: call void @llvm.memset.p0i8.i64(i8* [[BITCAST]], i8 0, i64 16, i32 16, i1 false) 563// CHECK: store x86_fp80 [[OLD]], x86_fp80* [[TEMP]] 564// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP]] to i128* 565// CHECK: [[EXPECTED:%.+]] = load i128, i128* [[BITCAST]] 566// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i8* 567// CHECK: call void @llvm.memset.p0i8.i64(i8* [[BITCAST]], i8 0, i64 16, i32 16, i1 false) 568// CHECK: store x86_fp80 [[SUB]], x86_fp80* [[TEMP]] 569// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP]] to i128* 570// CHECK: [[DESIRED:%.+]] = load i128, i128* [[BITCAST]] 571// CHECK: [[RES:%.+]] = cmpxchg i128* bitcast (x86_fp80* [[X_ADDR]] to i128*), i128 [[EXPECTED]], i128 [[DESIRED]] monotonic monotonic 572// CHECK: [[PREV:%.+]] = extractvalue { i128, i1 } [[RES]], 0 573// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i128, i1 } [[RES]], 1 574// CHECK: [[BITCAST:%.+]] = bitcast x86_fp80* [[TEMP:%.+]] to i128* 575// CHECK: store i128 [[PREV]], i128* [[BITCAST]] 576// CHECK: [[OLD_X]] = load x86_fp80, x86_fp80* [[TEMP]], 577// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 578// CHECK: [[EXIT]] 579#pragma omp atomic 580 ldx -= ullv; 581// CHECK: [[EXPR:%.+]] = load float, float* @{{.+}}, 582// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP:%.+]] to i8* 583// CHECK: call void @__atomic_load(i64 8, i8* bitcast ({ i32, i32 }* [[X_ADDR:@.+]] to i8*), i8* [[BITCAST]], i32 0) 584// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 0 585// CHECK: [[LD_RE:%.+]] = load i32, i32* [[LD_RE_ADDR]] 586// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 587// CHECK: [[LD_IM:%.+]] = load i32, i32* [[LD_IM_ADDR]] 588// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 589// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 590// CHECK: store i32 [[LD_RE]], i32* [[LD_RE_ADDR]] 591// CHECK: store i32 [[LD_IM]], i32* [[LD_IM_ADDR]] 592// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP]] to i64* 593// CHECK: [[X:%.+]] = load i64, i64* [[BITCAST]] 594// CHECK: br label %[[CONT:.+]] 595// CHECK: [[CONT]] 596// CHECK: [[OLD:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 597// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP:%.+]] to i64* 598// CHECK: store i64 [[OLD]], i64* [[BITCAST]] 599// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 0 600// CHECK: [[X_RE:%.+]] = load i32, i32* [[X_RE_ADDR]] 601// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 602// CHECK: [[X_IM:%.+]] = load i32, i32* [[X_IM_ADDR]] 603// <Skip checks for complex calculations> 604// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[EXPECTED_ADDR:%.+]], i32 0, i32 0 605// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[EXPECTED_ADDR]], i32 0, i32 1 606// CHECK: store i32 [[X_RE]], i32* [[X_RE_ADDR]] 607// CHECK: store i32 [[X_IM]], i32* [[X_IM_ADDR]] 608// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[DESIRED_ADDR:%.+]], i32 0, i32 0 609// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[DESIRED_ADDR]], i32 0, i32 1 610// CHECK: store i32 %{{.+}}, i32* [[X_RE_ADDR]] 611// CHECK: store i32 %{{.+}}, i32* [[X_IM_ADDR]] 612// CHECK: [[EXPECTED:%.+]] = bitcast { i32, i32 }* [[EXPECTED_ADDR]] to i8* 613// CHECK: [[DESIRED:%.+]] = bitcast { i32, i32 }* [[DESIRED_ADDR]] to i8* 614// CHECK: [[SUCCESS_FAIL:%.+]] = call zeroext i1 @__atomic_compare_exchange(i64 8, i8* bitcast ({ i32, i32 }* [[X_ADDR]] to i8*), i8* [[EXPECTED]], i8* [[DESIRED]], i32 0, i32 0) 615// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 616// CHECK: [[X_RE:%.+]] = load i32, i32* [[X_RE_ADDR]] 617// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 618// CHECK: [[X_IM:%.+]] = load i32, i32* [[X_IM_ADDR]] 619// CHECK: [[LD_RE_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP:%.+]], i32 0, i32 0 620// CHECK: [[LD_IM_ADDR:%.+]] = getelementptr inbounds { i32, i32 }, { i32, i32 }* [[TEMP]], i32 0, i32 1 621// CHECK: store i32 [[X_RE]], i32* [[LD_RE_ADDR]] 622// CHECK: store i32 [[X_IM]], i32* [[LD_IM_ADDR]] 623// CHECK: [[BITCAST:%.+]] = bitcast { i32, i32 }* [[TEMP]] to i64* 624// CHECK: [[OLD_X]] = load i64, i64* [[BITCAST]] 625// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 626// CHECK: [[EXIT]] 627#pragma omp atomic update 628 cix = fv / cix; 629// CHECK: [[EXPR:%.+]] = load double, double* @{{.+}}, 630// CHECK: [[X:%.+]] = load atomic i16, i16* [[X_ADDR:@.+]] monotonic 631// CHECK: br label %[[CONT:.+]] 632// CHECK: [[CONT]] 633// CHECK: [[EXPECTED:%.+]] = phi i16 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 634// CHECK: [[CONV:%.+]] = sext i16 [[EXPECTED]] to i32 635// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[CONV]] to double 636// CHECK: [[ADD:%.+]] = fadd double [[X_RVAL]], [[EXPR]] 637// CHECK: [[DESIRED:%.+]] = fptosi double [[ADD]] to i16 638// CHECK: [[RES:%.+]] = cmpxchg i16* [[X_ADDR]], i16 [[EXPECTED]], i16 [[DESIRED]] monotonic monotonic 639// CHECK: [[OLD_X]] = extractvalue { i16, i1 } [[RES]], 0 640// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i16, i1 } [[RES]], 1 641// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 642// CHECK: [[EXIT]] 643#pragma omp atomic 644 sx = sx + dv; 645// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}}, 646// CHECK: [[XI8:%.+]] = load atomic i8, i8* [[X_ADDR:@.+]] monotonic 647// CHECK: [[X:%.+]] = trunc i8 [[XI8]] to i1 648// CHECK: br label %[[CONT:.+]] 649// CHECK: [[CONT]] 650// CHECK: [[BOOL_EXPECTED:%.+]] = phi i1 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 651// CHECK: [[CONV:%.+]] = zext i1 [[BOOL_EXPECTED]] to i32 652// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[CONV]] to x86_fp80 653// CHECK: [[MUL:%.+]] = fmul x86_fp80 [[EXPR]], [[X_RVAL]] 654// CHECK: [[BOOL_DESIRED:%.+]] = fcmp une x86_fp80 [[MUL]], 0xK00000000000000000000 655// CHECK: [[EXPECTED:%.+]] = zext i1 [[BOOL_EXPECTED]] to i8 656// CHECK: [[DESIRED:%.+]] = zext i1 [[BOOL_DESIRED]] to i8 657// CHECK: [[RES:%.+]] = cmpxchg i8* [[X_ADDR]], i8 [[EXPECTED]], i8 [[DESIRED]] monotonic monotonic 658// CHECK: [[OLD_XI8:%.+]] = extractvalue { i8, i1 } [[RES]], 0 659// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i8, i1 } [[RES]], 1 660// CHECK: [[OLD_X]] = trunc i8 [[OLD_XI8]] to i1 661// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 662// CHECK: [[EXIT]] 663#pragma omp atomic update 664 bx = ldv * bx; 665// CHECK: [[EXPR_RE:%.+]] = load i32, i32* getelementptr inbounds ({ i32, i32 }, { i32, i32 }* [[CIV_ADDR:@.+]], i32 0, i32 0), 666// CHECK: [[EXPR_IM:%.+]] = load i32, i32* getelementptr inbounds ({ i32, i32 }, { i32, i32 }* [[CIV_ADDR]], i32 0, i32 1), 667// CHECK: [[XI8:%.+]] = load atomic i8, i8* [[X_ADDR:@.+]] monotonic 668// CHECK: [[X:%.+]] = trunc i8 [[XI8]] to i1 669// CHECK: br label %[[CONT:.+]] 670// CHECK: [[CONT]] 671// CHECK: [[BOOL_EXPECTED:%.+]] = phi i1 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 672// CHECK: [[X_RVAL:%.+]] = zext i1 [[BOOL_EXPECTED]] to i32 673// CHECK: [[SUB_RE:%.+]] = sub i32 [[EXPR_RE:%.+]], [[X_RVAL]] 674// CHECK: [[SUB_IM:%.+]] = sub i32 [[EXPR_IM:%.+]], 0 675// CHECK: icmp ne i32 [[SUB_RE]], 0 676// CHECK: icmp ne i32 [[SUB_IM]], 0 677// CHECK: [[BOOL_DESIRED:%.+]] = or i1 678// CHECK: [[EXPECTED:%.+]] = zext i1 [[BOOL_EXPECTED]] to i8 679// CHECK: [[DESIRED:%.+]] = zext i1 [[BOOL_DESIRED]] to i8 680// CHECK: [[RES:%.+]] = cmpxchg i8* [[X_ADDR]], i8 [[EXPECTED]], i8 [[DESIRED]] monotonic monotonic 681// CHECK: [[OLD_XI8:%.+]] = extractvalue { i8, i1 } [[RES]], 0 682// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i8, i1 } [[RES]], 1 683// CHECK: [[OLD_X]] = trunc i8 [[OLD_XI8]] to i1 684// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 685// CHECK: [[EXIT]] 686#pragma omp atomic 687 bx = civ - bx; 688// CHECK: [[EXPR_RE:%.+]] = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @{{.+}}, i32 0, i32 0) 689// CHECK: [[EXPR_IM:%.+]] = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @{{.+}}, i32 0, i32 1) 690// CHECK: [[X:%.+]] = load atomic i16, i16* [[X_ADDR:@.+]] monotonic 691// CHECK: br label %[[CONT:.+]] 692// CHECK: [[CONT]] 693// CHECK: [[EXPECTED:%.+]] = phi i16 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 694// CHECK: [[CONV:%.+]] = zext i16 [[EXPECTED]] to i32 695// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[CONV]] to float 696// <Skip checks for complex calculations> 697// CHECK: [[X_RE_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP:%.+]], i32 0, i32 0 698// CHECK: [[X_RE:%.+]] = load float, float* [[X_RE_ADDR]] 699// CHECK: [[X_IM_ADDR:%.+]] = getelementptr inbounds { float, float }, { float, float }* [[TEMP]], i32 0, i32 1 700// CHECK: [[X_IM:%.+]] = load float, float* [[X_IM_ADDR]] 701// CHECK: [[DESIRED:%.+]] = fptoui float [[X_RE]] to i16 702// CHECK: [[RES:%.+]] = cmpxchg i16* [[X_ADDR]], i16 [[EXPECTED]], i16 [[DESIRED]] monotonic monotonic 703// CHECK: [[OLD_X]] = extractvalue { i16, i1 } [[RES]], 0 704// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i16, i1 } [[RES]], 1 705// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 706// CHECK: [[EXIT]] 707#pragma omp atomic update 708 usx /= cfv; 709// CHECK: [[EXPR_RE:%.+]] = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @{{.+}}, i32 0, i32 0) 710// CHECK: [[EXPR_IM:%.+]] = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @{{.+}}, i32 0, i32 1) 711// CHECK: [[X:%.+]] = load atomic i64, i64* [[X_ADDR:@.+]] monotonic 712// CHECK: br label %[[CONT:.+]] 713// CHECK: [[CONT]] 714// CHECK: [[EXPECTED:%.+]] = phi i64 [ [[X]], %{{.+}} ], [ [[OLD_X:%.+]], %[[CONT]] ] 715// CHECK: [[X_RVAL:%.+]] = sitofp i64 [[EXPECTED]] to double 716// CHECK: [[ADD_RE:%.+]] = fadd double [[X_RVAL]], [[EXPR_RE]] 717// CHECK: [[ADD_IM:%.+]] = fadd double 0.000000e+00, [[EXPR_IM]] 718// CHECK: [[DESIRED:%.+]] = fptosi double [[ADD_RE]] to i64 719// CHECK: [[RES:%.+]] = cmpxchg i64* [[X_ADDR]], i64 [[EXPECTED]], i64 [[DESIRED]] monotonic monotonic 720// CHECK: [[OLD_X]] = extractvalue { i64, i1 } [[RES]], 0 721// CHECK: [[SUCCESS_FAIL:%.+]] = extractvalue { i64, i1 } [[RES]], 1 722// CHECK: br i1 [[SUCCESS_FAIL]], label %[[EXIT:.+]], label %[[CONT]] 723// CHECK: [[EXIT]] 724#pragma omp atomic 725 llx += cdv; 726// CHECK: [[IDX:%.+]] = load i16, i16* @{{.+}} 727// CHECK: load i8, i8* 728// CHECK: [[VEC_ITEM_VAL:%.+]] = zext i1 %{{.+}} to i32 729// CHECK: [[I128VAL:%.+]] = load atomic i128, i128* bitcast (<4 x i32>* [[DEST:@.+]] to i128*) monotonic 730// CHECK: [[LD:%.+]] = bitcast i128 [[I128VAL]] to <4 x i32> 731// CHECK: br label %[[CONT:.+]] 732// CHECK: [[CONT]] 733// CHECK: [[OLD_VEC_VAL:%.+]] = phi <4 x i32> [ [[LD]], %{{.+}} ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 734// CHECK: store <4 x i32> [[OLD_VEC_VAL]], <4 x i32>* [[LDTEMP:%.+]], 735// CHECK: [[VEC_VAL:%.+]] = load <4 x i32>, <4 x i32>* [[LDTEMP]] 736// CHECK: [[ITEM:%.+]] = extractelement <4 x i32> [[VEC_VAL]], i16 [[IDX]] 737// CHECK: [[OR:%.+]] = or i32 [[ITEM]], [[VEC_ITEM_VAL]] 738// CHECK: [[VEC_VAL:%.+]] = load <4 x i32>, <4 x i32>* [[LDTEMP]] 739// CHECK: [[NEW_VEC_VAL:%.+]] = insertelement <4 x i32> [[VEC_VAL]], i32 [[OR]], i16 [[IDX]] 740// CHECK: store <4 x i32> [[NEW_VEC_VAL]], <4 x i32>* [[LDTEMP]] 741// CHECK: [[NEW_VEC_VAL:%.+]] = load <4 x i32>, <4 x i32>* [[LDTEMP]] 742// CHECK: [[OLD_I128:%.+]] = bitcast <4 x i32> [[OLD_VEC_VAL]] to i128 743// CHECK: [[NEW_I128:%.+]] = bitcast <4 x i32> [[NEW_VEC_VAL]] to i128 744// CHECK: [[RES:%.+]] = cmpxchg i128* bitcast (<4 x i32>* [[DEST]] to i128*), i128 [[OLD_I128]], i128 [[NEW_I128]] monotonic monotonic 745// CHECK: [[FAILED_I128_OLD_VAL:%.+]] = extractvalue { i128, i1 } [[RES]], 0 746// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i128, i1 } [[RES]], 1 747// CHECK: [[FAILED_OLD_VAL]] = bitcast i128 [[FAILED_I128_OLD_VAL]] to <4 x i32> 748// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 749// CHECK: [[EXIT]] 750#pragma omp atomic update 751 int4x[sv] |= bv; 752// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 753// CHECK: [[PREV_VALUE:%.+]] = load atomic i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast (%struct.BitFields* @{{.+}} to i8*), i64 4) to i32*) monotonic 754// CHECK: br label %[[CONT:.+]] 755// CHECK: [[CONT]] 756// CHECK: [[OLD_BF_VALUE:%.+]] = phi i32 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 757// CHECK: store i32 [[OLD_BF_VALUE]], i32* [[TEMP:%.+]], 758// CHECK: [[A_LD:%.+]] = load i32, i32* [[TEMP]], 759// CHECK: [[A_SHL:%.+]] = shl i32 [[A_LD]], 1 760// CHECK: [[A_ASHR:%.+]] = ashr i32 [[A_SHL]], 1 761// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[A_ASHR]] to x86_fp80 762// CHECK: [[SUB:%.+]] = fsub x86_fp80 [[X_RVAL]], [[EXPR]] 763// CHECK: [[CONV:%.+]] = fptosi x86_fp80 [[SUB]] to i32 764// CHECK: [[NEW_VAL:%.+]] = load i32, i32* [[TEMP]], 765// CHECK: [[BF_VALUE:%.+]] = and i32 [[CONV]], 2147483647 766// CHECK: [[BF_CLEAR:%.+]] = and i32 [[NEW_VAL]], -2147483648 767// CHECK: or i32 [[BF_CLEAR]], [[BF_VALUE]] 768// CHECK: store i32 %{{.+}}, i32* [[LDTEMP:%.+]] 769// CHECK: [[NEW_BF_VALUE:%.+]] = load i32, i32* [[LDTEMP]] 770// CHECK: [[RES:%.+]] = cmpxchg i32* bitcast (i8* getelementptr (i8, i8* bitcast (%struct.BitFields* @{{.+}} to i8*), i64 4) to i32*), i32 [[OLD_BF_VALUE]], i32 [[NEW_BF_VALUE]] monotonic monotonic 771// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i32, i1 } [[RES]], 0 772// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i32, i1 } [[RES]], 1 773// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 774// CHECK: [[EXIT]] 775#pragma omp atomic 776 bfx.a = bfx.a - ldv; 777// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 778// CHECK: [[BITCAST:%.+]] = bitcast i32* [[LDTEMP:%.+]] to i8* 779// CHECK: call void @__atomic_load(i64 4, i8* getelementptr (i8, i8* bitcast (%struct.BitFields_packed* @{{.+}} to i8*), i64 4), i8* [[BITCAST]], i32 0) 780// CHECK: [[PREV_VALUE:%.+]] = load i32, i32* [[LDTEMP]] 781// CHECK: br label %[[CONT:.+]] 782// CHECK: [[CONT]] 783// CHECK: [[OLD_BF_VALUE:%.+]] = phi i32 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 784// CHECK: store i32 [[OLD_BF_VALUE]], i32* [[TEMP:%.+]], 785// CHECK: [[A_LD:%.+]] = load i32, i32* [[TEMP]], 786// CHECK: [[A_SHL:%.+]] = shl i32 [[A_LD]], 1 787// CHECK: [[A_ASHR:%.+]] = ashr i32 [[A_SHL]], 1 788// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[A_ASHR]] to x86_fp80 789// CHECK: [[MUL:%.+]] = fmul x86_fp80 [[X_RVAL]], [[EXPR]] 790// CHECK: [[CONV:%.+]] = fptosi x86_fp80 [[MUL]] to i32 791// CHECK: [[NEW_VAL:%.+]] = load i32, i32* [[TEMP]], 792// CHECK: [[BF_VALUE:%.+]] = and i32 [[CONV]], 2147483647 793// CHECK: [[BF_CLEAR:%.+]] = and i32 [[NEW_VAL]], -2147483648 794// CHECK: or i32 [[BF_CLEAR]], [[BF_VALUE]] 795// CHECK: store i32 %{{.+}}, i32* [[LDTEMP:%.+]] 796// CHECK: [[NEW_BF_VALUE:%.+]] = load i32, i32* [[LDTEMP]] 797// CHECK: store i32 [[OLD_BF_VALUE]], i32* [[TEMP_OLD_BF_ADDR:%.+]], 798// CHECK: store i32 [[NEW_BF_VALUE]], i32* [[TEMP_NEW_BF_ADDR:%.+]], 799// CHECK: [[BITCAST_TEMP_OLD_BF_ADDR:%.+]] = bitcast i32* [[TEMP_OLD_BF_ADDR]] to i8* 800// CHECK: [[BITCAST_TEMP_NEW_BF_ADDR:%.+]] = bitcast i32* [[TEMP_NEW_BF_ADDR]] to i8* 801// CHECK: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i64 4, i8* getelementptr (i8, i8* bitcast (%struct.BitFields_packed* @{{.+}} to i8*), i64 4), i8* [[BITCAST_TEMP_OLD_BF_ADDR]], i8* [[BITCAST_TEMP_NEW_BF_ADDR]], i32 0, i32 0) 802// CHECK: [[FAILED_OLD_VAL]] = load i32, i32* [[TEMP_OLD_BF_ADDR]] 803// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 804// CHECK: [[EXIT]] 805#pragma omp atomic update 806 bfx_packed.a *= ldv; 807// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 808// CHECK: [[PREV_VALUE:%.+]] = load atomic i32, i32* getelementptr inbounds (%struct.BitFields2, %struct.BitFields2* @{{.+}}, i32 0, i32 0) monotonic 809// CHECK: br label %[[CONT:.+]] 810// CHECK: [[CONT]] 811// CHECK: [[OLD_BF_VALUE:%.+]] = phi i32 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 812// CHECK: store i32 [[OLD_BF_VALUE]], i32* [[TEMP:%.+]], 813// CHECK: [[A_LD:%.+]] = load i32, i32* [[TEMP]], 814// CHECK: [[A_ASHR:%.+]] = ashr i32 [[A_LD]], 31 815// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[A_ASHR]] to x86_fp80 816// CHECK: [[SUB:%.+]] = fsub x86_fp80 [[X_RVAL]], [[EXPR]] 817// CHECK: [[CONV:%.+]] = fptosi x86_fp80 [[SUB]] to i32 818// CHECK: [[NEW_VAL:%.+]] = load i32, i32* [[TEMP]], 819// CHECK: [[BF_AND:%.+]] = and i32 [[CONV]], 1 820// CHECK: [[BF_VALUE:%.+]] = shl i32 [[BF_AND]], 31 821// CHECK: [[BF_CLEAR:%.+]] = and i32 [[NEW_VAL]], 2147483647 822// CHECK: or i32 [[BF_CLEAR]], [[BF_VALUE]] 823// CHECK: store i32 %{{.+}}, i32* [[LDTEMP:%.+]] 824// CHECK: [[NEW_BF_VALUE:%.+]] = load i32, i32* [[LDTEMP]] 825// CHECK: [[RES:%.+]] = cmpxchg i32* getelementptr inbounds (%struct.BitFields2, %struct.BitFields2* @{{.+}}, i32 0, i32 0), i32 [[OLD_BF_VALUE]], i32 [[NEW_BF_VALUE]] monotonic monotonic 826// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i32, i1 } [[RES]], 0 827// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i32, i1 } [[RES]], 1 828// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 829// CHECK: [[EXIT]] 830#pragma omp atomic 831 bfx2.a -= ldv; 832// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 833// CHECK: [[PREV_VALUE:%.+]] = load atomic i8, i8* getelementptr (i8, i8* bitcast (%struct.BitFields2_packed* @{{.+}} to i8*), i64 3) monotonic 834// CHECK: br label %[[CONT:.+]] 835// CHECK: [[CONT]] 836// CHECK: [[OLD_BF_VALUE:%.+]] = phi i8 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 837// CHECK: [[BITCAST:%.+]] = bitcast i32* %{{.+}} to i8* 838// CHECK: store i8 [[OLD_BF_VALUE]], i8* [[BITCAST]], 839// CHECK: [[A_LD:%.+]] = load i8, i8* [[BITCAST]], 840// CHECK: [[A_ASHR:%.+]] = ashr i8 [[A_LD]], 7 841// CHECK: [[CAST:%.+]] = sext i8 [[A_ASHR]] to i32 842// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[CAST]] to x86_fp80 843// CHECK: [[DIV:%.+]] = fdiv x86_fp80 [[EXPR]], [[X_RVAL]] 844// CHECK: [[NEW_VAL:%.+]] = fptosi x86_fp80 [[DIV]] to i32 845// CHECK: [[TRUNC:%.+]] = trunc i32 [[NEW_VAL]] to i8 846// CHECK: [[BF_LD:%.+]] = load i8, i8* [[BITCAST]], 847// CHECK: [[BF_AND:%.+]] = and i8 [[TRUNC]], 1 848// CHECK: [[BF_VALUE:%.+]] = shl i8 [[BF_AND]], 7 849// CHECK: [[BF_CLEAR:%.+]] = and i8 %{{.+}}, 127 850// CHECK: or i8 [[BF_CLEAR]], [[BF_VALUE]] 851// CHECK: store i8 %{{.+}}, i8* [[LDTEMP:%.+]] 852// CHECK: [[NEW_BF_VALUE:%.+]] = load i8, i8* [[LDTEMP]] 853// CHECK: [[RES:%.+]] = cmpxchg i8* getelementptr (i8, i8* bitcast (%struct.BitFields2_packed* @{{.+}} to i8*), i64 3), i8 [[OLD_BF_VALUE]], i8 [[NEW_BF_VALUE]] monotonic monotonic 854// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i8, i1 } [[RES]], 0 855// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i8, i1 } [[RES]], 1 856// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 857// CHECK: [[EXIT]] 858#pragma omp atomic update 859 bfx2_packed.a = ldv / bfx2_packed.a; 860// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 861// CHECK: [[PREV_VALUE:%.+]] = load atomic i32, i32* getelementptr inbounds (%struct.BitFields3, %struct.BitFields3* @{{.+}}, i32 0, i32 0) monotonic 862// CHECK: br label %[[CONT:.+]] 863// CHECK: [[CONT]] 864// CHECK: [[OLD_BF_VALUE:%.+]] = phi i32 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 865// CHECK: store i32 [[OLD_BF_VALUE]], i32* [[TEMP:%.+]], 866// CHECK: [[A_LD:%.+]] = load i32, i32* [[TEMP]], 867// CHECK: [[A_SHL:%.+]] = shl i32 [[A_LD]], 7 868// CHECK: [[A_ASHR:%.+]] = ashr i32 [[A_SHL]], 18 869// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[A_ASHR]] to x86_fp80 870// CHECK: [[DIV:%.+]] = fdiv x86_fp80 [[X_RVAL]], [[EXPR]] 871// CHECK: [[NEW_VAL:%.+]] = fptosi x86_fp80 [[DIV]] to i32 872// CHECK: [[BF_LD:%.+]] = load i32, i32* [[TEMP]], 873// CHECK: [[BF_AND:%.+]] = and i32 [[NEW_VAL]], 16383 874// CHECK: [[BF_VALUE:%.+]] = shl i32 [[BF_AND]], 11 875// CHECK: [[BF_CLEAR:%.+]] = and i32 %{{.+}}, -33552385 876// CHECK: or i32 [[BF_CLEAR]], [[BF_VALUE]] 877// CHECK: store i32 %{{.+}}, i32* [[LDTEMP:%.+]] 878// CHECK: [[NEW_BF_VALUE:%.+]] = load i32, i32* [[LDTEMP]] 879// CHECK: [[RES:%.+]] = cmpxchg i32* getelementptr inbounds (%struct.BitFields3, %struct.BitFields3* @{{.+}}, i32 0, i32 0), i32 [[OLD_BF_VALUE]], i32 [[NEW_BF_VALUE]] monotonic monotonic 880// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i32, i1 } [[RES]], 0 881// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i32, i1 } [[RES]], 1 882// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 883// CHECK: [[EXIT]] 884#pragma omp atomic 885 bfx3.a /= ldv; 886// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 887// CHECK: [[LDTEMP:%.+]] = bitcast i32* %{{.+}} to i24* 888// CHECK: [[BITCAST:%.+]] = bitcast i24* %{{.+}} to i8* 889// CHECK: call void @__atomic_load(i64 3, i8* getelementptr (i8, i8* bitcast (%struct.BitFields3_packed* @{{.+}} to i8*), i64 1), i8* [[BITCAST]], i32 0) 890// CHECK: [[PREV_VALUE:%.+]] = load i24, i24* [[LDTEMP]] 891// CHECK: br label %[[CONT:.+]] 892// CHECK: [[CONT]] 893// CHECK: [[OLD_BF_VALUE:%.+]] = phi i24 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 894// CHECK: [[BITCAST:%.+]] = bitcast i32* %{{.+}} to i24* 895// CHECK: store i24 [[OLD_BF_VALUE]], i24* [[BITCAST]], 896// CHECK: [[A_LD:%.+]] = load i24, i24* [[BITCAST]], 897// CHECK: [[A_SHL:%.+]] = shl i24 [[A_LD]], 7 898// CHECK: [[A_ASHR:%.+]] = ashr i24 [[A_SHL]], 10 899// CHECK: [[CAST:%.+]] = sext i24 [[A_ASHR]] to i32 900// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[CAST]] to x86_fp80 901// CHECK: [[ADD:%.+]] = fadd x86_fp80 [[X_RVAL]], [[EXPR]] 902// CHECK: [[NEW_VAL:%.+]] = fptosi x86_fp80 [[ADD]] to i32 903// CHECK: [[TRUNC:%.+]] = trunc i32 [[NEW_VAL]] to i24 904// CHECK: [[BF_LD:%.+]] = load i24, i24* [[BITCAST]], 905// CHECK: [[BF_AND:%.+]] = and i24 [[TRUNC]], 16383 906// CHECK: [[BF_VALUE:%.+]] = shl i24 [[BF_AND]], 3 907// CHECK: [[BF_CLEAR:%.+]] = and i24 [[BF_LD]], -131065 908// CHECK: or i24 [[BF_CLEAR]], [[BF_VALUE]] 909// CHECK: store i24 %{{.+}}, i24* [[LDTEMP:%.+]] 910// CHECK: [[NEW_BF_VALUE:%.+]] = load i24, i24* [[LDTEMP]] 911// CHECK: [[TEMP_OLD_BF_ADDR:%.+]] = bitcast i32* %{{.+}} to i24* 912// CHECK: store i24 [[OLD_BF_VALUE]], i24* [[TEMP_OLD_BF_ADDR]] 913// CHECK: [[TEMP_NEW_BF_ADDR:%.+]] = bitcast i32* %{{.+}} to i24* 914// CHECK: store i24 [[NEW_BF_VALUE]], i24* [[TEMP_NEW_BF_ADDR]] 915// CHECK: [[BITCAST_TEMP_OLD_BF_ADDR:%.+]] = bitcast i24* [[TEMP_OLD_BF_ADDR]] to i8* 916// CHECK: [[BITCAST_TEMP_NEW_BF_ADDR:%.+]] = bitcast i24* [[TEMP_NEW_BF_ADDR]] to i8* 917// CHECK: [[FAIL_SUCCESS:%.+]] = call zeroext i1 @__atomic_compare_exchange(i64 3, i8* getelementptr (i8, i8* bitcast (%struct.BitFields3_packed* @{{.+}} to i8*), i64 1), i8* [[BITCAST_TEMP_OLD_BF_ADDR]], i8* [[BITCAST_TEMP_NEW_BF_ADDR]], i32 0, i32 0) 918// CHECK: [[FAILED_OLD_VAL]] = load i24, i24* [[TEMP_OLD_BF_ADDR]] 919// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 920// CHECK: [[EXIT]] 921#pragma omp atomic update 922 bfx3_packed.a += ldv; 923// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 924// CHECK: [[PREV_VALUE:%.+]] = load atomic i64, i64* bitcast (%struct.BitFields4* @{{.+}} to i64*) monotonic 925// CHECK: br label %[[CONT:.+]] 926// CHECK: [[CONT]] 927// CHECK: [[OLD_BF_VALUE:%.+]] = phi i64 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 928// CHECK: store i64 [[OLD_BF_VALUE]], i64* [[TEMP:%.+]], 929// CHECK: [[A_LD:%.+]] = load i64, i64* [[TEMP]], 930// CHECK: [[A_SHL:%.+]] = shl i64 [[A_LD]], 47 931// CHECK: [[A_ASHR:%.+]] = ashr i64 [[A_SHL:%.+]], 63 932// CHECK: [[A_CAST:%.+]] = trunc i64 [[A_ASHR:%.+]] to i32 933// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[CAST:%.+]] to x86_fp80 934// CHECK: [[MUL:%.+]] = fmul x86_fp80 [[X_RVAL]], [[EXPR]] 935// CHECK: [[NEW_VAL:%.+]] = fptosi x86_fp80 [[MUL]] to i32 936// CHECK: [[ZEXT:%.+]] = zext i32 [[NEW_VAL]] to i64 937// CHECK: [[BF_LD:%.+]] = load i64, i64* [[TEMP]], 938// CHECK: [[BF_AND:%.+]] = and i64 [[ZEXT]], 1 939// CHECK: [[BF_VALUE:%.+]] = shl i64 [[BF_AND]], 16 940// CHECK: [[BF_CLEAR:%.+]] = and i64 [[BF_LD]], -65537 941// CHECK: or i64 [[BF_CLEAR]], [[BF_VALUE]] 942// CHECK: store i64 %{{.+}}, i64* [[LDTEMP:%.+]] 943// CHECK: [[NEW_BF_VALUE:%.+]] = load i64, i64* [[LDTEMP]] 944// CHECK: [[RES:%.+]] = cmpxchg i64* bitcast (%struct.BitFields4* @{{.+}} to i64*), i64 [[OLD_BF_VALUE]], i64 [[NEW_BF_VALUE]] monotonic monotonic 945// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i64, i1 } [[RES]], 0 946// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i64, i1 } [[RES]], 1 947// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 948// CHECK: [[EXIT]] 949#pragma omp atomic 950 bfx4.a = bfx4.a * ldv; 951// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 952// CHECK: [[PREV_VALUE:%.+]] = load atomic i8, i8* getelementptr inbounds (%struct.BitFields4_packed, %struct.BitFields4_packed* @{{.+}}, i32 0, i32 0, i64 2) monotonic 953// CHECK: br label %[[CONT:.+]] 954// CHECK: [[CONT]] 955// CHECK: [[OLD_BF_VALUE:%.+]] = phi i8 [ [[PREV_VALUE]], %{{.+}} ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 956// CHECK: [[BITCAST:%.+]] = bitcast i32* %{{.+}} to i8* 957// CHECK: store i8 [[OLD_BF_VALUE]], i8* [[BITCAST]], 958// CHECK: [[A_LD:%.+]] = load i8, i8* [[BITCAST]], 959// CHECK: [[A_SHL:%.+]] = shl i8 [[A_LD]], 7 960// CHECK: [[A_ASHR:%.+]] = ashr i8 [[A_SHL:%.+]], 7 961// CHECK: [[CAST:%.+]] = sext i8 [[A_ASHR:%.+]] to i32 962// CHECK: [[CONV:%.+]] = sitofp i32 [[CAST]] to x86_fp80 963// CHECK: [[SUB: %.+]] = fsub x86_fp80 [[CONV]], [[EXPR]] 964// CHECK: [[CONV:%.+]] = fptosi x86_fp80 [[SUB:%.+]] to i32 965// CHECK: [[NEW_VAL:%.+]] = trunc i32 [[CONV]] to i8 966// CHECK: [[BF_LD:%.+]] = load i8, i8* [[BITCAST]], 967// CHECK: [[BF_VALUE:%.+]] = and i8 [[NEW_VAL]], 1 968// CHECK: [[BF_CLEAR:%.+]] = and i8 [[BF_LD]], -2 969// CHECK: or i8 [[BF_CLEAR]], [[BF_VALUE]] 970// CHECK: store i8 %{{.+}}, i8* [[LDTEMP:%.+]] 971// CHECK: [[NEW_BF_VALUE:%.+]] = load i8, i8* [[LDTEMP]] 972// CHECK: [[RES:%.+]] = cmpxchg i8* getelementptr inbounds (%struct.BitFields4_packed, %struct.BitFields4_packed* @{{.+}}, i32 0, i32 0, i64 2), i8 [[OLD_BF_VALUE]], i8 [[NEW_BF_VALUE]] monotonic monotonic 973// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i8, i1 } [[RES]], 0 974// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i8, i1 } [[RES]], 1 975// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 976// CHECK: [[EXIT]] 977#pragma omp atomic update 978 bfx4_packed.a -= ldv; 979// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 980// CHECK: [[PREV_VALUE:%.+]] = load atomic i64, i64* bitcast (%struct.BitFields4* @{{.+}} to i64*) monotonic 981// CHECK: br label %[[CONT:.+]] 982// CHECK: [[CONT]] 983// CHECK: [[OLD_BF_VALUE:%.+]] = phi i64 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 984// CHECK: store i64 [[OLD_BF_VALUE]], i64* [[TEMP:%.+]], 985// CHECK: [[A_LD:%.+]] = load i64, i64* [[TEMP]], 986// CHECK: [[A_SHL:%.+]] = shl i64 [[A_LD]], 40 987// CHECK: [[A_ASHR:%.+]] = ashr i64 [[A_SHL:%.+]], 57 988// CHECK: [[CONV:%.+]] = sitofp i64 [[A_ASHR]] to x86_fp80 989// CHECK: [[DIV:%.+]] = fdiv x86_fp80 [[CONV]], [[EXPR]] 990// CHECK: [[CONV:%.+]] = fptosi x86_fp80 [[DIV]] to i64 991// CHECK: [[BF_LD:%.+]] = load i64, i64* [[TEMP]], 992// CHECK: [[BF_AND:%.+]] = and i64 [[CONV]], 127 993// CHECK: [[BF_VALUE:%.+]] = shl i64 [[BF_AND:%.+]], 17 994// CHECK: [[BF_CLEAR:%.+]] = and i64 [[BF_LD]], -16646145 995// CHECK: [[VAL:%.+]] = or i64 [[BF_CLEAR]], [[BF_VALUE]] 996// CHECK: store i64 [[VAL]], i64* [[LDTEMP:%.+]] 997// CHECK: [[NEW_BF_VALUE:%.+]] = load i64, i64* [[LDTEMP]] 998// CHECK: [[RES:%.+]] = cmpxchg i64* bitcast (%struct.BitFields4* @{{.+}} to i64*), i64 [[OLD_BF_VALUE]], i64 [[NEW_BF_VALUE]] monotonic monotonic 999// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i64, i1 } [[RES]], 0 1000// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i64, i1 } [[RES]], 1 1001// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 1002// CHECK: [[EXIT]] 1003#pragma omp atomic 1004 bfx4.b /= ldv; 1005// CHECK: [[EXPR:%.+]] = load x86_fp80, x86_fp80* @{{.+}} 1006// CHECK: [[PREV_VALUE:%.+]] = load atomic i8, i8* getelementptr inbounds (%struct.BitFields4_packed, %struct.BitFields4_packed* @{{.+}}, i32 0, i32 0, i64 2) monotonic 1007// CHECK: br label %[[CONT:.+]] 1008// CHECK: [[CONT]] 1009// CHECK: [[OLD_BF_VALUE:%.+]] = phi i8 [ [[PREV_VALUE]], %[[EXIT]] ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 1010// CHECK: [[BITCAST:%.+]] = bitcast i64* %{{.+}} to i8* 1011// CHECK: store i8 [[OLD_BF_VALUE]], i8* [[BITCAST]], 1012// CHECK: [[A_LD:%.+]] = load i8, i8* [[BITCAST]], 1013// CHECK: [[A_ASHR:%.+]] = ashr i8 [[A_LD]], 1 1014// CHECK: [[CAST:%.+]] = sext i8 [[A_ASHR]] to i64 1015// CHECK: [[CONV:%.+]] = sitofp i64 [[CAST]] to x86_fp80 1016// CHECK: [[ADD:%.+]] = fadd x86_fp80 [[CONV]], [[EXPR]] 1017// CHECK: [[NEW_VAL:%.+]] = fptosi x86_fp80 [[ADD]] to i64 1018// CHECK: [[TRUNC:%.+]] = trunc i64 [[NEW_VAL]] to i8 1019// CHECK: [[BF_LD:%.+]] = load i8, i8* [[BITCAST]], 1020// CHECK: [[BF_AND:%.+]] = and i8 [[TRUNC]], 127 1021// CHECK: [[BF_VALUE:%.+]] = shl i8 [[BF_AND]], 1 1022// CHECK: [[BF_CLEAR:%.+]] = and i8 [[BF_LD]], 1 1023// CHECK: or i8 [[BF_CLEAR]], [[BF_VALUE]] 1024// CHECK: store i8 %{{.+}}, i8* [[LDTEMP:%.+]] 1025// CHECK: [[NEW_BF_VALUE:%.+]] = load i8, i8* [[LDTEMP]] 1026// CHECK: [[RES:%.+]] = cmpxchg i8* getelementptr inbounds (%struct.BitFields4_packed, %struct.BitFields4_packed* @{{.+}}, i32 0, i32 0, i64 2), i8 [[OLD_BF_VALUE]], i8 [[NEW_BF_VALUE]] monotonic monotonic 1027// CHECK: [[FAILED_OLD_VAL]] = extractvalue { i8, i1 } [[RES]], 0 1028// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i8, i1 } [[RES]], 1 1029// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 1030// CHECK: [[EXIT]] 1031#pragma omp atomic update 1032 bfx4_packed.b += ldv; 1033// CHECK: load i64, i64* 1034// CHECK: [[EXPR:%.+]] = uitofp i64 %{{.+}} to float 1035// CHECK: [[I64VAL:%.+]] = load atomic i64, i64* bitcast (<2 x float>* [[DEST:@.+]] to i64*) monotonic 1036// CHECK: [[LD:%.+]] = bitcast i64 [[I64VAL]] to <2 x float> 1037// CHECK: br label %[[CONT:.+]] 1038// CHECK: [[CONT]] 1039// CHECK: [[OLD_VEC_VAL:%.+]] = phi <2 x float> [ [[LD]], %{{.+}} ], [ [[FAILED_OLD_VAL:%.+]], %[[CONT]] ] 1040// CHECK: store <2 x float> [[OLD_VEC_VAL]], <2 x float>* [[LDTEMP:%.+]], 1041// CHECK: [[VEC_VAL:%.+]] = load <2 x float>, <2 x float>* [[LDTEMP]] 1042// CHECK: [[X:%.+]] = extractelement <2 x float> [[VEC_VAL]], i64 0 1043// CHECK: [[VEC_ITEM_VAL:%.+]] = fsub float [[EXPR]], [[X]] 1044// CHECK: [[VEC_VAL:%.+]] = load <2 x float>, <2 x float>* [[LDTEMP]], 1045// CHECK: [[NEW_VEC_VAL:%.+]] = insertelement <2 x float> [[VEC_VAL]], float [[VEC_ITEM_VAL]], i64 0 1046// CHECK: store <2 x float> [[NEW_VEC_VAL]], <2 x float>* [[LDTEMP]] 1047// CHECK: [[NEW_VEC_VAL:%.+]] = load <2 x float>, <2 x float>* [[LDTEMP]] 1048// CHECK: [[OLD_I64:%.+]] = bitcast <2 x float> [[OLD_VEC_VAL]] to i64 1049// CHECK: [[NEW_I64:%.+]] = bitcast <2 x float> [[NEW_VEC_VAL]] to i64 1050// CHECK: [[RES:%.+]] = cmpxchg i64* bitcast (<2 x float>* [[DEST]] to i64*), i64 [[OLD_I64]], i64 [[NEW_I64]] monotonic monotonic 1051// CHECK: [[FAILED_I64_OLD_VAL:%.+]] = extractvalue { i64, i1 } [[RES]], 0 1052// CHECK: [[FAIL_SUCCESS:%.+]] = extractvalue { i64, i1 } [[RES]], 1 1053// CHECK: [[FAILED_OLD_VAL]] = bitcast i64 [[FAILED_I64_OLD_VAL]] to <2 x float> 1054// CHECK: br i1 [[FAIL_SUCCESS]], label %[[EXIT:.+]], label %[[CONT]] 1055// CHECK: [[EXIT]] 1056#pragma omp atomic 1057 float2x.x = ulv - float2x.x; 1058// CHECK: [[EXPR:%.+]] = load double, double* @{{.+}}, 1059// CHECK: [[OLD_VAL:%.+]] = call i32 @llvm.read_register.i32([[REG:metadata ![0-9]+]]) 1060// CHECK: [[X_RVAL:%.+]] = sitofp i32 [[OLD_VAL]] to double 1061// CHECK: [[DIV:%.+]] = fdiv double [[EXPR]], [[X_RVAL]] 1062// CHECK: [[NEW_VAL:%.+]] = fptosi double [[DIV]] to i32 1063// CHECK: call void @llvm.write_register.i32([[REG]], i32 [[NEW_VAL]]) 1064// CHECK: call{{.*}} @__kmpc_flush( 1065#pragma omp atomic seq_cst 1066 rix = dv / rix; 1067 return 0; 1068} 1069 1070#endif 1071