Skip to content

Commit 9f89ee4

Browse files
knickishknickish
committed
[M68k] add all remaining addressing modes for atomic ops
1 parent 5205619 commit 9f89ee4

File tree

8 files changed

+511
-17
lines changed

8 files changed

+511
-17
lines changed

‎llvm/lib/Target/M68k/Disassembler/M68kDisassembler.cpp

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,8 +19,8 @@
1919

2020
#include "llvm/MC/MCAsmInfo.h"
2121
#include "llvm/MC/MCContext.h"
22-
#include "llvm/MC/MCDisassembler/MCDisassembler.h"
2322
#include "llvm/MC/MCDecoderOps.h"
23+
#include "llvm/MC/MCDisassembler/MCDisassembler.h"
2424
#include "llvm/MC/MCInst.h"
2525
#include "llvm/MC/TargetRegistry.h"
2626
#include "llvm/Support/Endian.h"
@@ -83,6 +83,12 @@ static DecodeStatus DecodeXR32RegisterClass(MCInst &Inst, uint64_t RegNo,
8383
return DecodeRegisterClass(Inst, RegNo, Address, Decoder);
8484
}
8585

86+
static DecodeStatus DecodeXR32RegisterClass(MCInst &Inst, APInt RegNo,
87+
uint64_t Address,
88+
const void *Decoder) {
89+
return DecodeRegisterClass(Inst, RegNo.getZExtValue(), Address, Decoder);
90+
}
91+
8692
static DecodeStatus DecodeXR16RegisterClass(MCInst &Inst, uint64_t RegNo,
8793
uint64_t Address,
8894
const void *Decoder) {

‎llvm/lib/Target/M68k/M68kISelDAGToDAG.cpp

Lines changed: 16 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -708,6 +708,20 @@ bool M68kDAGToDAGISel::SelectARIPD(SDNode *Parent, SDValue N, SDValue &Base) {
708708
return false;
709709
}
710710

711+
static bool allowARIDWithDisp(SDNode *Parent) {
712+
if (!Parent)
713+
return false;
714+
switch (Parent->getOpcode()) {
715+
case ISD::LOAD:
716+
case ISD::STORE:
717+
case ISD::ATOMIC_LOAD:
718+
case ISD::ATOMIC_STORE:
719+
return true;
720+
default:
721+
return false;
722+
}
723+
}
724+
711725
bool M68kDAGToDAGISel::SelectARID(SDNode *Parent, SDValue N, SDValue &Disp,
712726
SDValue &Base) {
713727
LLVM_DEBUG(dbgs() << "Selecting AddrType::ARID: ");
@@ -740,7 +754,8 @@ bool M68kDAGToDAGISel::SelectARID(SDNode *Parent, SDValue N, SDValue &Disp,
740754
Base = AM.BaseReg;
741755

742756
if (getSymbolicDisplacement(AM, SDLoc(N), Disp)) {
743-
assert(!AM.Disp && "Should not be any displacement");
757+
assert((!AM.Disp || allowARIDWithDisp(Parent)) &&
758+
"Should not be any displacement");
744759
LLVM_DEBUG(dbgs() << "SUCCESS, matched Symbol\n");
745760
return true;
746761
}

‎llvm/lib/Target/M68k/M68kInstrAtomics.td

Lines changed: 139 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -13,17 +13,38 @@ foreach size = [8, 16, 32] in {
1313
def : Pat<(!cast<SDPatternOperator>("atomic_load_"#size) MxCP_ARII:$ptr),
1414
(!cast<MxInst>("MOV"#size#"df") !cast<MxMemOp>("MxARII"#size):$ptr)>;
1515

16+
def : Pat<(!cast<SDPatternOperator>("atomic_load_"#size) MxCP_ARID:$ptr),
17+
(!cast<MxInst>("MOV"#size#"dp") !cast<MxMemOp>("MxARID"#size):$ptr)>;
18+
19+
def : Pat<(!cast<SDPatternOperator>("atomic_load_"#size) MxCP_PCD:$ptr),
20+
(!cast<MxInst>("MOV"#size#"dq") !cast<MxMemOp>("MxPCD"#size):$ptr)>;
21+
22+
def : Pat<(!cast<SDPatternOperator>("atomic_load_"#size) MxCP_PCI:$ptr),
23+
(!cast<MxInst>("MOV"#size#"dk") !cast<MxMemOp>("MxPCI"#size):$ptr)>;
24+
1625
def : Pat<(!cast<SDPatternOperator>("atomic_store_"#size) !cast<MxRegOp>("MxDRD"#size):$val, MxCP_ARI:$ptr),
1726
(!cast<MxInst>("MOV"#size#"jd") !cast<MxMemOp>("MxARI"#size):$ptr,
1827
!cast<MxRegOp>("MxDRD"#size):$val)>;
1928

2029
def : Pat<(!cast<SDPatternOperator>("atomic_store_"#size) !cast<MxRegOp>("MxDRD"#size):$val, MxCP_ARII:$ptr),
2130
(!cast<MxInst>("MOV"#size#"fd") !cast<MxMemOp>("MxARII"#size):$ptr,
2231
!cast<MxRegOp>("MxDRD"#size):$val)>;
32+
33+
def : Pat<(!cast<SDPatternOperator>("atomic_store_"#size) !cast<MxRegOp>("MxDRD"#size):$val, MxCP_ARID:$ptr),
34+
(!cast<MxInst>("MOV"#size#"pd") !cast<MxMemOp>("MxARID"#size):$ptr,
35+
!cast<MxRegOp>("MxDRD"#size):$val)>;
36+
37+
def : Pat<(!cast<SDPatternOperator>("atomic_store_"#size) !cast<MxRegOp>("MxDRD"#size):$val, MxCP_PCD:$ptr),
38+
(!cast<MxInst>("MOV"#size#"qd") !cast<MxMemOp>("MxPCD"#size):$ptr,
39+
!cast<MxRegOp>("MxDRD"#size):$val)>;
40+
41+
def : Pat<(!cast<SDPatternOperator>("atomic_store_"#size) !cast<MxRegOp>("MxDRD"#size):$val, MxCP_PCI:$ptr),
42+
(!cast<MxInst>("MOV"#size#"kd") !cast<MxMemOp>("MxPCI"#size):$ptr,
43+
!cast<MxRegOp>("MxDRD"#size):$val)>;
2344
}
2445

2546
let Predicates = [AtLeastM68020] in {
26-
class MxCASOp<bits<2> size_encoding, MxType type>
47+
class MxCASARIOp<bits<2> size_encoding, MxType type>
2748
: MxInst<(outs type.ROp:$out),
2849
(ins type.ROp:$dc, type.ROp:$du, !cast<MxMemOp>("MxARI"#type.Size):$mem),
2950
"cas."#type.Prefix#" $dc, $du, $mem"> {
@@ -36,17 +57,128 @@ class MxCASOp<bits<2> size_encoding, MxType type>
3657
let mayStore = 1;
3758
}
3859

39-
def CAS8 : MxCASOp<0x1, MxType8d>;
40-
def CAS16 : MxCASOp<0x2, MxType16d>;
41-
def CAS32 : MxCASOp<0x3, MxType32d>;
60+
def CASARI8 : MxCASARIOp<0x1, MxType8d>;
61+
def CASARI16 : MxCASARIOp<0x2, MxType16d>;
62+
def CASARI32 : MxCASARIOp<0x3, MxType32d>;
63+
64+
class MxCASARIDOp<bits<2> size_encoding, MxType type>
65+
: MxInst<(outs type.ROp:$out),
66+
(ins type.ROp:$dc, type.ROp:$du, !cast<MxMemOp>("MxARID"#type.Size):$mem),
67+
"cas."#type.Prefix#" $dc, $du, $mem"> {
68+
let Inst = (ascend
69+
(descend 0b00001, size_encoding, 0b011, MxEncAddrMode_p<"mem">.EA),
70+
(descend 0b0000000, (operand "$du", 3), 0b000, (operand "$dc", 3))
71+
);
72+
let Constraints = "$out = $dc";
73+
let mayLoad = 1;
74+
let mayStore = 1;
75+
}
76+
77+
def CASARID8 : MxCASARIDOp<0x1, MxType8d>;
78+
def CASARID16 : MxCASARIDOp<0x2, MxType16d>;
79+
def CASARID32 : MxCASARIDOp<0x3, MxType32d>;
80+
81+
class MxCASARIIOp<bits<2> size_encoding, MxType type>
82+
: MxInst<(outs type.ROp:$out),
83+
(ins type.ROp:$dc, type.ROp:$du, !cast<MxMemOp>("MxARII"#type.Size):$mem),
84+
"cas."#type.Prefix#" $dc, $du, $mem"> {
85+
let Inst = (ascend
86+
(descend 0b00001, size_encoding, 0b011, MxEncAddrMode_f<"mem">.EA),
87+
(descend 0b0000000, (operand "$du", 3), 0b000, (operand "$dc", 3))
88+
);
89+
let Constraints = "$out = $dc";
90+
let mayLoad = 1;
91+
let mayStore = 1;
92+
}
93+
94+
def CASARII8 : MxCASARIIOp<0x1, MxType8d>;
95+
def CASARII16 : MxCASARIIOp<0x2, MxType16d>;
96+
def CASARII32 : MxCASARIIOp<0x3, MxType32d>;
4297

98+
class MxCASPCIOp<bits<2> size_encoding, MxType type>
99+
: MxInst<(outs type.ROp:$out),
100+
(ins type.ROp:$dc, type.ROp:$du, !cast<MxMemOp>("MxPCI"#type.Size):$mem),
101+
"cas."#type.Prefix#" $dc, $du, $mem"> {
102+
let Inst = (ascend
103+
(descend 0b00001, size_encoding, 0b011, MxEncAddrMode_k<"mem">.EA),
104+
(descend 0b0000000, (operand "$du", 3), 0b000, (operand "$dc", 3))
105+
);
106+
let Constraints = "$out = $dc";
107+
let mayLoad = 1;
108+
let mayStore = 1;
109+
}
43110

111+
def CASPCI8 : MxCASPCIOp<0x1, MxType8d>;
112+
def CASPCI16 : MxCASPCIOp<0x2, MxType16d>;
113+
def CASPCI32 : MxCASPCIOp<0x3, MxType32d>;
114+
115+
class MxCASPCDOp<bits<2> size_encoding, MxType type>
116+
: MxInst<(outs type.ROp:$out),
117+
(ins type.ROp:$dc, type.ROp:$du, !cast<MxMemOp>("MxPCD"#type.Size):$mem),
118+
"cas."#type.Prefix#" $dc, $du, $mem"> {
119+
let Inst = (ascend
120+
(descend 0b00001, size_encoding, 0b011, MxEncAddrMode_q<"mem">.EA),
121+
(descend 0b0000000, (operand "$du", 3), 0b000, (operand "$dc", 3))
122+
);
123+
let Constraints = "$out = $dc";
124+
let mayLoad = 1;
125+
let mayStore = 1;
126+
}
127+
128+
def CASPCD8 : MxCASPCDOp<0x1, MxType8d>;
129+
def CASPCD16 : MxCASPCDOp<0x2, MxType16d>;
130+
def CASPCD32 : MxCASPCDOp<0x3, MxType32d>;
131+
132+
class MxCASALOp<bits<2> size_encoding, MxType type>
133+
: MxInst<(outs type.ROp:$out),
134+
(ins type.ROp:$dc, type.ROp:$du, !cast<MxMemOp>("MxAL"#type.Size):$mem),
135+
"cas."#type.Prefix#" $dc, $du, $mem"> {
136+
let Inst = (ascend
137+
(descend 0b00001, size_encoding, 0b011, MxEncAddrMode_abs<"mem">.EA),
138+
(descend 0b0000000, (operand "$du", 3), 0b000, (operand "$dc", 3))
139+
);
140+
let Constraints = "$out = $dc";
141+
let mayLoad = 1;
142+
let mayStore = 1;
143+
}
144+
145+
def CASAL8 : MxCASALOp<0x1, MxType8d>;
146+
def CASAL16 : MxCASALOp<0x2, MxType16d>;
147+
def CASAL32 : MxCASALOp<0x3, MxType32d>;
148+
149+
foreach mode = ["ARI", "ARII", "ARID", "PCI", "PCD", "AL"] in {
44150
foreach size = [8, 16, 32] in {
45-
def : Pat<(!cast<SDPatternOperator>("atomic_cmp_swap_i"#size) MxCP_ARI:$ptr,
151+
def : Pat<(!cast<SDPatternOperator>("atomic_cmp_swap_i"#size) !cast<ComplexPattern>("MxCP_"#mode):$ptr,
46152
!cast<MxRegOp>("MxDRD"#size):$cmp,
47153
!cast<MxRegOp>("MxDRD"#size):$new),
48-
(!cast<MxInst>("CAS"#size) !cast<MxRegOp>("MxDRD"#size):$cmp,
154+
(!cast<MxInst>("CAS"#mode#size) !cast<MxRegOp>("MxDRD"#size):$cmp,
49155
!cast<MxRegOp>("MxDRD"#size):$new,
50-
!cast<MxMemOp>("MxARI"#size):$ptr)>;
156+
!cast<MxMemOp>("Mx"#mode#size):$ptr)>;
157+
} // size
158+
} // addr mode
159+
160+
class MxCASARDOp<bits<2> size_encoding, MxType type>
161+
: MxInst<(outs type.ROp:$out),
162+
(ins type.ROp:$dc, type.ROp:$du, !cast<MxRegOp>("MxARD"#type.Size):$mem),
163+
"cas."#type.Prefix#" $dc, $du, $mem"> {
164+
let Inst = (ascend
165+
(descend 0b00001, size_encoding, 0b011, MxEncAddrMode_a<"mem">.EA),
166+
(descend 0b0000000, (operand "$du", 3), 0b000, (operand "$dc", 3))
167+
);
168+
let Constraints = "$out = $dc";
169+
let mayLoad = 1;
170+
let mayStore = 1;
51171
}
172+
173+
def CASARD16 : MxCASARDOp<0x2, MxType16a>;
174+
def CASARD32 : MxCASARDOp<0x3, MxType32a>;
175+
176+
foreach size = [16, 32] in {
177+
def : Pat<(!cast<SDPatternOperator>("atomic_cmp_swap_i"#size) !cast<MxRegOp>("MxARD"#size):$ptr,
178+
!cast<MxRegOp>("MxDRD"#size):$cmp,
179+
!cast<MxRegOp>("MxDRD"#size):$new),
180+
(!cast<MxInst>("CASARD"#size) !cast<MxRegOp>("MxDRD"#size):$cmp,
181+
!cast<MxRegOp>("MxDRD"#size):$new,
182+
!cast<MxRegOp>("MxARD"#size):$ptr)>;
183+
} // size
52184
} // let Predicates = [AtLeastM68020]

‎llvm/test/CodeGen/M68k/Atomics/load-store.ll

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -604,3 +604,51 @@ define void @atomic_store_i64_seq_cst(ptr %a, i64 %val) nounwind {
604604
store atomic i64 %val, ptr %a seq_cst, align 8
605605
ret void
606606
}
607+
608+
define void @store_arid(ptr nonnull align 4 %a) {
609+
; NO-ATOMIC-LABEL: store_arid:
610+
; NO-ATOMIC: .cfi_startproc
611+
; NO-ATOMIC-NEXT: ; %bb.0: ; %start
612+
; NO-ATOMIC-NEXT: moveq #1, %d0
613+
; NO-ATOMIC-NEXT: move.l (4,%sp), %a0
614+
; NO-ATOMIC-NEXT: move.l %d0, (32,%a0)
615+
; NO-ATOMIC-NEXT: rts
616+
;
617+
; ATOMIC-LABEL: store_arid:
618+
; ATOMIC: .cfi_startproc
619+
; ATOMIC-NEXT: ; %bb.0: ; %start
620+
; ATOMIC-NEXT: moveq #1, %d0
621+
; ATOMIC-NEXT: move.l (4,%sp), %a0
622+
; ATOMIC-NEXT: move.l %d0, (32,%a0)
623+
; ATOMIC-NEXT: rts
624+
start:
625+
%1 = getelementptr inbounds i32, ptr %a, i32 8
626+
store atomic i32 1, ptr %1 seq_cst, align 4
627+
br label %exit
628+
629+
exit: ; preds = %start
630+
ret void
631+
}
632+
633+
define i32 @load_arid(ptr nonnull align 4 %a) {
634+
; NO-ATOMIC-LABEL: load_arid:
635+
; NO-ATOMIC: .cfi_startproc
636+
; NO-ATOMIC-NEXT: ; %bb.0: ; %start
637+
; NO-ATOMIC-NEXT: move.l (4,%sp), %a0
638+
; NO-ATOMIC-NEXT: move.l (32,%a0), %d0
639+
; NO-ATOMIC-NEXT: rts
640+
;
641+
; ATOMIC-LABEL: load_arid:
642+
; ATOMIC: .cfi_startproc
643+
; ATOMIC-NEXT: ; %bb.0: ; %start
644+
; ATOMIC-NEXT: move.l (4,%sp), %a0
645+
; ATOMIC-NEXT: move.l (32,%a0), %d0
646+
; ATOMIC-NEXT: rts
647+
start:
648+
%1 = getelementptr inbounds i32, ptr %a, i32 8
649+
%2 = load atomic i32, ptr %1 seq_cst, align 4
650+
br label %exit
651+
652+
exit: ; preds = %start
653+
ret i32 %2
654+
}

0 commit comments

Comments
 (0)