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