Skip to content

Commit 82bb253

Browse files
arsenmarsenm
authored
AMDGPU: Don't bitcast float typed atomic store in IR (#90116)
Implement the promotion in the DAG. Depends #90113
1 parent c76ccf0 commit 82bb253

File tree

6 files changed

+91
-41
lines changed

6 files changed

+91
-41
lines changed

‎llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

+20-9
Original file line numberDiff line numberDiff line change
@@ -5006,7 +5006,8 @@ void SelectionDAGLegalize::PromoteNode(SDNode *Node) {
50065006
Node->getOpcode() == ISD::INSERT_VECTOR_ELT) {
50075007
OVT = Node->getOperand(0).getSimpleValueType();
50085008
}
5009-
if (Node->getOpcode() == ISD::STRICT_UINT_TO_FP ||
5009+
if (Node->getOpcode() == ISD::ATOMIC_STORE ||
5010+
Node->getOpcode() == ISD::STRICT_UINT_TO_FP ||
50105011
Node->getOpcode() == ISD::STRICT_SINT_TO_FP ||
50115012
Node->getOpcode() == ISD::STRICT_FSETCC ||
50125013
Node->getOpcode() == ISD::STRICT_FSETCCS ||
@@ -5622,7 +5623,8 @@ void SelectionDAGLegalize::PromoteNode(SDNode *Node) {
56225623
Results.push_back(CvtVec);
56235624
break;
56245625
}
5625-
case ISD::ATOMIC_SWAP: {
5626+
case ISD::ATOMIC_SWAP:
5627+
case ISD::ATOMIC_STORE: {
56265628
AtomicSDNode *AM = cast<AtomicSDNode>(Node);
56275629
SDLoc SL(Node);
56285630
SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, NVT, AM->getVal());
@@ -5631,13 +5633,22 @@ void SelectionDAGLegalize::PromoteNode(SDNode *Node) {
56315633
assert(AM->getMemoryVT().getSizeInBits() == NVT.getSizeInBits() &&
56325634
"unexpected atomic_swap with illegal type");
56335635

5634-
SDValue NewAtomic
5635-
= DAG.getAtomic(ISD::ATOMIC_SWAP, SL, NVT,
5636-
DAG.getVTList(NVT, MVT::Other),
5637-
{ AM->getChain(), AM->getBasePtr(), CastVal },
5638-
AM->getMemOperand());
5639-
Results.push_back(DAG.getNode(ISD::BITCAST, SL, OVT, NewAtomic));
5640-
Results.push_back(NewAtomic.getValue(1));
5636+
SDValue Op0 = AM->getBasePtr();
5637+
SDValue Op1 = CastVal;
5638+
5639+
// ATOMIC_STORE uses a swapped operand order from every other AtomicSDNode,
5640+
// but really it should merge with ISD::STORE.
5641+
if (AM->getOpcode() == ISD::ATOMIC_STORE)
5642+
std::swap(Op0, Op1);
5643+
5644+
SDValue NewAtomic = DAG.getAtomic(AM->getOpcode(), SL, NVT, AM->getChain(),
5645+
Op0, Op1, AM->getMemOperand());
5646+
5647+
if (AM->getOpcode() != ISD::ATOMIC_STORE) {
5648+
Results.push_back(DAG.getNode(ISD::BITCAST, SL, OVT, NewAtomic));
5649+
Results.push_back(NewAtomic.getValue(1));
5650+
} else
5651+
Results.push_back(NewAtomic);
56415652
break;
56425653
}
56435654
case ISD::ATOMIC_LOAD: {

‎llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

+34
Original file line numberDiff line numberDiff line change
@@ -2287,6 +2287,7 @@ bool DAGTypeLegalizer::PromoteFloatOperand(SDNode *N, unsigned OpNo) {
22872287
case ISD::SELECT_CC: R = PromoteFloatOp_SELECT_CC(N, OpNo); break;
22882288
case ISD::SETCC: R = PromoteFloatOp_SETCC(N, OpNo); break;
22892289
case ISD::STORE: R = PromoteFloatOp_STORE(N, OpNo); break;
2290+
case ISD::ATOMIC_STORE: R = PromoteFloatOp_ATOMIC_STORE(N, OpNo); break;
22902291
}
22912292
// clang-format on
22922293

@@ -2409,6 +2410,23 @@ SDValue DAGTypeLegalizer::PromoteFloatOp_STORE(SDNode *N, unsigned OpNo) {
24092410
ST->getMemOperand());
24102411
}
24112412

2413+
SDValue DAGTypeLegalizer::PromoteFloatOp_ATOMIC_STORE(SDNode *N,
2414+
unsigned OpNo) {
2415+
AtomicSDNode *ST = cast<AtomicSDNode>(N);
2416+
SDValue Val = ST->getVal();
2417+
SDLoc DL(N);
2418+
2419+
SDValue Promoted = GetPromotedFloat(Val);
2420+
EVT VT = ST->getOperand(1).getValueType();
2421+
EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
2422+
2423+
SDValue NewVal = DAG.getNode(GetPromotionOpcode(Promoted.getValueType(), VT),
2424+
DL, IVT, Promoted);
2425+
2426+
return DAG.getAtomic(ISD::ATOMIC_STORE, DL, IVT, ST->getChain(), NewVal,
2427+
ST->getBasePtr(), ST->getMemOperand());
2428+
}
2429+
24122430
//===----------------------------------------------------------------------===//
24132431
// Float Result Promotion
24142432
//===----------------------------------------------------------------------===//
@@ -3238,6 +3256,9 @@ bool DAGTypeLegalizer::SoftPromoteHalfOperand(SDNode *N, unsigned OpNo) {
32383256
case ISD::SELECT_CC: Res = SoftPromoteHalfOp_SELECT_CC(N, OpNo); break;
32393257
case ISD::SETCC: Res = SoftPromoteHalfOp_SETCC(N); break;
32403258
case ISD::STORE: Res = SoftPromoteHalfOp_STORE(N, OpNo); break;
3259+
case ISD::ATOMIC_STORE:
3260+
Res = SoftPromoteHalfOp_ATOMIC_STORE(N, OpNo);
3261+
break;
32413262
case ISD::STACKMAP:
32423263
Res = SoftPromoteHalfOp_STACKMAP(N, OpNo);
32433264
break;
@@ -3391,6 +3412,19 @@ SDValue DAGTypeLegalizer::SoftPromoteHalfOp_STORE(SDNode *N, unsigned OpNo) {
33913412
ST->getMemOperand());
33923413
}
33933414

3415+
SDValue DAGTypeLegalizer::SoftPromoteHalfOp_ATOMIC_STORE(SDNode *N,
3416+
unsigned OpNo) {
3417+
assert(OpNo == 1 && "Can only soften the stored value!");
3418+
AtomicSDNode *ST = cast<AtomicSDNode>(N);
3419+
SDValue Val = ST->getVal();
3420+
SDLoc dl(N);
3421+
3422+
SDValue Promoted = GetSoftPromotedHalf(Val);
3423+
return DAG.getAtomic(ISD::ATOMIC_STORE, dl, Promoted.getValueType(),
3424+
ST->getChain(), Promoted, ST->getBasePtr(),
3425+
ST->getMemOperand());
3426+
}
3427+
33943428
SDValue DAGTypeLegalizer::SoftPromoteHalfOp_STACKMAP(SDNode *N, unsigned OpNo) {
33953429
assert(OpNo > 1); // Because the first two arguments are guaranteed legal.
33963430
SmallVector<SDValue> NewOps(N->ops().begin(), N->ops().end());

‎llvm/lib/CodeGen/SelectionDAG/LegalizeTypes.h

+2
Original file line numberDiff line numberDiff line change
@@ -712,6 +712,7 @@ class LLVM_LIBRARY_VISIBILITY DAGTypeLegalizer {
712712
SDValue PromoteFloatOp_UnaryOp(SDNode *N, unsigned OpNo);
713713
SDValue PromoteFloatOp_FP_TO_XINT_SAT(SDNode *N, unsigned OpNo);
714714
SDValue PromoteFloatOp_STORE(SDNode *N, unsigned OpNo);
715+
SDValue PromoteFloatOp_ATOMIC_STORE(SDNode *N, unsigned OpNo);
715716
SDValue PromoteFloatOp_SELECT_CC(SDNode *N, unsigned OpNo);
716717
SDValue PromoteFloatOp_SETCC(SDNode *N, unsigned OpNo);
717718

@@ -757,6 +758,7 @@ class LLVM_LIBRARY_VISIBILITY DAGTypeLegalizer {
757758
SDValue SoftPromoteHalfOp_SETCC(SDNode *N);
758759
SDValue SoftPromoteHalfOp_SELECT_CC(SDNode *N, unsigned OpNo);
759760
SDValue SoftPromoteHalfOp_STORE(SDNode *N, unsigned OpNo);
761+
SDValue SoftPromoteHalfOp_ATOMIC_STORE(SDNode *N, unsigned OpNo);
760762
SDValue SoftPromoteHalfOp_STACKMAP(SDNode *N, unsigned OpNo);
761763
SDValue SoftPromoteHalfOp_PATCHPOINT(SDNode *N, unsigned OpNo);
762764

‎llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp

+12
Original file line numberDiff line numberDiff line change
@@ -161,6 +161,18 @@ AMDGPUTargetLowering::AMDGPUTargetLowering(const TargetMachine &TM,
161161
setOperationAction(ISD::ATOMIC_LOAD, MVT::bf16, Promote);
162162
AddPromotedToType(ISD::ATOMIC_LOAD, MVT::bf16, MVT::i16);
163163

164+
setOperationAction(ISD::ATOMIC_STORE, MVT::f32, Promote);
165+
AddPromotedToType(ISD::ATOMIC_STORE, MVT::f32, MVT::i32);
166+
167+
setOperationAction(ISD::ATOMIC_STORE, MVT::f64, Promote);
168+
AddPromotedToType(ISD::ATOMIC_STORE, MVT::f64, MVT::i64);
169+
170+
setOperationAction(ISD::ATOMIC_STORE, MVT::f16, Promote);
171+
AddPromotedToType(ISD::ATOMIC_STORE, MVT::f16, MVT::i16);
172+
173+
setOperationAction(ISD::ATOMIC_STORE, MVT::bf16, Promote);
174+
AddPromotedToType(ISD::ATOMIC_STORE, MVT::bf16, MVT::i16);
175+
164176
// There are no 64-bit extloads. These should be done as a 32-bit extload and
165177
// an extension to 64-bit.
166178
for (MVT VT : MVT::integer_valuetypes())

‎llvm/lib/Target/AMDGPU/AMDGPUISelLowering.h

+4
Original file line numberDiff line numberDiff line change
@@ -236,6 +236,10 @@ class AMDGPUTargetLowering : public TargetLowering {
236236
return AtomicExpansionKind::None;
237237
}
238238

239+
AtomicExpansionKind shouldCastAtomicStoreInIR(StoreInst *SI) const override {
240+
return AtomicExpansionKind::None;
241+
}
242+
239243
AtomicExpansionKind shouldCastAtomicRMWIInIR(AtomicRMWInst *) const override {
240244
return AtomicExpansionKind::None;
241245
}

‎llvm/test/Transforms/AtomicExpand/AMDGPU/no-expand-atomic-store.ll

+19-32
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,7 @@
44
define void @store_atomic_f32_global_system(float %val, ptr addrspace(1) %ptr) {
55
; CHECK-LABEL: define void @store_atomic_f32_global_system(
66
; CHECK-SAME: float [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
7-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast float [[VAL]] to i32
8-
; CHECK-NEXT: store atomic i32 [[TMP1]], ptr addrspace(1) [[PTR]] seq_cst, align 4
7+
; CHECK-NEXT: store atomic float [[VAL]], ptr addrspace(1) [[PTR]] seq_cst, align 4, !some.unknown.md [[META0:![0-9]+]]
98
; CHECK-NEXT: ret void
109
;
1110
store atomic float %val, ptr addrspace(1) %ptr seq_cst, align 4, !some.unknown.md !0
@@ -15,8 +14,7 @@ define void @store_atomic_f32_global_system(float %val, ptr addrspace(1) %ptr) {
1514
define void @store_atomic_f32_global_agent(float %val, ptr addrspace(1) %ptr) {
1615
; CHECK-LABEL: define void @store_atomic_f32_global_agent(
1716
; CHECK-SAME: float [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
18-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast float [[VAL]] to i32
19-
; CHECK-NEXT: store atomic i32 [[TMP1]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 4
17+
; CHECK-NEXT: store atomic float [[VAL]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 4, !some.unknown.md [[META0]]
2018
; CHECK-NEXT: ret void
2119
;
2220
store atomic float %val, ptr addrspace(1) %ptr syncscope("agent") seq_cst, align 4, !some.unknown.md !0
@@ -26,8 +24,7 @@ define void @store_atomic_f32_global_agent(float %val, ptr addrspace(1) %ptr) {
2624
define void @store_atomic_f32_local(float %val, ptr addrspace(3) %ptr) {
2725
; CHECK-LABEL: define void @store_atomic_f32_local(
2826
; CHECK-SAME: float [[VAL:%.*]], ptr addrspace(3) [[PTR:%.*]]) {
29-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast float [[VAL]] to i32
30-
; CHECK-NEXT: store atomic i32 [[TMP1]], ptr addrspace(3) [[PTR]] seq_cst, align 4
27+
; CHECK-NEXT: store atomic float [[VAL]], ptr addrspace(3) [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
3128
; CHECK-NEXT: ret void
3229
;
3330
store atomic float %val, ptr addrspace(3) %ptr seq_cst, align 4, !some.unknown.md !0
@@ -37,8 +34,7 @@ define void @store_atomic_f32_local(float %val, ptr addrspace(3) %ptr) {
3734
define void @store_atomic_f32_flat(float %val, ptr %ptr) {
3835
; CHECK-LABEL: define void @store_atomic_f32_flat(
3936
; CHECK-SAME: float [[VAL:%.*]], ptr [[PTR:%.*]]) {
40-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast float [[VAL]] to i32
41-
; CHECK-NEXT: store atomic i32 [[TMP1]], ptr [[PTR]] seq_cst, align 4
37+
; CHECK-NEXT: store atomic float [[VAL]], ptr [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
4238
; CHECK-NEXT: ret void
4339
;
4440
store atomic float %val, ptr %ptr seq_cst, align 4, !some.unknown.md !0
@@ -48,8 +44,7 @@ define void @store_atomic_f32_flat(float %val, ptr %ptr) {
4844
define void @store_atomic_f16_global_system(half %val, ptr addrspace(1) %ptr) {
4945
; CHECK-LABEL: define void @store_atomic_f16_global_system(
5046
; CHECK-SAME: half [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
51-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast half [[VAL]] to i16
52-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr addrspace(1) [[PTR]] seq_cst, align 4
47+
; CHECK-NEXT: store atomic half [[VAL]], ptr addrspace(1) [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
5348
; CHECK-NEXT: ret void
5449
;
5550
store atomic half %val, ptr addrspace(1) %ptr seq_cst, align 4, !some.unknown.md !0
@@ -59,8 +54,7 @@ define void @store_atomic_f16_global_system(half %val, ptr addrspace(1) %ptr) {
5954
define void @store_atomic_f16_global_agent(half %val, ptr addrspace(1) %ptr) {
6055
; CHECK-LABEL: define void @store_atomic_f16_global_agent(
6156
; CHECK-SAME: half [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
62-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast half [[VAL]] to i16
63-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 4
57+
; CHECK-NEXT: store atomic half [[VAL]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 4, !some.unknown.md [[META0]]
6458
; CHECK-NEXT: ret void
6559
;
6660
store atomic half %val, ptr addrspace(1) %ptr syncscope("agent") seq_cst, align 4, !some.unknown.md !0
@@ -70,8 +64,7 @@ define void @store_atomic_f16_global_agent(half %val, ptr addrspace(1) %ptr) {
7064
define void @store_atomic_f16_local(half %val, ptr addrspace(3) %ptr) {
7165
; CHECK-LABEL: define void @store_atomic_f16_local(
7266
; CHECK-SAME: half [[VAL:%.*]], ptr addrspace(3) [[PTR:%.*]]) {
73-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast half [[VAL]] to i16
74-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr addrspace(3) [[PTR]] seq_cst, align 4
67+
; CHECK-NEXT: store atomic half [[VAL]], ptr addrspace(3) [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
7568
; CHECK-NEXT: ret void
7669
;
7770
store atomic half %val, ptr addrspace(3) %ptr seq_cst, align 4, !some.unknown.md !0
@@ -81,8 +74,7 @@ define void @store_atomic_f16_local(half %val, ptr addrspace(3) %ptr) {
8174
define void @store_atomic_f16_flat(half %val, ptr %ptr) {
8275
; CHECK-LABEL: define void @store_atomic_f16_flat(
8376
; CHECK-SAME: half [[VAL:%.*]], ptr [[PTR:%.*]]) {
84-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast half [[VAL]] to i16
85-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr [[PTR]] seq_cst, align 4
77+
; CHECK-NEXT: store atomic half [[VAL]], ptr [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
8678
; CHECK-NEXT: ret void
8779
;
8880
store atomic half %val, ptr %ptr seq_cst, align 4, !some.unknown.md !0
@@ -92,8 +84,7 @@ define void @store_atomic_f16_flat(half %val, ptr %ptr) {
9284
define void @store_atomic_bf16_global_system(bfloat %val, ptr addrspace(1) %ptr) {
9385
; CHECK-LABEL: define void @store_atomic_bf16_global_system(
9486
; CHECK-SAME: bfloat [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
95-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast bfloat [[VAL]] to i16
96-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr addrspace(1) [[PTR]] seq_cst, align 4
87+
; CHECK-NEXT: store atomic bfloat [[VAL]], ptr addrspace(1) [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
9788
; CHECK-NEXT: ret void
9889
;
9990
store atomic bfloat %val, ptr addrspace(1) %ptr seq_cst, align 4, !some.unknown.md !0
@@ -103,8 +94,7 @@ define void @store_atomic_bf16_global_system(bfloat %val, ptr addrspace(1) %ptr)
10394
define void @store_atomic_bf16_global_agent(bfloat %val, ptr addrspace(1) %ptr) {
10495
; CHECK-LABEL: define void @store_atomic_bf16_global_agent(
10596
; CHECK-SAME: bfloat [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
106-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast bfloat [[VAL]] to i16
107-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 4
97+
; CHECK-NEXT: store atomic bfloat [[VAL]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 4, !some.unknown.md [[META0]]
10898
; CHECK-NEXT: ret void
10999
;
110100
store atomic bfloat %val, ptr addrspace(1) %ptr syncscope("agent") seq_cst, align 4, !some.unknown.md !0
@@ -114,8 +104,7 @@ define void @store_atomic_bf16_global_agent(bfloat %val, ptr addrspace(1) %ptr)
114104
define void @store_atomic_bf16_local(bfloat %val, ptr addrspace(3) %ptr) {
115105
; CHECK-LABEL: define void @store_atomic_bf16_local(
116106
; CHECK-SAME: bfloat [[VAL:%.*]], ptr addrspace(3) [[PTR:%.*]]) {
117-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast bfloat [[VAL]] to i16
118-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr addrspace(3) [[PTR]] seq_cst, align 4
107+
; CHECK-NEXT: store atomic bfloat [[VAL]], ptr addrspace(3) [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
119108
; CHECK-NEXT: ret void
120109
;
121110
store atomic bfloat %val, ptr addrspace(3) %ptr seq_cst, align 4, !some.unknown.md !0
@@ -125,8 +114,7 @@ define void @store_atomic_bf16_local(bfloat %val, ptr addrspace(3) %ptr) {
125114
define void @store_atomic_bf16_flat(bfloat %val, ptr %ptr) {
126115
; CHECK-LABEL: define void @store_atomic_bf16_flat(
127116
; CHECK-SAME: bfloat [[VAL:%.*]], ptr [[PTR:%.*]]) {
128-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast bfloat [[VAL]] to i16
129-
; CHECK-NEXT: store atomic i16 [[TMP1]], ptr [[PTR]] seq_cst, align 4
117+
; CHECK-NEXT: store atomic bfloat [[VAL]], ptr [[PTR]] seq_cst, align 4, !some.unknown.md [[META0]]
130118
; CHECK-NEXT: ret void
131119
;
132120
store atomic bfloat %val, ptr %ptr seq_cst, align 4, !some.unknown.md !0
@@ -135,8 +123,7 @@ define void @store_atomic_bf16_flat(bfloat %val, ptr %ptr) {
135123
define void @store_atomic_f64_global_system(double %val, ptr addrspace(1) %ptr) {
136124
; CHECK-LABEL: define void @store_atomic_f64_global_system(
137125
; CHECK-SAME: double [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
138-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast double [[VAL]] to i64
139-
; CHECK-NEXT: store atomic i64 [[TMP1]], ptr addrspace(1) [[PTR]] seq_cst, align 8
126+
; CHECK-NEXT: store atomic double [[VAL]], ptr addrspace(1) [[PTR]] seq_cst, align 8, !some.unknown.md [[META0]]
140127
; CHECK-NEXT: ret void
141128
;
142129
store atomic double %val, ptr addrspace(1) %ptr seq_cst, align 8, !some.unknown.md !0
@@ -146,8 +133,7 @@ define void @store_atomic_f64_global_system(double %val, ptr addrspace(1) %ptr)
146133
define void @store_atomic_f64_global_agent(double %val, ptr addrspace(1) %ptr) {
147134
; CHECK-LABEL: define void @store_atomic_f64_global_agent(
148135
; CHECK-SAME: double [[VAL:%.*]], ptr addrspace(1) [[PTR:%.*]]) {
149-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast double [[VAL]] to i64
150-
; CHECK-NEXT: store atomic i64 [[TMP1]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 8
136+
; CHECK-NEXT: store atomic double [[VAL]], ptr addrspace(1) [[PTR]] syncscope("agent") seq_cst, align 8, !some.unknown.md [[META0]]
151137
; CHECK-NEXT: ret void
152138
;
153139
store atomic double %val, ptr addrspace(1) %ptr syncscope("agent") seq_cst, align 8, !some.unknown.md !0
@@ -157,8 +143,7 @@ define void @store_atomic_f64_global_agent(double %val, ptr addrspace(1) %ptr) {
157143
define void @store_atomic_f64_local(double %val, ptr addrspace(3) %ptr) {
158144
; CHECK-LABEL: define void @store_atomic_f64_local(
159145
; CHECK-SAME: double [[VAL:%.*]], ptr addrspace(3) [[PTR:%.*]]) {
160-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast double [[VAL]] to i64
161-
; CHECK-NEXT: store atomic i64 [[TMP1]], ptr addrspace(3) [[PTR]] seq_cst, align 8
146+
; CHECK-NEXT: store atomic double [[VAL]], ptr addrspace(3) [[PTR]] seq_cst, align 8, !some.unknown.md [[META0]]
162147
; CHECK-NEXT: ret void
163148
;
164149
store atomic double %val, ptr addrspace(3) %ptr seq_cst, align 8, !some.unknown.md !0
@@ -168,12 +153,14 @@ define void @store_atomic_f64_local(double %val, ptr addrspace(3) %ptr) {
168153
define void @store_atomic_f64_flat(double %val, ptr %ptr) {
169154
; CHECK-LABEL: define void @store_atomic_f64_flat(
170155
; CHECK-SAME: double [[VAL:%.*]], ptr [[PTR:%.*]]) {
171-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast double [[VAL]] to i64
172-
; CHECK-NEXT: store atomic i64 [[TMP1]], ptr [[PTR]] seq_cst, align 8
156+
; CHECK-NEXT: store atomic double [[VAL]], ptr [[PTR]] seq_cst, align 8, !some.unknown.md [[META0]]
173157
; CHECK-NEXT: ret void
174158
;
175159
store atomic double %val, ptr %ptr seq_cst, align 8, !some.unknown.md !0
176160
ret void
177161
}
178162

179163
!0 = !{}
164+
;.
165+
; CHECK: [[META0]] = !{}
166+
;.

0 commit comments

Comments
 (0)