llvm/test/Transforms/AtomicExpand/X86/expand-atomic-non-integer.ll

   1 ; RUN: opt -S %s -atomic-expand -mtriple=x86_64-linux-gnu | FileCheck %s
   2
   3 ; This file tests the functions `llvm::convertAtomicLoadToIntegerType` and
   4 ; `llvm::convertAtomicStoreToIntegerType`. If X86 stops using this
   5 ; functionality, please move this test to a target which still is.
   6
   7 define float @float_load_expand(float* %ptr) {
   8 ; CHECK-LABEL: @float_load_expand
   9 ; CHECK: %1 = bitcast float* %ptr to i32*
  10 ; CHECK: %2 = load atomic i32, i32* %1 unordered, align 4
  11 ; CHECK: %3 = bitcast i32 %2 to float
  12 ; CHECK: ret float %3
  13   %res = load atomic float, float* %ptr unordered, align 4
  14   ret float %res
  15 }
  16
  17 define float @float_load_expand_seq_cst(float* %ptr) {
  18 ; CHECK-LABEL: @float_load_expand_seq_cst
  19 ; CHECK: %1 = bitcast float* %ptr to i32*
  20 ; CHECK: %2 = load atomic i32, i32* %1 seq_cst, align 4
  21 ; CHECK: %3 = bitcast i32 %2 to float
  22 ; CHECK: ret float %3
  23   %res = load atomic float, float* %ptr seq_cst, align 4
  24   ret float %res
  25 }
  26
  27 define float @float_load_expand_vol(float* %ptr) {
  28 ; CHECK-LABEL: @float_load_expand_vol
  29 ; CHECK: %1 = bitcast float* %ptr to i32*
  30 ; CHECK: %2 = load atomic volatile i32, i32* %1 unordered, align 4
  31 ; CHECK: %3 = bitcast i32 %2 to float
  32 ; CHECK: ret float %3
  33   %res = load atomic volatile float, float* %ptr unordered, align 4
  34   ret float %res
  35 }
  36
  37 define float @float_load_expand_addr1(float addrspace(1)* %ptr) {
  38 ; CHECK-LABEL: @float_load_expand_addr1
  39 ; CHECK: %1 = bitcast float addrspace(1)* %ptr to i32 addrspace(1)*
  40 ; CHECK: %2 = load atomic i32, i32 addrspace(1)* %1 unordered, align 4
  41 ; CHECK: %3 = bitcast i32 %2 to float
  42 ; CHECK: ret float %3
  43   %res = load atomic float, float addrspace(1)* %ptr unordered, align 4
  44   ret float %res
  45 }
  46
  47 define void @float_store_expand(float* %ptr, float %v) {
  48 ; CHECK-LABEL: @float_store_expand
  49 ; CHECK: %1 = bitcast float %v to i32
  50 ; CHECK: %2 = bitcast float* %ptr to i32*
  51 ; CHECK: store atomic i32 %1, i32* %2 unordered, align 4
  52   store atomic float %v, float* %ptr unordered, align 4
  53   ret void
  54 }
  55
  56 define void @float_store_expand_seq_cst(float* %ptr, float %v) {
  57 ; CHECK-LABEL: @float_store_expand_seq_cst
  58 ; CHECK: %1 = bitcast float %v to i32
  59 ; CHECK: %2 = bitcast float* %ptr to i32*
  60 ; CHECK: store atomic i32 %1, i32* %2 seq_cst, align 4
  61   store atomic float %v, float* %ptr seq_cst, align 4
  62   ret void
  63 }
  64
  65 define void @float_store_expand_vol(float* %ptr, float %v) {
  66 ; CHECK-LABEL: @float_store_expand_vol
  67 ; CHECK: %1 = bitcast float %v to i32
  68 ; CHECK: %2 = bitcast float* %ptr to i32*
  69 ; CHECK: store atomic volatile i32 %1, i32* %2 unordered, align 4
  70   store atomic volatile float %v, float* %ptr unordered, align 4
  71   ret void
  72 }
  73
  74 define void @float_store_expand_addr1(float addrspace(1)* %ptr, float %v) {
  75 ; CHECK-LABEL: @float_store_expand_addr1
  76 ; CHECK: %1 = bitcast float %v to i32
  77 ; CHECK: %2 = bitcast float addrspace(1)* %ptr to i32 addrspace(1)*
  78 ; CHECK: store atomic i32 %1, i32 addrspace(1)* %2 unordered, align 4
  79   store atomic float %v, float addrspace(1)* %ptr unordered, align 4
  80   ret void
  81 }
  82
  83 define void @pointer_cmpxchg_expand(i8** %ptr, i8* %v) {
  84 ; CHECK-LABEL: @pointer_cmpxchg_expand
  85 ; CHECK: %1 = bitcast i8** %ptr to i64*
  86 ; CHECK: %2 = ptrtoint i8* %v to i64
  87 ; CHECK: %3 = cmpxchg i64* %1, i64 0, i64 %2 seq_cst monotonic
  88 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
  89 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
  90 ; CHECK: %6 = inttoptr i64 %4 to i8*
  91 ; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
  92 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
  93   cmpxchg i8** %ptr, i8* null, i8* %v seq_cst monotonic
  94   ret void
  95 }
  96
  97 define void @pointer_cmpxchg_expand2(i8** %ptr, i8* %v) {
  98 ; CHECK-LABEL: @pointer_cmpxchg_expand2
  99 ; CHECK: %1 = bitcast i8** %ptr to i64*
 100 ; CHECK: %2 = ptrtoint i8* %v to i64
 101 ; CHECK: %3 = cmpxchg i64* %1, i64 0, i64 %2 release monotonic
 102 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 103 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 104 ; CHECK: %6 = inttoptr i64 %4 to i8*
 105 ; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
 106 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
 107   cmpxchg i8** %ptr, i8* null, i8* %v release monotonic
 108   ret void
 109 }
 110
 111 define void @pointer_cmpxchg_expand3(i8** %ptr, i8* %v) {
 112 ; CHECK-LABEL: @pointer_cmpxchg_expand3
 113 ; CHECK: %1 = bitcast i8** %ptr to i64*
 114 ; CHECK: %2 = ptrtoint i8* %v to i64
 115 ; CHECK: %3 = cmpxchg i64* %1, i64 0, i64 %2 seq_cst seq_cst
 116 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 117 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 118 ; CHECK: %6 = inttoptr i64 %4 to i8*
 119 ; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
 120 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
 121   cmpxchg i8** %ptr, i8* null, i8* %v seq_cst seq_cst
 122   ret void
 123 }
 124
 125 define void @pointer_cmpxchg_expand4(i8** %ptr, i8* %v) {
 126 ; CHECK-LABEL: @pointer_cmpxchg_expand4
 127 ; CHECK: %1 = bitcast i8** %ptr to i64*
 128 ; CHECK: %2 = ptrtoint i8* %v to i64
 129 ; CHECK: %3 = cmpxchg weak i64* %1, i64 0, i64 %2 seq_cst seq_cst
 130 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 131 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 132 ; CHECK: %6 = inttoptr i64 %4 to i8*
 133 ; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
 134 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
 135   cmpxchg weak i8** %ptr, i8* null, i8* %v seq_cst seq_cst
 136   ret void
 137 }
 138
 139 define void @pointer_cmpxchg_expand5(i8** %ptr, i8* %v) {
 140 ; CHECK-LABEL: @pointer_cmpxchg_expand5
 141 ; CHECK: %1 = bitcast i8** %ptr to i64*
 142 ; CHECK: %2 = ptrtoint i8* %v to i64
 143 ; CHECK: %3 = cmpxchg volatile i64* %1, i64 0, i64 %2 seq_cst seq_cst
 144 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 145 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 146 ; CHECK: %6 = inttoptr i64 %4 to i8*
 147 ; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
 148 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
 149   cmpxchg volatile i8** %ptr, i8* null, i8* %v seq_cst seq_cst
 150   ret void
 151 }
 152
 153 define void @pointer_cmpxchg_expand6(i8 addrspace(2)* addrspace(1)* %ptr,
 154                                      i8 addrspace(2)* %v) {
 155 ; CHECK-LABEL: @pointer_cmpxchg_expand6
 156 ; CHECK: %1 = bitcast i8 addrspace(2)* addrspace(1)* %ptr to i64 addrspace(1)*
 157 ; CHECK: %2 = ptrtoint i8 addrspace(2)* %v to i64
 158 ; CHECK: %3 = cmpxchg i64 addrspace(1)* %1, i64 0, i64 %2 seq_cst seq_cst
 159 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 160 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 161 ; CHECK: %6 = inttoptr i64 %4 to i8 addrspace(2)*
 162 ; CHECK: %7 = insertvalue { i8 addrspace(2)*, i1 } undef, i8 addrspace(2)* %6, 0
 163 ; CHECK: %8 = insertvalue { i8 addrspace(2)*, i1 } %7, i1 %5, 1
 164   cmpxchg i8 addrspace(2)* addrspace(1)* %ptr, i8 addrspace(2)* null, i8 addrspace(2)* %v seq_cst seq_cst
 165   ret void
 166 }
 167