clang/test/CodeGen/ms-intrinsics.c

   1 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
   2 // RUN:         -triple i686--windows -Oz -emit-llvm %s -o - \
   3 // RUN:         | FileCheck %s -check-prefixes CHECK,CHECK-I386,CHECK-INTEL
   4 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
   5 // RUN:         -triple thumbv7--windows -Oz -emit-llvm %s -o - \
   6 // RUN:         | FileCheck %s --check-prefixes CHECK,CHECK-ARM,CHECK-ARM-ARM64,CHECK-ARM-X64
   7 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
   8 // RUN:         -triple x86_64--windows -Oz -emit-llvm -target-feature +cx16 %s -o - \
   9 // RUN:         | FileCheck %s --check-prefixes CHECK,CHECK-X64,CHECK-ARM-X64,CHECK-INTEL
  10 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
  11 // RUN:         -triple aarch64-windows -Oz -emit-llvm %s -o - \
  12 // RUN:         | FileCheck %s --check-prefixes CHECK-ARM-ARM64,CHECK-ARM-X64,CHECK-ARM64
  13
  14 // intrin.h needs size_t, but -ffreestanding prevents us from getting it from
  15 // stddef.h.  Work around it with this typedef.
  16 typedef __SIZE_TYPE__ size_t;
  17
  18 #include <intrin.h>
  19
  20 #if defined(__i386__) || defined(__x86_64__)
  21 void test__stosb(unsigned char *Dest, unsigned char Data, size_t Count) {
  22   return __stosb(Dest, Data, Count);
  23 }
  24
  25 // CHECK-I386: define{{.*}}void @test__stosb
  26 // CHECK-I386:   tail call void @llvm.memset.p0i8.i32(i8* align 1 %Dest, i8 %Data, i32 %Count, i1 true)
  27 // CHECK-I386:   ret void
  28 // CHECK-I386: }
  29
  30 // CHECK-X64: define{{.*}}void @test__stosb
  31 // CHECK-X64:   tail call void @llvm.memset.p0i8.i64(i8* align 1 %Dest, i8 %Data, i64 %Count, i1 true)
  32 // CHECK-X64:   ret void
  33 // CHECK-X64: }
  34
  35 void test__movsb(unsigned char *Dest, unsigned char *Src, size_t Count) {
  36   return __movsb(Dest, Src, Count);
  37 }
  38 // CHECK-I386-LABEL: define{{.*}} void @test__movsb
  39 // CHECK-I386:   call { i8*, i8*, i32 } asm sideeffect "rep movsb", "={di},={si},={cx},0,1,2,~{memory},~{dirflag},~{fpsr},~{flags}"(i8* %Dest, i8* %Src, i32 %Count)
  40 // CHECK-I386:   ret void
  41 // CHECK-I386: }
  42
  43 // CHECK-X64-LABEL: define{{.*}} void @test__movsb
  44 // CHECK-X64:   call { i8*, i8*, i64 } asm sideeffect "rep movsb", "={di},={si},={cx},0,1,2,~{memory},~{dirflag},~{fpsr},~{flags}"(i8* %Dest, i8* %Src, i64 %Count)
  45 // CHECK-X64:   ret void
  46 // CHECK-X64: }
  47
  48 void test__stosw(unsigned short *Dest, unsigned short Data, size_t Count) {
  49   return __stosw(Dest, Data, Count);
  50 }
  51 // CHECK-I386-LABEL: define{{.*}} void @test__stosw
  52 // CHECK-I386:   call { i16*, i32 } asm sideeffect "rep stosw", "={di},={cx},{ax},0,1,~{memory},~{dirflag},~{fpsr},~{flags}"(i16 %Data, i16* %Dest, i32 %Count)
  53 // CHECK-I386:   ret void
  54 // CHECK-I386: }
  55
  56 // CHECK-X64-LABEL: define{{.*}} void @test__stosw
  57 // CHECK-X64:   call { i16*, i64 } asm sideeffect "rep stosw", "={di},={cx},{ax},0,1,~{memory},~{dirflag},~{fpsr},~{flags}"(i16 %Data, i16* %Dest, i64 %Count)
  58 // CHECK-X64:   ret void
  59 // CHECK-X64: }
  60
  61 void test__movsw(unsigned short *Dest, unsigned short *Src, size_t Count) {
  62   return __movsw(Dest, Src, Count);
  63 }
  64 // CHECK-I386-LABEL: define{{.*}} void @test__movsw
  65 // CHECK-I386:   call { i16*, i16*, i32 } asm sideeffect "rep movsw", "={di},={si},={cx},0,1,2,~{memory},~{dirflag},~{fpsr},~{flags}"(i16* %Dest, i16* %Src, i32 %Count)
  66 // CHECK-I386:   ret void
  67 // CHECK-I386: }
  68
  69 // CHECK-X64-LABEL: define{{.*}} void @test__movsw
  70 // CHECK-X64:   call { i16*, i16*, i64 } asm sideeffect "rep movsw", "={di},={si},={cx},0,1,2,~{memory},~{dirflag},~{fpsr},~{flags}"(i16* %Dest, i16* %Src, i64 %Count)
  71 // CHECK-X64:   ret void
  72 // CHECK-X64: }
  73
  74 void test__stosd(unsigned long *Dest, unsigned long Data, size_t Count) {
  75   return __stosd(Dest, Data, Count);
  76 }
  77 // CHECK-I386-LABEL: define{{.*}} void @test__stosd
  78 // CHECK-I386:   call { i32*, i32 } asm sideeffect "rep stosl", "={di},={cx},{ax},0,1,~{memory},~{dirflag},~{fpsr},~{flags}"(i32 %Data, i32* %Dest, i32 %Count)
  79 // CHECK-I386:   ret void
  80 // CHECK-I386: }
  81
  82 // CHECK-X64-LABEL: define{{.*}} void @test__stosd
  83 // CHECK-X64:   call { i32*, i64 } asm sideeffect "rep stosl", "={di},={cx},{ax},0,1,~{memory},~{dirflag},~{fpsr},~{flags}"(i32 %Data, i32* %Dest, i64 %Count)
  84 // CHECK-X64:   ret void
  85 // CHECK-X64: }
  86
  87 void test__movsd(unsigned long *Dest, unsigned long *Src, size_t Count) {
  88   return __movsd(Dest, Src, Count);
  89 }
  90 // CHECK-I386-LABEL: define{{.*}} void @test__movsd
  91 // CHECK-I386:   call { i32*, i32*, i32 } asm sideeffect "rep movsl", "={di},={si},={cx},0,1,2,~{memory},~{dirflag},~{fpsr},~{flags}"(i32* %Dest, i32* %Src, i32 %Count)
  92 // CHECK-I386:   ret void
  93 // CHECK-I386: }
  94
  95 // CHECK-X64-LABEL: define{{.*}} void @test__movsd
  96 // CHECK-X64:   call { i32*, i32*, i64 } asm sideeffect "rep movsl", "={di},={si},={cx},0,1,2,~{memory},~{dirflag},~{fpsr},~{flags}"(i32* %Dest, i32* %Src, i64 %Count)
  97 // CHECK-X64:   ret void
  98 // CHECK-X64: }
  99
 100 #ifdef __x86_64__
 101 void test__stosq(unsigned __int64 *Dest, unsigned __int64 Data, size_t Count) {
 102   return __stosq(Dest, Data, Count);
 103 }
 104 // CHECK-X64-LABEL: define{{.*}} void @test__stosq
 105 // CHECK-X64:   call { i64*, i64 } asm sideeffect "rep stosq", "={di},={cx},{ax},0,1,~{memory},~{dirflag},~{fpsr},~{flags}"(i64 %Data, i64* %Dest, i64 %Count)
 106 // CHECK-X64:   ret void
 107 // CHECK-X64: }
 108
 109 void test__movsq(unsigned __int64 *Dest, unsigned __int64 *Src, size_t Count) {
 110   return __movsq(Dest, Src, Count);
 111 }
 112 // CHECK-X64-LABEL: define{{.*}} void @test__movsq
 113 // CHECK-X64:   call { i64*, i64*, i64 } asm sideeffect "rep movsq", "={di},={si},={cx},0,1,2,~{memory},~{dirflag},~{fpsr},~{flags}"(i64* %Dest, i64* %Src, i64 %Count)
 114 // CHECK-X64:   ret void
 115 // CHECK-X64: }
 116 #endif
 117
 118 void test__ud2(void) {
 119   __ud2();
 120 }
 121 // CHECK-INTEL-LABEL: define{{.*}} void @test__ud2()
 122 // CHECK-INTEL: call void @llvm.trap()
 123
 124 void test__int2c(void) {
 125   __int2c();
 126 }
 127 // CHECK-INTEL-LABEL: define{{.*}} void @test__int2c()
 128 // CHECK-INTEL: call void asm sideeffect "int $$0x2c", ""() #[[NORETURN:[0-9]+]]
 129
 130
 131 #endif
 132
 133 void *test_ReturnAddress() {
 134   return _ReturnAddress();
 135 }
 136 // CHECK-LABEL: define{{.*}}i8* @test_ReturnAddress()
 137 // CHECK: = tail call i8* @llvm.returnaddress(i32 0)
 138 // CHECK: ret i8*
 139
 140 #if defined(__i386__) || defined(__x86_64__) || defined (__aarch64__)
 141 void *test_AddressOfReturnAddress() {
 142   return _AddressOfReturnAddress();
 143 }
 144 // CHECK-INTEL-LABEL: define dso_local i8* @test_AddressOfReturnAddress()
 145 // CHECK-INTEL: = tail call i8* @llvm.addressofreturnaddress.p0i8()
 146 // CHECK-INTEL: ret i8*
 147 #endif
 148
 149 unsigned char test_BitScanForward(unsigned long *Index, unsigned long Mask) {
 150   return _BitScanForward(++Index, Mask);
 151 }
 152 // CHECK: define{{.*}}i8 @test_BitScanForward(i32* {{[a-z_ ]*}}%Index, i32 {{[a-z_ ]*}}%Mask){{.*}}{
 153 // CHECK:   [[ISNOTZERO:%[a-z0-9._]+]] = icmp eq i32 %Mask, 0
 154 // CHECK:   br i1 [[ISNOTZERO]], label %[[END_LABEL:[a-z0-9._]+]], label %[[ISNOTZERO_LABEL:[a-z0-9._]+]]
 155 // CHECK:   [[END_LABEL]]:
 156 // CHECK:   [[RESULT:%[a-z0-9._]+]] = phi i8 [ 0, %[[ISZERO_LABEL:[a-z0-9._]+]] ], [ 1, %[[ISNOTZERO_LABEL]] ]
 157 // CHECK:   ret i8 [[RESULT]]
 158 // CHECK:   [[ISNOTZERO_LABEL]]:
 159 // CHECK:   [[IDXGEP:%[a-z0-9._]+]] = getelementptr inbounds i32, i32* %Index, {{i64|i32}} 1
 160 // CHECK:   [[INDEX:%[0-9]+]] = tail call i32 @llvm.cttz.i32(i32 %Mask, i1 true)
 161 // CHECK:   store i32 [[INDEX]], i32* [[IDXGEP]], align 4
 162 // CHECK:   br label %[[END_LABEL]]
 163
 164 unsigned char test_BitScanReverse(unsigned long *Index, unsigned long Mask) {
 165   return _BitScanReverse(++Index, Mask);
 166 }
 167 // CHECK: define{{.*}}i8 @test_BitScanReverse(i32* {{[a-z_ ]*}}%Index, i32 {{[a-z_ ]*}}%Mask){{.*}}{
 168 // CHECK:   [[ISNOTZERO:%[0-9]+]] = icmp eq i32 %Mask, 0
 169 // CHECK:   br i1 [[ISNOTZERO]], label %[[END_LABEL:[a-z0-9._]+]], label %[[ISNOTZERO_LABEL:[a-z0-9._]+]]
 170 // CHECK:   [[END_LABEL]]:
 171 // CHECK:   [[RESULT:%[a-z0-9._]+]] = phi i8 [ 0, %[[ISZERO_LABEL:[a-z0-9._]+]] ], [ 1, %[[ISNOTZERO_LABEL]] ]
 172 // CHECK:   ret i8 [[RESULT]]
 173 // CHECK:   [[ISNOTZERO_LABEL]]:
 174 // CHECK:   [[IDXGEP:%[a-z0-9._]+]] = getelementptr inbounds i32, i32* %Index, {{i64|i32}} 1
 175 // CHECK:   [[REVINDEX:%[0-9]+]] = tail call i32 @llvm.ctlz.i32(i32 %Mask, i1 true)
 176 // CHECK:   [[INDEX:%[0-9]+]] = xor i32 [[REVINDEX]], 31
 177 // CHECK:   store i32 [[INDEX]], i32* [[IDXGEP]], align 4
 178 // CHECK:   br label %[[END_LABEL]]
 179
 180 #if defined(__x86_64__) || defined(__arm__) || defined(__aarch64__)
 181 unsigned char test_BitScanForward64(unsigned long *Index, unsigned __int64 Mask) {
 182   return _BitScanForward64(Index, Mask);
 183 }
 184 // CHECK-ARM-X64: define{{.*}}i8 @test_BitScanForward64(i32* {{[a-z_ ]*}}%Index, i64 {{[a-z_ ]*}}%Mask){{.*}}{
 185 // CHECK-ARM-X64:   [[ISNOTZERO:%[a-z0-9._]+]] = icmp eq i64 %Mask, 0
 186 // CHECK-ARM-X64:   br i1 [[ISNOTZERO]], label %[[END_LABEL:[a-z0-9._]+]], label %[[ISNOTZERO_LABEL:[a-z0-9._]+]]
 187 // CHECK-ARM-X64:   [[END_LABEL]]:
 188 // CHECK-ARM-X64:   [[RESULT:%[a-z0-9._]+]] = phi i8 [ 0, %[[ISZERO_LABEL:[a-z0-9._]+]] ], [ 1, %[[ISNOTZERO_LABEL]] ]
 189 // CHECK-ARM-X64:   ret i8 [[RESULT]]
 190 // CHECK-ARM-X64:   [[ISNOTZERO_LABEL]]:
 191 // CHECK-ARM-X64:   [[INDEX:%[0-9]+]] = tail call i64 @llvm.cttz.i64(i64 %Mask, i1 true)
 192 // CHECK-ARM-X64:   [[TRUNC_INDEX:%[0-9]+]] = trunc i64 [[INDEX]] to i32
 193 // CHECK-ARM-X64:   store i32 [[TRUNC_INDEX]], i32* %Index, align 4
 194 // CHECK-ARM-X64:   br label %[[END_LABEL]]
 195
 196 unsigned char test_BitScanReverse64(unsigned long *Index, unsigned __int64 Mask) {
 197   return _BitScanReverse64(Index, Mask);
 198 }
 199 // CHECK-ARM-X64: define{{.*}}i8 @test_BitScanReverse64(i32* {{[a-z_ ]*}}%Index, i64 {{[a-z_ ]*}}%Mask){{.*}}{
 200 // CHECK-ARM-X64:   [[ISNOTZERO:%[0-9]+]] = icmp eq i64 %Mask, 0
 201 // CHECK-ARM-X64:   br i1 [[ISNOTZERO]], label %[[END_LABEL:[a-z0-9._]+]], label %[[ISNOTZERO_LABEL:[a-z0-9._]+]]
 202 // CHECK-ARM-X64:   [[END_LABEL]]:
 203 // CHECK-ARM-X64:   [[RESULT:%[a-z0-9._]+]] = phi i8 [ 0, %[[ISZERO_LABEL:[a-z0-9._]+]] ], [ 1, %[[ISNOTZERO_LABEL]] ]
 204 // CHECK-ARM-X64:   ret i8 [[RESULT]]
 205 // CHECK-ARM-X64:   [[ISNOTZERO_LABEL]]:
 206 // CHECK-ARM-X64:   [[REVINDEX:%[0-9]+]] = tail call i64 @llvm.ctlz.i64(i64 %Mask, i1 true)
 207 // CHECK-ARM-X64:   [[TRUNC_REVINDEX:%[0-9]+]] = trunc i64 [[REVINDEX]] to i32
 208 // CHECK-ARM-X64:   [[INDEX:%[0-9]+]] = xor i32 [[TRUNC_REVINDEX]], 63
 209 // CHECK-ARM-X64:   store i32 [[INDEX]], i32* %Index, align 4
 210 // CHECK-ARM-X64:   br label %[[END_LABEL]]
 211 #endif
 212
 213 void *test_InterlockedExchangePointer(void * volatile *Target, void *Value) {
 214   return _InterlockedExchangePointer(Target, Value);
 215 }
 216
 217 // CHECK: define{{.*}}i8* @test_InterlockedExchangePointer(i8** {{[a-z_ ]*}}%Target, i8* {{[a-z_ ]*}}%Value){{.*}}{
 218 // CHECK:   %[[TARGET:[0-9]+]] = bitcast i8** %Target to [[iPTR:i[0-9]+]]*
 219 // CHECK:   %[[VALUE:[0-9]+]] = ptrtoint i8* %Value to [[iPTR]]
 220 // CHECK:   %[[EXCHANGE:[0-9]+]] = atomicrmw xchg [[iPTR]]* %[[TARGET]], [[iPTR]] %[[VALUE]] seq_cst
 221 // CHECK:   %[[RESULT:[0-9]+]] = inttoptr [[iPTR]] %[[EXCHANGE]] to i8*
 222 // CHECK:   ret i8* %[[RESULT]]
 223 // CHECK: }
 224
 225 void *test_InterlockedCompareExchangePointer(void * volatile *Destination,
 226                                              void *Exchange, void *Comparand) {
 227   return _InterlockedCompareExchangePointer(Destination, Exchange, Comparand);
 228 }
 229
 230 // CHECK: define{{.*}}i8* @test_InterlockedCompareExchangePointer(i8** {{[a-z_ ]*}}%Destination, i8* {{[a-z_ ]*}}%Exchange, i8* {{[a-z_ ]*}}%Comparand){{.*}}{
 231 // CHECK:   %[[DEST:[0-9]+]] = bitcast i8** %Destination to [[iPTR]]*
 232 // CHECK:   %[[EXCHANGE:[0-9]+]] = ptrtoint i8* %Exchange to [[iPTR]]
 233 // CHECK:   %[[COMPARAND:[0-9]+]] = ptrtoint i8* %Comparand to [[iPTR]]
 234 // CHECK:   %[[XCHG:[0-9]+]] = cmpxchg volatile [[iPTR]]* %[[DEST:[0-9]+]], [[iPTR]] %[[COMPARAND:[0-9]+]], [[iPTR]] %[[EXCHANGE:[0-9]+]] seq_cst seq_cst
 235 // CHECK:   %[[EXTRACT:[0-9]+]] = extractvalue { [[iPTR]], i1 } %[[XCHG]], 0
 236 // CHECK:   %[[RESULT:[0-9]+]] = inttoptr [[iPTR]] %[[EXTRACT]] to i8*
 237 // CHECK:   ret i8* %[[RESULT:[0-9]+]]
 238 // CHECK: }
 239
 240 void *test_InterlockedCompareExchangePointer_nf(void * volatile *Destination,
 241                                              void *Exchange, void *Comparand) {
 242   return _InterlockedCompareExchangePointer_nf(Destination, Exchange, Comparand);
 243 }
 244
 245 // CHECK: define{{.*}}i8* @test_InterlockedCompareExchangePointer_nf(i8** {{[a-z_ ]*}}%Destination, i8* {{[a-z_ ]*}}%Exchange, i8* {{[a-z_ ]*}}%Comparand){{.*}}{
 246 // CHECK:   %[[DEST:[0-9]+]] = bitcast i8** %Destination to [[iPTR]]*
 247 // CHECK:   %[[EXCHANGE:[0-9]+]] = ptrtoint i8* %Exchange to [[iPTR]]
 248 // CHECK:   %[[COMPARAND:[0-9]+]] = ptrtoint i8* %Comparand to [[iPTR]]
 249 // CHECK:   %[[XCHG:[0-9]+]] = cmpxchg volatile [[iPTR]]* %[[DEST:[0-9]+]], [[iPTR]] %[[COMPARAND:[0-9]+]], [[iPTR]] %[[EXCHANGE:[0-9]+]] monotonic monotonic
 250 // CHECK:   %[[EXTRACT:[0-9]+]] = extractvalue { [[iPTR]], i1 } %[[XCHG]], 0
 251 // CHECK:   %[[RESULT:[0-9]+]] = inttoptr [[iPTR]] %[[EXTRACT]] to i8*
 252 // CHECK:   ret i8* %[[RESULT:[0-9]+]]
 253 // CHECK: }
 254
 255 char test_InterlockedExchange8(char volatile *value, char mask) {
 256   return _InterlockedExchange8(value, mask);
 257 }
 258 // CHECK: define{{.*}}i8 @test_InterlockedExchange8(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 259 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xchg i8* %value, i8 %mask seq_cst
 260 // CHECK:   ret i8 [[RESULT:%[0-9]+]]
 261 // CHECK: }
 262
 263 short test_InterlockedExchange16(short volatile *value, short mask) {
 264   return _InterlockedExchange16(value, mask);
 265 }
 266 // CHECK: define{{.*}}i16 @test_InterlockedExchange16(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 267 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xchg i16* %value, i16 %mask seq_cst
 268 // CHECK:   ret i16 [[RESULT:%[0-9]+]]
 269 // CHECK: }
 270
 271 long test_InterlockedExchange(long volatile *value, long mask) {
 272   return _InterlockedExchange(value, mask);
 273 }
 274 // CHECK: define{{.*}}i32 @test_InterlockedExchange(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 275 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xchg i32* %value, i32 %mask seq_cst
 276 // CHECK:   ret i32 [[RESULT:%[0-9]+]]
 277 // CHECK: }
 278
 279 char test_InterlockedExchangeAdd8(char volatile *value, char mask) {
 280   return _InterlockedExchangeAdd8(value, mask);
 281 }
 282 // CHECK: define{{.*}}i8 @test_InterlockedExchangeAdd8(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 283 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw add i8* %value, i8 %mask seq_cst
 284 // CHECK:   ret i8 [[RESULT:%[0-9]+]]
 285 // CHECK: }
 286
 287 short test_InterlockedExchangeAdd16(short volatile *value, short mask) {
 288   return _InterlockedExchangeAdd16(value, mask);
 289 }
 290 // CHECK: define{{.*}}i16 @test_InterlockedExchangeAdd16(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 291 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw add i16* %value, i16 %mask seq_cst
 292 // CHECK:   ret i16 [[RESULT:%[0-9]+]]
 293 // CHECK: }
 294
 295 long test_InterlockedExchangeAdd(long volatile *value, long mask) {
 296   return _InterlockedExchangeAdd(value, mask);
 297 }
 298 // CHECK: define{{.*}}i32 @test_InterlockedExchangeAdd(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 299 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw add i32* %value, i32 %mask seq_cst
 300 // CHECK:   ret i32 [[RESULT:%[0-9]+]]
 301 // CHECK: }
 302
 303 char test_InterlockedExchangeSub8(char volatile *value, char mask) {
 304   return _InterlockedExchangeSub8(value, mask);
 305 }
 306 // CHECK: define{{.*}}i8 @test_InterlockedExchangeSub8(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 307 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw sub i8* %value, i8 %mask seq_cst
 308 // CHECK:   ret i8 [[RESULT:%[0-9]+]]
 309 // CHECK: }
 310
 311 short test_InterlockedExchangeSub16(short volatile *value, short mask) {
 312   return _InterlockedExchangeSub16(value, mask);
 313 }
 314 // CHECK: define{{.*}}i16 @test_InterlockedExchangeSub16(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 315 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw sub i16* %value, i16 %mask seq_cst
 316 // CHECK:   ret i16 [[RESULT:%[0-9]+]]
 317 // CHECK: }
 318
 319 long test_InterlockedExchangeSub(long volatile *value, long mask) {
 320   return _InterlockedExchangeSub(value, mask);
 321 }
 322 // CHECK: define{{.*}}i32 @test_InterlockedExchangeSub(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 323 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw sub i32* %value, i32 %mask seq_cst
 324 // CHECK:   ret i32 [[RESULT:%[0-9]+]]
 325 // CHECK: }
 326
 327 char test_InterlockedOr8(char volatile *value, char mask) {
 328   return _InterlockedOr8(value, mask);
 329 }
 330 // CHECK: define{{.*}}i8 @test_InterlockedOr8(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 331 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw or i8* %value, i8 %mask seq_cst
 332 // CHECK:   ret i8 [[RESULT:%[0-9]+]]
 333 // CHECK: }
 334
 335 short test_InterlockedOr16(short volatile *value, short mask) {
 336   return _InterlockedOr16(value, mask);
 337 }
 338 // CHECK: define{{.*}}i16 @test_InterlockedOr16(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 339 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw or i16* %value, i16 %mask seq_cst
 340 // CHECK:   ret i16 [[RESULT:%[0-9]+]]
 341 // CHECK: }
 342
 343 long test_InterlockedOr(long volatile *value, long mask) {
 344   return _InterlockedOr(value, mask);
 345 }
 346 // CHECK: define{{.*}}i32 @test_InterlockedOr(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 347 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw or i32* %value, i32 %mask seq_cst
 348 // CHECK:   ret i32 [[RESULT:%[0-9]+]]
 349 // CHECK: }
 350
 351 char test_InterlockedXor8(char volatile *value, char mask) {
 352   return _InterlockedXor8(value, mask);
 353 }
 354 // CHECK: define{{.*}}i8 @test_InterlockedXor8(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 355 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xor i8* %value, i8 %mask seq_cst
 356 // CHECK:   ret i8 [[RESULT:%[0-9]+]]
 357 // CHECK: }
 358
 359 short test_InterlockedXor16(short volatile *value, short mask) {
 360   return _InterlockedXor16(value, mask);
 361 }
 362 // CHECK: define{{.*}}i16 @test_InterlockedXor16(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 363 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xor i16* %value, i16 %mask seq_cst
 364 // CHECK:   ret i16 [[RESULT:%[0-9]+]]
 365 // CHECK: }
 366
 367 long test_InterlockedXor(long volatile *value, long mask) {
 368   return _InterlockedXor(value, mask);
 369 }
 370 // CHECK: define{{.*}}i32 @test_InterlockedXor(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 371 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xor i32* %value, i32 %mask seq_cst
 372 // CHECK:   ret i32 [[RESULT:%[0-9]+]]
 373 // CHECK: }
 374
 375 char test_InterlockedAnd8(char volatile *value, char mask) {
 376   return _InterlockedAnd8(value, mask);
 377 }
 378 // CHECK: define{{.*}}i8 @test_InterlockedAnd8(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 379 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw and i8* %value, i8 %mask seq_cst
 380 // CHECK:   ret i8 [[RESULT:%[0-9]+]]
 381 // CHECK: }
 382
 383 short test_InterlockedAnd16(short volatile *value, short mask) {
 384   return _InterlockedAnd16(value, mask);
 385 }
 386 // CHECK: define{{.*}}i16 @test_InterlockedAnd16(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 387 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw and i16* %value, i16 %mask seq_cst
 388 // CHECK:   ret i16 [[RESULT:%[0-9]+]]
 389 // CHECK: }
 390
 391 long test_InterlockedAnd(long volatile *value, long mask) {
 392   return _InterlockedAnd(value, mask);
 393 }
 394 // CHECK: define{{.*}}i32 @test_InterlockedAnd(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 395 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw and i32* %value, i32 %mask seq_cst
 396 // CHECK:   ret i32 [[RESULT:%[0-9]+]]
 397 // CHECK: }
 398
 399 char test_InterlockedCompareExchange8(char volatile *Destination, char Exchange, char Comperand) {
 400   return _InterlockedCompareExchange8(Destination, Exchange, Comperand);
 401 }
 402 // CHECK: define{{.*}}i8 @test_InterlockedCompareExchange8(i8*{{[a-z_ ]*}}%Destination, i8{{[a-z_ ]*}}%Exchange, i8{{[a-z_ ]*}}%Comperand){{.*}}{
 403 // CHECK: [[TMP:%[0-9]+]] = cmpxchg volatile i8* %Destination, i8 %Comperand, i8 %Exchange seq_cst seq_cst
 404 // CHECK: [[RESULT:%[0-9]+]] = extractvalue { i8, i1 } [[TMP]], 0
 405 // CHECK: ret i8 [[RESULT]]
 406 // CHECK: }
 407
 408 short test_InterlockedCompareExchange16(short volatile *Destination, short Exchange, short Comperand) {
 409   return _InterlockedCompareExchange16(Destination, Exchange, Comperand);
 410 }
 411 // CHECK: define{{.*}}i16 @test_InterlockedCompareExchange16(i16*{{[a-z_ ]*}}%Destination, i16{{[a-z_ ]*}}%Exchange, i16{{[a-z_ ]*}}%Comperand){{.*}}{
 412 // CHECK: [[TMP:%[0-9]+]] = cmpxchg volatile i16* %Destination, i16 %Comperand, i16 %Exchange seq_cst seq_cst
 413 // CHECK: [[RESULT:%[0-9]+]] = extractvalue { i16, i1 } [[TMP]], 0
 414 // CHECK: ret i16 [[RESULT]]
 415 // CHECK: }
 416
 417 long test_InterlockedCompareExchange(long volatile *Destination, long Exchange, long Comperand) {
 418   return _InterlockedCompareExchange(Destination, Exchange, Comperand);
 419 }
 420 // CHECK: define{{.*}}i32 @test_InterlockedCompareExchange(i32*{{[a-z_ ]*}}%Destination, i32{{[a-z_ ]*}}%Exchange, i32{{[a-z_ ]*}}%Comperand){{.*}}{
 421 // CHECK: [[TMP:%[0-9]+]] = cmpxchg volatile i32* %Destination, i32 %Comperand, i32 %Exchange seq_cst seq_cst
 422 // CHECK: [[RESULT:%[0-9]+]] = extractvalue { i32, i1 } [[TMP]], 0
 423 // CHECK: ret i32 [[RESULT]]
 424 // CHECK: }
 425
 426 __int64 test_InterlockedCompareExchange64(__int64 volatile *Destination, __int64 Exchange, __int64 Comperand) {
 427   return _InterlockedCompareExchange64(Destination, Exchange, Comperand);
 428 }
 429 // CHECK: define{{.*}}i64 @test_InterlockedCompareExchange64(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%Exchange, i64{{[a-z_ ]*}}%Comperand){{.*}}{
 430 // CHECK: [[TMP:%[0-9]+]] = cmpxchg volatile i64* %Destination, i64 %Comperand, i64 %Exchange seq_cst seq_cst
 431 // CHECK: [[RESULT:%[0-9]+]] = extractvalue { i64, i1 } [[TMP]], 0
 432 // CHECK: ret i64 [[RESULT]]
 433 // CHECK: }
 434
 435 #if defined(__x86_64__)
 436 unsigned char test_InterlockedCompareExchange128(
 437     __int64 volatile *Destination, __int64 ExchangeHigh,
 438     __int64 ExchangeLow, __int64 *ComparandResult) {
 439   return _InterlockedCompareExchange128(++Destination, ++ExchangeHigh,
 440                                         ++ExchangeLow, ++ComparandResult);
 441 }
 442 // CHECK-X64: define{{.*}}i8 @test_InterlockedCompareExchange128(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%ExchangeHigh, i64{{[a-z_ ]*}}%ExchangeLow, i64*{{[a-z_ ]*}}%ComparandResult){{.*}}{
 443 // CHECK-X64: %incdec.ptr = getelementptr inbounds i64, i64* %Destination, i64 1
 444 // CHECK-X64: %inc = add nsw i64 %ExchangeHigh, 1
 445 // CHECK-X64: %inc1 = add nsw i64 %ExchangeLow, 1
 446 // CHECK-X64: %incdec.ptr2 = getelementptr inbounds i64, i64* %ComparandResult, i64 1
 447 // CHECK-X64: [[DST:%[0-9]+]] = bitcast i64* %incdec.ptr to i128*
 448 // CHECK-X64: [[EH:%[0-9]+]] = zext i64 %inc to i128
 449 // CHECK-X64: [[EL:%[0-9]+]] = zext i64 %inc1 to i128
 450 // CHECK-X64: [[CNR:%[0-9]+]] = bitcast i64* %incdec.ptr2 to i128*
 451 // CHECK-X64: [[EHS:%[0-9]+]] = shl nuw i128 [[EH]], 64
 452 // CHECK-X64: [[EXP:%[0-9]+]] = or i128 [[EHS]], [[EL]]
 453 // CHECK-X64: [[ORG:%[0-9]+]] = load i128, i128* [[CNR]], align 16
 454 // CHECK-X64: [[RES:%[0-9]+]] = cmpxchg volatile i128* [[DST]], i128 [[ORG]], i128 [[EXP]] seq_cst seq_cst
 455 // CHECK-X64: [[OLD:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 0
 456 // CHECK-X64: store i128 [[OLD]], i128* [[CNR]], align 16
 457 // CHECK-X64: [[SUC1:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 1
 458 // CHECK-X64: [[SUC8:%[0-9]+]] = zext i1 [[SUC1]] to i8
 459 // CHECK-X64: ret i8 [[SUC8]]
 460 // CHECK-X64: }
 461 #endif
 462
 463 short test_InterlockedIncrement16(short volatile *Addend) {
 464   return _InterlockedIncrement16(++Addend);
 465 }
 466 // CHECK: define{{.*}}i16 @test_InterlockedIncrement16(i16*{{[a-z_ ]*}}%Addend){{.*}}{
 467 // CHECK: %incdec.ptr = getelementptr inbounds i16, i16* %Addend, {{i64|i32}} 1
 468 // CHECK: [[TMP:%[0-9]+]] = atomicrmw add i16* %incdec.ptr, i16 1 seq_cst
 469 // CHECK: [[RESULT:%[0-9]+]] = add i16 [[TMP]], 1
 470 // CHECK: ret i16 [[RESULT]]
 471 // CHECK: }
 472
 473 long test_InterlockedIncrement(long volatile *Addend) {
 474   return _InterlockedIncrement(++Addend);
 475 }
 476 // CHECK: define{{.*}}i32 @test_InterlockedIncrement(i32*{{[a-z_ ]*}}%Addend){{.*}}{
 477 // CHECK: %incdec.ptr = getelementptr inbounds i32, i32* %Addend, {{i64|i32}} 1
 478 // CHECK: [[TMP:%[0-9]+]] = atomicrmw add i32* %incdec.ptr, i32 1 seq_cst
 479 // CHECK: [[RESULT:%[0-9]+]] = add i32 [[TMP]], 1
 480 // CHECK: ret i32 [[RESULT]]
 481 // CHECK: }
 482
 483 short test_InterlockedDecrement16(short volatile *Addend) {
 484   return _InterlockedDecrement16(Addend);
 485 }
 486 // CHECK: define{{.*}}i16 @test_InterlockedDecrement16(i16*{{[a-z_ ]*}}%Addend){{.*}}{
 487 // CHECK: [[TMP:%[0-9]+]] = atomicrmw sub i16* %Addend, i16 1 seq_cst
 488 // CHECK: [[RESULT:%[0-9]+]] = add i16 [[TMP]], -1
 489 // CHECK: ret i16 [[RESULT]]
 490 // CHECK: }
 491
 492 long test_InterlockedDecrement(long volatile *Addend) {
 493   return _InterlockedDecrement(Addend);
 494 }
 495 // CHECK: define{{.*}}i32 @test_InterlockedDecrement(i32*{{[a-z_ ]*}}%Addend){{.*}}{
 496 // CHECK: [[TMP:%[0-9]+]] = atomicrmw sub i32* %Addend, i32 1 seq_cst
 497 // CHECK: [[RESULT:%[0-9]+]] = add i32 [[TMP]], -1
 498 // CHECK: ret i32 [[RESULT]]
 499 // CHECK: }
 500
 501 char test_iso_volatile_load8(char volatile *p) { return __iso_volatile_load8(p); }
 502 short test_iso_volatile_load16(short volatile *p) { return __iso_volatile_load16(p); }
 503 int test_iso_volatile_load32(int volatile *p) { return __iso_volatile_load32(p); }
 504 __int64 test_iso_volatile_load64(__int64 volatile *p) { return __iso_volatile_load64(p); }
 505
 506 // CHECK: define{{.*}}i8 @test_iso_volatile_load8(i8*{{[a-z_ ]*}}%p)
 507 // CHECK: = load volatile i8, i8* %p
 508 // CHECK: define{{.*}}i16 @test_iso_volatile_load16(i16*{{[a-z_ ]*}}%p)
 509 // CHECK: = load volatile i16, i16* %p
 510 // CHECK: define{{.*}}i32 @test_iso_volatile_load32(i32*{{[a-z_ ]*}}%p)
 511 // CHECK: = load volatile i32, i32* %p
 512 // CHECK: define{{.*}}i64 @test_iso_volatile_load64(i64*{{[a-z_ ]*}}%p)
 513 // CHECK: = load volatile i64, i64* %p
 514
 515 void test_iso_volatile_store8(char volatile *p, char v) { __iso_volatile_store8(p, v); }
 516 void test_iso_volatile_store16(short volatile *p, short v) { __iso_volatile_store16(p, v); }
 517 void test_iso_volatile_store32(int volatile *p, int v) { __iso_volatile_store32(p, v); }
 518 void test_iso_volatile_store64(__int64 volatile *p, __int64 v) { __iso_volatile_store64(p, v); }
 519
 520 // CHECK: define{{.*}}void @test_iso_volatile_store8(i8*{{[a-z_ ]*}}%p, i8 {{[a-z_ ]*}}%v)
 521 // CHECK: store volatile i8 %v, i8* %p
 522 // CHECK: define{{.*}}void @test_iso_volatile_store16(i16*{{[a-z_ ]*}}%p, i16 {{[a-z_ ]*}}%v)
 523 // CHECK: store volatile i16 %v, i16* %p
 524 // CHECK: define{{.*}}void @test_iso_volatile_store32(i32*{{[a-z_ ]*}}%p, i32 {{[a-z_ ]*}}%v)
 525 // CHECK: store volatile i32 %v, i32* %p
 526 // CHECK: define{{.*}}void @test_iso_volatile_store64(i64*{{[a-z_ ]*}}%p, i64 {{[a-z_ ]*}}%v)
 527 // CHECK: store volatile i64 %v, i64* %p
 528
 529
 530 #if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__aarch64__)
 531 __int64 test_InterlockedExchange64(__int64 volatile *value, __int64 mask) {
 532   return _InterlockedExchange64(value, mask);
 533 }
 534 // CHECK: define{{.*}}i64 @test_InterlockedExchange64(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 535 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xchg i64* %value, i64 %mask seq_cst
 536 // CHECK:   ret i64 [[RESULT:%[0-9]+]]
 537 // CHECK: }
 538
 539 __int64 test_InterlockedExchangeAdd64(__int64 volatile *value, __int64 mask) {
 540   return _InterlockedExchangeAdd64(value, mask);
 541 }
 542 // CHECK: define{{.*}}i64 @test_InterlockedExchangeAdd64(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 543 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw add i64* %value, i64 %mask seq_cst
 544 // CHECK:   ret i64 [[RESULT:%[0-9]+]]
 545 // CHECK: }
 546
 547 __int64 test_InterlockedExchangeSub64(__int64 volatile *value, __int64 mask) {
 548   return _InterlockedExchangeSub64(value, mask);
 549 }
 550 // CHECK: define{{.*}}i64 @test_InterlockedExchangeSub64(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 551 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw sub i64* %value, i64 %mask seq_cst
 552 // CHECK:   ret i64 [[RESULT:%[0-9]+]]
 553 // CHECK: }
 554
 555 __int64 test_InterlockedOr64(__int64 volatile *value, __int64 mask) {
 556   return _InterlockedOr64(value, mask);
 557 }
 558 // CHECK: define{{.*}}i64 @test_InterlockedOr64(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 559 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw or i64* %value, i64 %mask seq_cst
 560 // CHECK:   ret i64 [[RESULT:%[0-9]+]]
 561 // CHECK: }
 562
 563 __int64 test_InterlockedXor64(__int64 volatile *value, __int64 mask) {
 564   return _InterlockedXor64(value, mask);
 565 }
 566 // CHECK: define{{.*}}i64 @test_InterlockedXor64(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 567 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw xor i64* %value, i64 %mask seq_cst
 568 // CHECK:   ret i64 [[RESULT:%[0-9]+]]
 569 // CHECK: }
 570
 571 __int64 test_InterlockedAnd64(__int64 volatile *value, __int64 mask) {
 572   return _InterlockedAnd64(value, mask);
 573 }
 574 // CHECK: define{{.*}}i64 @test_InterlockedAnd64(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 575 // CHECK:   [[RESULT:%[0-9]+]] = atomicrmw and i64* %value, i64 %mask seq_cst
 576 // CHECK:   ret i64 [[RESULT:%[0-9]+]]
 577 // CHECK: }
 578
 579 __int64 test_InterlockedIncrement64(__int64 volatile *Addend) {
 580   return _InterlockedIncrement64(Addend);
 581 }
 582 // CHECK: define{{.*}}i64 @test_InterlockedIncrement64(i64*{{[a-z_ ]*}}%Addend){{.*}}{
 583 // CHECK: [[TMP:%[0-9]+]] = atomicrmw add i64* %Addend, i64 1 seq_cst
 584 // CHECK: [[RESULT:%[0-9]+]] = add i64 [[TMP]], 1
 585 // CHECK: ret i64 [[RESULT]]
 586 // CHECK: }
 587
 588 __int64 test_InterlockedDecrement64(__int64 volatile *Addend) {
 589   return _InterlockedDecrement64(Addend);
 590 }
 591 // CHECK: define{{.*}}i64 @test_InterlockedDecrement64(i64*{{[a-z_ ]*}}%Addend){{.*}}{
 592 // CHECK: [[TMP:%[0-9]+]] = atomicrmw sub i64* %Addend, i64 1 seq_cst
 593 // CHECK: [[RESULT:%[0-9]+]] = add i64 [[TMP]], -1
 594 // CHECK: ret i64 [[RESULT]]
 595 // CHECK: }
 596
 597 #endif
 598
 599 #if defined(__i386__) || defined(__x86_64__)
 600 long test_InterlockedExchange_HLEAcquire(long volatile *Target, long Value) {
 601 // CHECK-INTEL: define{{.*}} i32 @test_InterlockedExchange_HLEAcquire(i32*{{[a-z_ ]*}}%Target, i32{{[a-z_ ]*}}%Value)
 602 // CHECK-INTEL: call i32 asm sideeffect ".byte 0xf2 ; lock ; xchg $0, $1", "=r,=*m,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i32* %Target, i32 %Value, i32* %Target)
 603   return _InterlockedExchange_HLEAcquire(Target, Value);
 604 }
 605 long test_InterlockedExchange_HLERelease(long volatile *Target, long Value) {
 606 // CHECK-INTEL: define{{.*}} i32 @test_InterlockedExchange_HLERelease(i32*{{[a-z_ ]*}}%Target, i32{{[a-z_ ]*}}%Value)
 607 // CHECK-INTEL: call i32 asm sideeffect ".byte 0xf3 ; lock ; xchg $0, $1", "=r,=*m,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i32* %Target, i32 %Value, i32* %Target)
 608   return _InterlockedExchange_HLERelease(Target, Value);
 609 }
 610 long test_InterlockedCompareExchange_HLEAcquire(long volatile *Destination,
 611                                                 long Exchange, long Comparand) {
 612 // CHECK-INTEL: define{{.*}} i32 @test_InterlockedCompareExchange_HLEAcquire(i32*{{[a-z_ ]*}}%Destination, i32{{[a-z_ ]*}}%Exchange, i32{{[a-z_ ]*}}%Comparand)
 613 // CHECK-INTEL: call i32 asm sideeffect ".byte 0xf2 ; lock ; cmpxchg $2, $1", "={ax},=*m,r,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i32* %Destination, i32 %Exchange, i32 %Comparand, i32* %Destination)
 614   return _InterlockedCompareExchange_HLEAcquire(Destination, Exchange, Comparand);
 615 }
 616 long test_InterlockedCompareExchange_HLERelease(long volatile *Destination,
 617                                             long Exchange, long Comparand) {
 618 // CHECK-INTEL: define{{.*}} i32 @test_InterlockedCompareExchange_HLERelease(i32*{{[a-z_ ]*}}%Destination, i32{{[a-z_ ]*}}%Exchange, i32{{[a-z_ ]*}}%Comparand)
 619 // CHECK-INTEL: call i32 asm sideeffect ".byte 0xf3 ; lock ; cmpxchg $2, $1", "={ax},=*m,r,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i32* %Destination, i32 %Exchange, i32 %Comparand, i32* %Destination)
 620   return _InterlockedCompareExchange_HLERelease(Destination, Exchange, Comparand);
 621 }
 622 #endif
 623 #if defined(__x86_64__)
 624 __int64 test_InterlockedExchange64_HLEAcquire(__int64 volatile *Target, __int64 Value) {
 625 // CHECK-X64: define{{.*}} i64 @test_InterlockedExchange64_HLEAcquire(i64*{{[a-z_ ]*}}%Target, i64{{[a-z_ ]*}}%Value)
 626 // CHECK-X64: call i64 asm sideeffect ".byte 0xf2 ; lock ; xchg $0, $1", "=r,=*m,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i64* %Target, i64 %Value, i64* %Target)
 627   return _InterlockedExchange64_HLEAcquire(Target, Value);
 628 }
 629 __int64 test_InterlockedExchange64_HLERelease(__int64 volatile *Target, __int64 Value) {
 630 // CHECK-X64: define{{.*}} i64 @test_InterlockedExchange64_HLERelease(i64*{{[a-z_ ]*}}%Target, i64{{[a-z_ ]*}}%Value)
 631 // CHECK-X64: call i64 asm sideeffect ".byte 0xf3 ; lock ; xchg $0, $1", "=r,=*m,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i64* %Target, i64 %Value, i64* %Target)
 632   return _InterlockedExchange64_HLERelease(Target, Value);
 633 }
 634 __int64 test_InterlockedCompareExchange64_HLEAcquire(__int64 volatile *Destination,
 635                                                      __int64 Exchange, __int64 Comparand) {
 636 // CHECK-X64: define{{.*}} i64 @test_InterlockedCompareExchange64_HLEAcquire(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%Exchange, i64{{[a-z_ ]*}}%Comparand)
 637 // CHECK-X64: call i64 asm sideeffect ".byte 0xf2 ; lock ; cmpxchg $2, $1", "={ax},=*m,r,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i64* %Destination, i64 %Exchange, i64 %Comparand, i64* %Destination)
 638   return _InterlockedCompareExchange64_HLEAcquire(Destination, Exchange, Comparand);
 639 }
 640 __int64 test_InterlockedCompareExchange64_HLERelease(__int64 volatile *Destination,
 641                                                      __int64 Exchange, __int64 Comparand) {
 642 // CHECK-X64: define{{.*}} i64 @test_InterlockedCompareExchange64_HLERelease(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%Exchange, i64{{[a-z_ ]*}}%Comparand)
 643 // CHECK-X64: call i64 asm sideeffect ".byte 0xf3 ; lock ; cmpxchg $2, $1", "={ax},=*m,r,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(i64* %Destination, i64 %Exchange, i64 %Comparand, i64* %Destination)
 644   return _InterlockedCompareExchange64_HLERelease(Destination, Exchange, Comparand);
 645 }
 646 #endif
 647
 648 #if defined(__arm__) || defined(__aarch64__)
 649 char test_InterlockedExchangeAdd8_acq(char volatile *value, char mask) {
 650   return _InterlockedExchangeAdd8_acq(value, mask);
 651 }
 652 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedExchangeAdd8_acq(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 653 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i8* %value, i8 %mask acquire
 654 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 655 // CHECK-ARM-ARM64: }
 656 char test_InterlockedExchangeAdd8_rel(char volatile *value, char mask) {
 657   return _InterlockedExchangeAdd8_rel(value, mask);
 658 }
 659 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedExchangeAdd8_rel(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 660 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i8* %value, i8 %mask release
 661 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 662 // CHECK-ARM-ARM64: }
 663 char test_InterlockedExchangeAdd8_nf(char volatile *value, char mask) {
 664   return _InterlockedExchangeAdd8_nf(value, mask);
 665 }
 666 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedExchangeAdd8_nf(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 667 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i8* %value, i8 %mask monotonic
 668 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 669 // CHECK-ARM-ARM64: }
 670 short test_InterlockedExchangeAdd16_acq(short volatile *value, short mask) {
 671   return _InterlockedExchangeAdd16_acq(value, mask);
 672 }
 673 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedExchangeAdd16_acq(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 674 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i16* %value, i16 %mask acquire
 675 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 676 // CHECK-ARM-ARM64: }
 677 short test_InterlockedExchangeAdd16_rel(short volatile *value, short mask) {
 678   return _InterlockedExchangeAdd16_rel(value, mask);
 679 }
 680 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedExchangeAdd16_rel(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 681 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i16* %value, i16 %mask release
 682 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 683 // CHECK-ARM-ARM64: }
 684 short test_InterlockedExchangeAdd16_nf(short volatile *value, short mask) {
 685   return _InterlockedExchangeAdd16_nf(value, mask);
 686 }
 687 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedExchangeAdd16_nf(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 688 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i16* %value, i16 %mask monotonic
 689 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 690 // CHECK-ARM-ARM64: }
 691 long test_InterlockedExchangeAdd_acq(long volatile *value, long mask) {
 692   return _InterlockedExchangeAdd_acq(value, mask);
 693 }
 694 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedExchangeAdd_acq(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 695 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i32* %value, i32 %mask acquire
 696 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 697 // CHECK-ARM-ARM64: }
 698 long test_InterlockedExchangeAdd_rel(long volatile *value, long mask) {
 699   return _InterlockedExchangeAdd_rel(value, mask);
 700 }
 701 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedExchangeAdd_rel(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 702 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i32* %value, i32 %mask release
 703 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 704 // CHECK-ARM-ARM64: }
 705 long test_InterlockedExchangeAdd_nf(long volatile *value, long mask) {
 706   return _InterlockedExchangeAdd_nf(value, mask);
 707 }
 708 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedExchangeAdd_nf(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 709 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i32* %value, i32 %mask monotonic
 710 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 711 // CHECK-ARM-ARM64: }
 712 __int64 test_InterlockedExchangeAdd64_acq(__int64 volatile *value, __int64 mask) {
 713   return _InterlockedExchangeAdd64_acq(value, mask);
 714 }
 715 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedExchangeAdd64_acq(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 716 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i64* %value, i64 %mask acquire
 717 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
 718 // CHECK-ARM-ARM64: }
 719 __int64 test_InterlockedExchangeAdd64_rel(__int64 volatile *value, __int64 mask) {
 720   return _InterlockedExchangeAdd64_rel(value, mask);
 721 }
 722 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedExchangeAdd64_rel(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 723 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i64* %value, i64 %mask release
 724 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
 725 // CHECK-ARM-ARM64: }
 726 __int64 test_InterlockedExchangeAdd64_nf(__int64 volatile *value, __int64 mask) {
 727   return _InterlockedExchangeAdd64_nf(value, mask);
 728 }
 729 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedExchangeAdd64_nf(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 730 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw add i64* %value, i64 %mask monotonic
 731 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
 732 // CHECK-ARM-ARM64: }
 733
 734 char test_InterlockedExchange8_acq(char volatile *value, char mask) {
 735   return _InterlockedExchange8_acq(value, mask);
 736 }
 737 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedExchange8_acq(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 738 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i8* %value, i8 %mask acquire
 739 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 740 // CHECK-ARM-ARM64: }
 741 char test_InterlockedExchange8_rel(char volatile *value, char mask) {
 742   return _InterlockedExchange8_rel(value, mask);
 743 }
 744 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedExchange8_rel(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 745 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i8* %value, i8 %mask release
 746 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 747 // CHECK-ARM-ARM64: }
 748 char test_InterlockedExchange8_nf(char volatile *value, char mask) {
 749   return _InterlockedExchange8_nf(value, mask);
 750 }
 751 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedExchange8_nf(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 752 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i8* %value, i8 %mask monotonic
 753 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 754 // CHECK-ARM-ARM64: }
 755 short test_InterlockedExchange16_acq(short volatile *value, short mask) {
 756   return _InterlockedExchange16_acq(value, mask);
 757 }
 758 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedExchange16_acq(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 759 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i16* %value, i16 %mask acquire
 760 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 761 // CHECK-ARM-ARM64: }
 762 short test_InterlockedExchange16_rel(short volatile *value, short mask) {
 763   return _InterlockedExchange16_rel(value, mask);
 764 }
 765 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedExchange16_rel(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 766 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i16* %value, i16 %mask release
 767 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 768 // CHECK-ARM-ARM64: }
 769 short test_InterlockedExchange16_nf(short volatile *value, short mask) {
 770   return _InterlockedExchange16_nf(value, mask);
 771 }
 772 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedExchange16_nf(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 773 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i16* %value, i16 %mask monotonic
 774 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 775 // CHECK-ARM-ARM64: }
 776 long test_InterlockedExchange_acq(long volatile *value, long mask) {
 777   return _InterlockedExchange_acq(value, mask);
 778 }
 779 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedExchange_acq(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 780 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i32* %value, i32 %mask acquire
 781 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 782 // CHECK-ARM-ARM64: }
 783 long test_InterlockedExchange_rel(long volatile *value, long mask) {
 784   return _InterlockedExchange_rel(value, mask);
 785 }
 786 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedExchange_rel(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 787 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i32* %value, i32 %mask release
 788 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 789 // CHECK-ARM-ARM64: }
 790 long test_InterlockedExchange_nf(long volatile *value, long mask) {
 791   return _InterlockedExchange_nf(value, mask);
 792 }
 793 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedExchange_nf(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 794 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i32* %value, i32 %mask monotonic
 795 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 796 // CHECK-ARM-ARM64: }
 797 __int64 test_InterlockedExchange64_acq(__int64 volatile *value, __int64 mask) {
 798   return _InterlockedExchange64_acq(value, mask);
 799 }
 800 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedExchange64_acq(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 801 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i64* %value, i64 %mask acquire
 802 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
 803 // CHECK-ARM-ARM64: }
 804 __int64 test_InterlockedExchange64_rel(__int64 volatile *value, __int64 mask) {
 805   return _InterlockedExchange64_rel(value, mask);
 806 }
 807 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedExchange64_rel(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 808 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i64* %value, i64 %mask release
 809 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
 810 // CHECK-ARM-ARM64: }
 811 __int64 test_InterlockedExchange64_nf(__int64 volatile *value, __int64 mask) {
 812   return _InterlockedExchange64_nf(value, mask);
 813 }
 814 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedExchange64_nf(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
 815 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xchg i64* %value, i64 %mask monotonic
 816 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
 817 // CHECK-ARM-ARM64: }
 818
 819 char test_InterlockedCompareExchange8_acq(char volatile *Destination, char Exchange, char Comperand) {
 820   return _InterlockedCompareExchange8_acq(Destination, Exchange, Comperand);
 821 }
 822 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedCompareExchange8_acq(i8*{{[a-z_ ]*}}%Destination, i8{{[a-z_ ]*}}%Exchange, i8{{[a-z_ ]*}}%Comperand){{.*}}{
 823 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i8* %Destination, i8 %Comperand, i8 %Exchange acquire acquire
 824 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i8, i1 } [[TMP]], 0
 825 // CHECK-ARM-ARM64: ret i8 [[RESULT]]
 826 // CHECK-ARM-ARM64: }
 827
 828 char test_InterlockedCompareExchange8_rel(char volatile *Destination, char Exchange, char Comperand) {
 829   return _InterlockedCompareExchange8_rel(Destination, Exchange, Comperand);
 830 }
 831 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedCompareExchange8_rel(i8*{{[a-z_ ]*}}%Destination, i8{{[a-z_ ]*}}%Exchange, i8{{[a-z_ ]*}}%Comperand){{.*}}{
 832 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i8* %Destination, i8 %Comperand, i8 %Exchange release monotonic
 833 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i8, i1 } [[TMP]], 0
 834 // CHECK-ARM-ARM64: ret i8 [[RESULT]]
 835 // CHECK-ARM-ARM64: }
 836
 837 char test_InterlockedCompareExchange8_nf(char volatile *Destination, char Exchange, char Comperand) {
 838   return _InterlockedCompareExchange8_nf(Destination, Exchange, Comperand);
 839 }
 840 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedCompareExchange8_nf(i8*{{[a-z_ ]*}}%Destination, i8{{[a-z_ ]*}}%Exchange, i8{{[a-z_ ]*}}%Comperand){{.*}}{
 841 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i8* %Destination, i8 %Comperand, i8 %Exchange monotonic monotonic
 842 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i8, i1 } [[TMP]], 0
 843 // CHECK-ARM-ARM64: ret i8 [[RESULT]]
 844 // CHECK-ARM-ARM64: }
 845
 846 short test_InterlockedCompareExchange16_acq(short volatile *Destination, short Exchange, short Comperand) {
 847   return _InterlockedCompareExchange16_acq(Destination, Exchange, Comperand);
 848 }
 849 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedCompareExchange16_acq(i16*{{[a-z_ ]*}}%Destination, i16{{[a-z_ ]*}}%Exchange, i16{{[a-z_ ]*}}%Comperand){{.*}}{
 850 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i16* %Destination, i16 %Comperand, i16 %Exchange acquire acquire
 851 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i16, i1 } [[TMP]], 0
 852 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
 853 // CHECK-ARM-ARM64: }
 854
 855 short test_InterlockedCompareExchange16_rel(short volatile *Destination, short Exchange, short Comperand) {
 856   return _InterlockedCompareExchange16_rel(Destination, Exchange, Comperand);
 857 }
 858 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedCompareExchange16_rel(i16*{{[a-z_ ]*}}%Destination, i16{{[a-z_ ]*}}%Exchange, i16{{[a-z_ ]*}}%Comperand){{.*}}{
 859 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i16* %Destination, i16 %Comperand, i16 %Exchange release monotonic
 860 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i16, i1 } [[TMP]], 0
 861 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
 862 // CHECK-ARM-ARM64: }
 863
 864 short test_InterlockedCompareExchange16_nf(short volatile *Destination, short Exchange, short Comperand) {
 865   return _InterlockedCompareExchange16_nf(Destination, Exchange, Comperand);
 866 }
 867 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedCompareExchange16_nf(i16*{{[a-z_ ]*}}%Destination, i16{{[a-z_ ]*}}%Exchange, i16{{[a-z_ ]*}}%Comperand){{.*}}{
 868 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i16* %Destination, i16 %Comperand, i16 %Exchange monotonic monotonic
 869 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i16, i1 } [[TMP]], 0
 870 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
 871 // CHECK-ARM-ARM64: }
 872
 873 long test_InterlockedCompareExchange_acq(long volatile *Destination, long Exchange, long Comperand) {
 874   return _InterlockedCompareExchange_acq(Destination, Exchange, Comperand);
 875 }
 876 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedCompareExchange_acq(i32*{{[a-z_ ]*}}%Destination, i32{{[a-z_ ]*}}%Exchange, i32{{[a-z_ ]*}}%Comperand){{.*}}{
 877 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i32* %Destination, i32 %Comperand, i32 %Exchange acquire acquire
 878 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i32, i1 } [[TMP]], 0
 879 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
 880 // CHECK-ARM-ARM64: }
 881
 882 long test_InterlockedCompareExchange_rel(long volatile *Destination, long Exchange, long Comperand) {
 883   return _InterlockedCompareExchange_rel(Destination, Exchange, Comperand);
 884 }
 885 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedCompareExchange_rel(i32*{{[a-z_ ]*}}%Destination, i32{{[a-z_ ]*}}%Exchange, i32{{[a-z_ ]*}}%Comperand){{.*}}{
 886 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i32* %Destination, i32 %Comperand, i32 %Exchange release monotonic
 887 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i32, i1 } [[TMP]], 0
 888 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
 889 // CHECK-ARM-ARM64: }
 890
 891 long test_InterlockedCompareExchange_nf(long volatile *Destination, long Exchange, long Comperand) {
 892   return _InterlockedCompareExchange_nf(Destination, Exchange, Comperand);
 893 }
 894 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedCompareExchange_nf(i32*{{[a-z_ ]*}}%Destination, i32{{[a-z_ ]*}}%Exchange, i32{{[a-z_ ]*}}%Comperand){{.*}}{
 895 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i32* %Destination, i32 %Comperand, i32 %Exchange monotonic monotonic
 896 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i32, i1 } [[TMP]], 0
 897 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
 898 // CHECK-ARM-ARM64: }
 899
 900 __int64 test_InterlockedCompareExchange64_acq(__int64 volatile *Destination, __int64 Exchange, __int64 Comperand) {
 901   return _InterlockedCompareExchange64_acq(Destination, Exchange, Comperand);
 902 }
 903 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedCompareExchange64_acq(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%Exchange, i64{{[a-z_ ]*}}%Comperand){{.*}}{
 904 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i64* %Destination, i64 %Comperand, i64 %Exchange acquire acquire
 905 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i64, i1 } [[TMP]], 0
 906 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
 907 // CHECK-ARM-ARM64: }
 908
 909 __int64 test_InterlockedCompareExchange64_rel(__int64 volatile *Destination, __int64 Exchange, __int64 Comperand) {
 910   return _InterlockedCompareExchange64_rel(Destination, Exchange, Comperand);
 911 }
 912 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedCompareExchange64_rel(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%Exchange, i64{{[a-z_ ]*}}%Comperand){{.*}}{
 913 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i64* %Destination, i64 %Comperand, i64 %Exchange release monotonic
 914 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i64, i1 } [[TMP]], 0
 915 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
 916 // CHECK-ARM-ARM64: }
 917
 918 __int64 test_InterlockedCompareExchange64_nf(__int64 volatile *Destination, __int64 Exchange, __int64 Comperand) {
 919   return _InterlockedCompareExchange64_nf(Destination, Exchange, Comperand);
 920 }
 921 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedCompareExchange64_nf(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%Exchange, i64{{[a-z_ ]*}}%Comperand){{.*}}{
 922 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = cmpxchg volatile i64* %Destination, i64 %Comperand, i64 %Exchange monotonic monotonic
 923 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = extractvalue { i64, i1 } [[TMP]], 0
 924 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
 925 // CHECK-ARM-ARM64: }
 926
 927 char test_InterlockedOr8_acq(char volatile *value, char mask) {
 928   return _InterlockedOr8_acq(value, mask);
 929 }
 930 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedOr8_acq(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 931 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i8* %value, i8 %mask acquire
 932 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 933 // CHECK-ARM-ARM64: }
 934
 935 char test_InterlockedOr8_rel(char volatile *value, char mask) {
 936   return _InterlockedOr8_rel(value, mask);
 937 }
 938 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedOr8_rel(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 939 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i8* %value, i8 %mask release
 940 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 941 // CHECK-ARM-ARM64: }
 942
 943 char test_InterlockedOr8_nf(char volatile *value, char mask) {
 944   return _InterlockedOr8_nf(value, mask);
 945 }
 946 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedOr8_nf(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
 947 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i8* %value, i8 %mask monotonic
 948 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
 949 // CHECK-ARM-ARM64: }
 950
 951 short test_InterlockedOr16_acq(short volatile *value, short mask) {
 952   return _InterlockedOr16_acq(value, mask);
 953 }
 954 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedOr16_acq(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 955 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i16* %value, i16 %mask acquire
 956 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 957 // CHECK-ARM-ARM64: }
 958
 959 short test_InterlockedOr16_rel(short volatile *value, short mask) {
 960   return _InterlockedOr16_rel(value, mask);
 961 }
 962 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedOr16_rel(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 963 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i16* %value, i16 %mask release
 964 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 965 // CHECK-ARM-ARM64: }
 966
 967 short test_InterlockedOr16_nf(short volatile *value, short mask) {
 968   return _InterlockedOr16_nf(value, mask);
 969 }
 970 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedOr16_nf(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
 971 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i16* %value, i16 %mask monotonic
 972 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
 973 // CHECK-ARM-ARM64: }
 974
 975 long test_InterlockedOr_acq(long volatile *value, long mask) {
 976   return _InterlockedOr_acq(value, mask);
 977 }
 978 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedOr_acq(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 979 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i32* %value, i32 %mask acquire
 980 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 981 // CHECK-ARM-ARM64: }
 982
 983 long test_InterlockedOr_rel(long volatile *value, long mask) {
 984   return _InterlockedOr_rel(value, mask);
 985 }
 986 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedOr_rel(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 987 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i32* %value, i32 %mask release
 988 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 989 // CHECK-ARM-ARM64: }
 990
 991 long test_InterlockedOr_nf(long volatile *value, long mask) {
 992   return _InterlockedOr_nf(value, mask);
 993 }
 994 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedOr_nf(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
 995 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i32* %value, i32 %mask monotonic
 996 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
 997 // CHECK-ARM-ARM64: }
 998
 999 __int64 test_InterlockedOr64_acq(__int64 volatile *value, __int64 mask) {
1000   return _InterlockedOr64_acq(value, mask);
1001 }
1002 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedOr64_acq(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1003 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i64* %value, i64 %mask acquire
1004 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1005 // CHECK-ARM-ARM64: }
1006
1007 __int64 test_InterlockedOr64_rel(__int64 volatile *value, __int64 mask) {
1008   return _InterlockedOr64_rel(value, mask);
1009 }
1010 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedOr64_rel(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1011 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i64* %value, i64 %mask release
1012 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1013 // CHECK-ARM-ARM64: }
1014
1015 __int64 test_InterlockedOr64_nf(__int64 volatile *value, __int64 mask) {
1016   return _InterlockedOr64_nf(value, mask);
1017 }
1018 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedOr64_nf(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1019 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw or i64* %value, i64 %mask monotonic
1020 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1021 // CHECK-ARM-ARM64: }
1022
1023 char test_InterlockedXor8_acq(char volatile *value, char mask) {
1024   return _InterlockedXor8_acq(value, mask);
1025 }
1026 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedXor8_acq(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
1027 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i8* %value, i8 %mask acquire
1028 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
1029 // CHECK-ARM-ARM64: }
1030
1031 char test_InterlockedXor8_rel(char volatile *value, char mask) {
1032   return _InterlockedXor8_rel(value, mask);
1033 }
1034 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedXor8_rel(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
1035 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i8* %value, i8 %mask release
1036 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
1037 // CHECK-ARM-ARM64: }
1038
1039 char test_InterlockedXor8_nf(char volatile *value, char mask) {
1040   return _InterlockedXor8_nf(value, mask);
1041 }
1042 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedXor8_nf(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
1043 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i8* %value, i8 %mask monotonic
1044 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
1045 // CHECK-ARM-ARM64: }
1046
1047 short test_InterlockedXor16_acq(short volatile *value, short mask) {
1048   return _InterlockedXor16_acq(value, mask);
1049 }
1050 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedXor16_acq(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
1051 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i16* %value, i16 %mask acquire
1052 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
1053 // CHECK-ARM-ARM64: }
1054
1055 short test_InterlockedXor16_rel(short volatile *value, short mask) {
1056   return _InterlockedXor16_rel(value, mask);
1057 }
1058 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedXor16_rel(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
1059 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i16* %value, i16 %mask release
1060 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
1061 // CHECK-ARM-ARM64: }
1062
1063 short test_InterlockedXor16_nf(short volatile *value, short mask) {
1064   return _InterlockedXor16_nf(value, mask);
1065 }
1066 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedXor16_nf(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
1067 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i16* %value, i16 %mask monotonic
1068 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
1069 // CHECK-ARM-ARM64: }
1070
1071 long test_InterlockedXor_acq(long volatile *value, long mask) {
1072   return _InterlockedXor_acq(value, mask);
1073 }
1074 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedXor_acq(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
1075 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i32* %value, i32 %mask acquire
1076 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
1077 // CHECK-ARM-ARM64: }
1078
1079 long test_InterlockedXor_rel(long volatile *value, long mask) {
1080   return _InterlockedXor_rel(value, mask);
1081 }
1082 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedXor_rel(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
1083 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i32* %value, i32 %mask release
1084 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
1085 // CHECK-ARM-ARM64: }
1086
1087 long test_InterlockedXor_nf(long volatile *value, long mask) {
1088   return _InterlockedXor_nf(value, mask);
1089 }
1090 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedXor_nf(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
1091 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i32* %value, i32 %mask monotonic
1092 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
1093 // CHECK-ARM-ARM64: }
1094
1095 __int64 test_InterlockedXor64_acq(__int64 volatile *value, __int64 mask) {
1096   return _InterlockedXor64_acq(value, mask);
1097 }
1098 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedXor64_acq(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1099 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i64* %value, i64 %mask acquire
1100 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1101 // CHECK-ARM-ARM64: }
1102
1103 __int64 test_InterlockedXor64_rel(__int64 volatile *value, __int64 mask) {
1104   return _InterlockedXor64_rel(value, mask);
1105 }
1106 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedXor64_rel(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1107 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i64* %value, i64 %mask release
1108 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1109 // CHECK-ARM-ARM64: }
1110
1111 __int64 test_InterlockedXor64_nf(__int64 volatile *value, __int64 mask) {
1112   return _InterlockedXor64_nf(value, mask);
1113 }
1114 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedXor64_nf(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1115 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw xor i64* %value, i64 %mask monotonic
1116 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1117 // CHECK-ARM-ARM64: }
1118
1119 char test_InterlockedAnd8_acq(char volatile *value, char mask) {
1120   return _InterlockedAnd8_acq(value, mask);
1121 }
1122 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedAnd8_acq(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
1123 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i8* %value, i8 %mask acquire
1124 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
1125 // CHECK-ARM-ARM64: }
1126
1127 char test_InterlockedAnd8_rel(char volatile *value, char mask) {
1128   return _InterlockedAnd8_rel(value, mask);
1129 }
1130 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedAnd8_rel(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
1131 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i8* %value, i8 %mask release
1132 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
1133 // CHECK-ARM-ARM64: }
1134
1135 char test_InterlockedAnd8_nf(char volatile *value, char mask) {
1136   return _InterlockedAnd8_nf(value, mask);
1137 }
1138 // CHECK-ARM-ARM64: define{{.*}}i8 @test_InterlockedAnd8_nf(i8*{{[a-z_ ]*}}%value, i8{{[a-z_ ]*}}%mask){{.*}}{
1139 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i8* %value, i8 %mask monotonic
1140 // CHECK-ARM-ARM64:   ret i8 [[RESULT:%[0-9]+]]
1141 // CHECK-ARM-ARM64: }
1142
1143 short test_InterlockedAnd16_acq(short volatile *value, short mask) {
1144   return _InterlockedAnd16_acq(value, mask);
1145 }
1146 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedAnd16_acq(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
1147 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i16* %value, i16 %mask acquire
1148 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
1149 // CHECK-ARM-ARM64: }
1150
1151 short test_InterlockedAnd16_rel(short volatile *value, short mask) {
1152   return _InterlockedAnd16_rel(value, mask);
1153 }
1154 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedAnd16_rel(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
1155 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i16* %value, i16 %mask release
1156 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
1157 // CHECK-ARM-ARM64: }
1158
1159 short test_InterlockedAnd16_nf(short volatile *value, short mask) {
1160   return _InterlockedAnd16_nf(value, mask);
1161 }
1162 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedAnd16_nf(i16*{{[a-z_ ]*}}%value, i16{{[a-z_ ]*}}%mask){{.*}}{
1163 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i16* %value, i16 %mask monotonic
1164 // CHECK-ARM-ARM64:   ret i16 [[RESULT:%[0-9]+]]
1165 // CHECK-ARM-ARM64: }
1166
1167 long test_InterlockedAnd_acq(long volatile *value, long mask) {
1168   return _InterlockedAnd_acq(value, mask);
1169 }
1170 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedAnd_acq(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
1171 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i32* %value, i32 %mask acquire
1172 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
1173 // CHECK-ARM-ARM64: }
1174
1175 long test_InterlockedAnd_rel(long volatile *value, long mask) {
1176   return _InterlockedAnd_rel(value, mask);
1177 }
1178 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedAnd_rel(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
1179 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i32* %value, i32 %mask release
1180 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
1181 // CHECK-ARM-ARM64: }
1182
1183 long test_InterlockedAnd_nf(long volatile *value, long mask) {
1184   return _InterlockedAnd_nf(value, mask);
1185 }
1186 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedAnd_nf(i32*{{[a-z_ ]*}}%value, i32{{[a-z_ ]*}}%mask){{.*}}{
1187 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i32* %value, i32 %mask monotonic
1188 // CHECK-ARM-ARM64:   ret i32 [[RESULT:%[0-9]+]]
1189 // CHECK-ARM-ARM64: }
1190
1191 __int64 test_InterlockedAnd64_acq(__int64 volatile *value, __int64 mask) {
1192   return _InterlockedAnd64_acq(value, mask);
1193 }
1194 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedAnd64_acq(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1195 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i64* %value, i64 %mask acquire
1196 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1197 // CHECK-ARM-ARM64: }
1198
1199 __int64 test_InterlockedAnd64_rel(__int64 volatile *value, __int64 mask) {
1200   return _InterlockedAnd64_rel(value, mask);
1201 }
1202 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedAnd64_rel(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1203 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i64* %value, i64 %mask release
1204 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1205 // CHECK-ARM-ARM64: }
1206
1207 __int64 test_InterlockedAnd64_nf(__int64 volatile *value, __int64 mask) {
1208   return _InterlockedAnd64_nf(value, mask);
1209 }
1210 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedAnd64_nf(i64*{{[a-z_ ]*}}%value, i64{{[a-z_ ]*}}%mask){{.*}}{
1211 // CHECK-ARM-ARM64:   [[RESULT:%[0-9]+]] = atomicrmw and i64* %value, i64 %mask monotonic
1212 // CHECK-ARM-ARM64:   ret i64 [[RESULT:%[0-9]+]]
1213 // CHECK-ARM-ARM64: }
1214
1215 short test_InterlockedIncrement16_acq(short volatile *Addend) {
1216   return _InterlockedIncrement16_acq(Addend);
1217 }
1218 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedIncrement16_acq(i16*{{[a-z_ ]*}}%Addend){{.*}}{
1219 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i16* %Addend, i16 1 acquire
1220 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i16 [[TMP]], 1
1221 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
1222 // CHECK-ARM-ARM64: }
1223
1224 short test_InterlockedIncrement16_rel(short volatile *Addend) {
1225   return _InterlockedIncrement16_rel(Addend);
1226 }
1227 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedIncrement16_rel(i16*{{[a-z_ ]*}}%Addend){{.*}}{
1228 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i16* %Addend, i16 1 release
1229 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i16 [[TMP]], 1
1230 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
1231 // CHECK-ARM-ARM64: }
1232
1233 short test_InterlockedIncrement16_nf(short volatile *Addend) {
1234   return _InterlockedIncrement16_nf(Addend);
1235 }
1236 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedIncrement16_nf(i16*{{[a-z_ ]*}}%Addend){{.*}}{
1237 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i16* %Addend, i16 1 monotonic
1238 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i16 [[TMP]], 1
1239 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
1240 // CHECK-ARM-ARM64: }
1241
1242 long test_InterlockedIncrement_acq(long volatile *Addend) {
1243   return _InterlockedIncrement_acq(Addend);
1244 }
1245 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedIncrement_acq(i32*{{[a-z_ ]*}}%Addend){{.*}}{
1246 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i32* %Addend, i32 1 acquire
1247 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i32 [[TMP]], 1
1248 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
1249 // CHECK-ARM-ARM64: }
1250
1251 long test_InterlockedIncrement_rel(long volatile *Addend) {
1252   return _InterlockedIncrement_rel(Addend);
1253 }
1254 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedIncrement_rel(i32*{{[a-z_ ]*}}%Addend){{.*}}{
1255 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i32* %Addend, i32 1 release
1256 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i32 [[TMP]], 1
1257 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
1258 // CHECK-ARM-ARM64: }
1259
1260 long test_InterlockedIncrement_nf(long volatile *Addend) {
1261   return _InterlockedIncrement_nf(Addend);
1262 }
1263 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedIncrement_nf(i32*{{[a-z_ ]*}}%Addend){{.*}}{
1264 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i32* %Addend, i32 1 monotonic
1265 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i32 [[TMP]], 1
1266 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
1267 // CHECK-ARM-ARM64: }
1268
1269 __int64 test_InterlockedIncrement64_acq(__int64 volatile *Addend) {
1270   return _InterlockedIncrement64_acq(Addend);
1271 }
1272 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedIncrement64_acq(i64*{{[a-z_ ]*}}%Addend){{.*}}{
1273 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i64* %Addend, i64 1 acquire
1274 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i64 [[TMP]], 1
1275 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
1276 // CHECK-ARM-ARM64: }
1277
1278 __int64 test_InterlockedIncrement64_rel(__int64 volatile *Addend) {
1279   return _InterlockedIncrement64_rel(Addend);
1280 }
1281 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedIncrement64_rel(i64*{{[a-z_ ]*}}%Addend){{.*}}{
1282 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i64* %Addend, i64 1 release
1283 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i64 [[TMP]], 1
1284 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
1285 // CHECK-ARM-ARM64: }
1286
1287 __int64 test_InterlockedIncrement64_nf(__int64 volatile *Addend) {
1288   return _InterlockedIncrement64_nf(Addend);
1289 }
1290 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedIncrement64_nf(i64*{{[a-z_ ]*}}%Addend){{.*}}{
1291 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw add i64* %Addend, i64 1 monotonic
1292 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i64 [[TMP]], 1
1293 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
1294 // CHECK-ARM-ARM64: }
1295
1296 short test_InterlockedDecrement16_acq(short volatile *Addend) {
1297   return _InterlockedDecrement16_acq(Addend);
1298 }
1299 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedDecrement16_acq(i16*{{[a-z_ ]*}}%Addend){{.*}}{
1300 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i16* %Addend, i16 1 acquire
1301 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i16 [[TMP]], -1
1302 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
1303 // CHECK-ARM-ARM64: }
1304
1305 short test_InterlockedDecrement16_rel(short volatile *Addend) {
1306   return _InterlockedDecrement16_rel(Addend);
1307 }
1308 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedDecrement16_rel(i16*{{[a-z_ ]*}}%Addend){{.*}}{
1309 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i16* %Addend, i16 1 release
1310 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i16 [[TMP]], -1
1311 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
1312 // CHECK-ARM-ARM64: }
1313
1314 short test_InterlockedDecrement16_nf(short volatile *Addend) {
1315   return _InterlockedDecrement16_nf(Addend);
1316 }
1317 // CHECK-ARM-ARM64: define{{.*}}i16 @test_InterlockedDecrement16_nf(i16*{{[a-z_ ]*}}%Addend){{.*}}{
1318 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i16* %Addend, i16 1 monotonic
1319 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i16 [[TMP]], -1
1320 // CHECK-ARM-ARM64: ret i16 [[RESULT]]
1321 // CHECK-ARM-ARM64: }
1322
1323 long test_InterlockedDecrement_acq(long volatile *Addend) {
1324   return _InterlockedDecrement_acq(Addend);
1325 }
1326 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedDecrement_acq(i32*{{[a-z_ ]*}}%Addend){{.*}}{
1327 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i32* %Addend, i32 1 acquire
1328 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i32 [[TMP]], -1
1329 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
1330 // CHECK-ARM-ARM64: }
1331
1332 long test_InterlockedDecrement_rel(long volatile *Addend) {
1333   return _InterlockedDecrement_rel(Addend);
1334 }
1335 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedDecrement_rel(i32*{{[a-z_ ]*}}%Addend){{.*}}{
1336 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i32* %Addend, i32 1 release
1337 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i32 [[TMP]], -1
1338 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
1339 // CHECK-ARM-ARM64: }
1340
1341 long test_InterlockedDecrement_nf(long volatile *Addend) {
1342   return _InterlockedDecrement_nf(Addend);
1343 }
1344 // CHECK-ARM-ARM64: define{{.*}}i32 @test_InterlockedDecrement_nf(i32*{{[a-z_ ]*}}%Addend){{.*}}{
1345 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i32* %Addend, i32 1 monotonic
1346 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i32 [[TMP]], -1
1347 // CHECK-ARM-ARM64: ret i32 [[RESULT]]
1348 // CHECK-ARM-ARM64: }
1349
1350 __int64 test_InterlockedDecrement64_acq(__int64 volatile *Addend) {
1351   return _InterlockedDecrement64_acq(Addend);
1352 }
1353 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedDecrement64_acq(i64*{{[a-z_ ]*}}%Addend){{.*}}{
1354 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i64* %Addend, i64 1 acquire
1355 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i64 [[TMP]], -1
1356 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
1357 // CHECK-ARM-ARM64: }
1358
1359 __int64 test_InterlockedDecrement64_rel(__int64 volatile *Addend) {
1360   return _InterlockedDecrement64_rel(Addend);
1361 }
1362 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedDecrement64_rel(i64*{{[a-z_ ]*}}%Addend){{.*}}{
1363 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i64* %Addend, i64 1 release
1364 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i64 [[TMP]], -1
1365 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
1366 // CHECK-ARM-ARM64: }
1367
1368 __int64 test_InterlockedDecrement64_nf(__int64 volatile *Addend) {
1369   return _InterlockedDecrement64_nf(Addend);
1370 }
1371 // CHECK-ARM-ARM64: define{{.*}}i64 @test_InterlockedDecrement64_nf(i64*{{[a-z_ ]*}}%Addend){{.*}}{
1372 // CHECK-ARM-ARM64: [[TMP:%[0-9]+]] = atomicrmw sub i64* %Addend, i64 1 monotonic
1373 // CHECK-ARM-ARM64: [[RESULT:%[0-9]+]] = add i64 [[TMP]], -1
1374 // CHECK-ARM-ARM64: ret i64 [[RESULT]]
1375 // CHECK-ARM-ARM64: }
1376 #endif
1377
1378 void test__fastfail() {
1379   __fastfail(42);
1380 }
1381 // CHECK-LABEL: define{{.*}} void @test__fastfail()
1382 // CHECK-ARM: call void asm sideeffect "udf #251", "{r0}"(i32 42) #[[NORETURN:[0-9]+]]
1383 // CHECK-INTEL: call void asm sideeffect "int $$0x29", "{cx}"(i32 42) #[[NORETURN]]
1384 // CHECK-ARM64: call void asm sideeffect "brk #0xF003", "{w0}"(i32 42) #[[NORETURN:[0-9]+]]
1385
1386 // Attributes come last.
1387
1388 // CHECK: attributes #[[NORETURN]] = { noreturn{{.*}} }