Skip to content

Commit 934d916

Browse files
AlexMacleanAlexMaclean
authored
[NVPTX] Use ADDR operand for atomic instructions (#130438)
1 parent 933221e commit 934d916

File tree

1 file changed

+44
-89
lines changed

1 file changed

+44
-89
lines changed

‎llvm/lib/Target/NVPTX/NVPTXIntrinsics.td

Lines changed: 44 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -1982,93 +1982,72 @@ class ATOMIC_SHARED_CHK <dag ops, dag frag>
19821982
class ATOMIC_GENERIC_CHK <dag ops, dag frag>
19831983
: PatFrag<ops, frag, AS_match.generic>;
19841984

1985-
multiclass F_ATOMIC_2_imp<ValueType ptrT, NVPTXRegClass ptrclass,
1985+
multiclass F_ATOMIC_2<
19861986
ValueType regT, NVPTXRegClass regclass,
19871987
string SpaceStr, string TypeStr, string OpcStr, PatFrag IntOp,
1988-
Operand IMMType, SDNode IMM, list<Predicate> Pred> {
1988+
Operand IMMType, SDNode IMM, list<Predicate> Pred = []> {
19891989
let mayLoad = 1, mayStore = 1, hasSideEffects = 1 in {
1990-
def reg : NVPTXInst<(outs regclass:$dst), (ins ptrclass:$addr, regclass:$b),
1991-
!strconcat("atom", SpaceStr, OpcStr, TypeStr, " \t$dst, [$addr], $b;"),
1992-
[(set (regT regclass:$dst), (IntOp (ptrT ptrclass:$addr), (regT regclass:$b)))]>,
1990+
def r : NVPTXInst<(outs regclass:$dst), (ins ADDR:$addr, regclass:$b),
1991+
"atom" # SpaceStr # OpcStr # TypeStr # " \t$dst, [$addr], $b;",
1992+
[(set (regT regclass:$dst), (IntOp addr:$addr, (regT regclass:$b)))]>,
19931993
Requires<Pred>;
1994-
def imm : NVPTXInst<(outs regclass:$dst), (ins ptrclass:$addr, IMMType:$b),
1995-
!strconcat("atom", SpaceStr, OpcStr, TypeStr, " \t$dst, [$addr], $b;", ""),
1996-
[(set (regT regclass:$dst), (IntOp (ptrT ptrclass:$addr), IMM:$b))]>,
1997-
Requires<!if(!or(!eq(TypeStr, ".f16"), !eq(TypeStr, ".bf16")), [Predicate<"false">], Pred)>;
1994+
if !not(!or(!eq(TypeStr, ".f16"), !eq(TypeStr, ".bf16"))) then
1995+
def i : NVPTXInst<(outs regclass:$dst), (ins ADDR:$addr, IMMType:$b),
1996+
"atom" # SpaceStr # OpcStr # TypeStr # " \t$dst, [$addr], $b;",
1997+
[(set (regT regclass:$dst), (IntOp addr:$addr, IMM:$b))]>,
1998+
Requires<Pred>;
19981999
}
19992000
}
2000-
multiclass F_ATOMIC_2<ValueType regT, NVPTXRegClass regclass, string SpaceStr, string TypeStr,
2001-
string OpcStr, PatFrag IntOp, Operand IMMType, SDNode IMM,
2002-
list<Predicate> Pred = []> {
2003-
defm p32 : F_ATOMIC_2_imp<i32, Int32Regs, regT, regclass, SpaceStr, TypeStr, OpcStr,
2004-
IntOp, IMMType, IMM, Pred>;
2005-
defm p64 : F_ATOMIC_2_imp<i64, Int64Regs, regT, regclass, SpaceStr, TypeStr, OpcStr,
2006-
IntOp, IMMType, IMM, Pred>;
2007-
}
20082001

20092002
// has 2 operands, neg the second one
2010-
multiclass F_ATOMIC_2_NEG_imp<ValueType ptrT, NVPTXRegClass ptrclass,
2003+
multiclass F_ATOMIC_2_NEG<
20112004
ValueType regT, NVPTXRegClass regclass,
20122005
string SpaceStr, string TypeStr, string OpcStr, PatFrag IntOp,
2013-
list<Predicate> Pred> {
2006+
list<Predicate> Pred = []> {
20142007
let mayLoad = 1, mayStore = 1, hasSideEffects = 1 in {
2015-
def reg : NVPTXInst<(outs regclass:$dst), (ins ptrclass:$addr, regclass:$b),
2008+
def reg : NVPTXInst<(outs regclass:$dst), (ins ADDR:$addr, regclass:$b),
20162009
!strconcat(
20172010
"{{ \n\t",
20182011
".reg \t.s", TypeStr, " temp; \n\t",
20192012
"neg.s", TypeStr, " \ttemp, $b; \n\t",
20202013
"atom", SpaceStr, OpcStr, ".u", TypeStr, " \t$dst, [$addr], temp; \n\t",
20212014
"}}"),
2022-
[(set (regT regclass:$dst), (IntOp (ptrT ptrclass:$addr), (regT regclass:$b)))]>,
2015+
[(set (regT regclass:$dst), (IntOp addr:$addr, (regT regclass:$b)))]>,
20232016
Requires<Pred>;
20242017
}
20252018
}
2026-
multiclass F_ATOMIC_2_NEG<ValueType regT, NVPTXRegClass regclass, string SpaceStr,
2027-
string TypeStr, string OpcStr, PatFrag IntOp, list<Predicate> Pred = []> {
2028-
defm p32: F_ATOMIC_2_NEG_imp<i32, Int32Regs, regT, regclass, SpaceStr, TypeStr, OpcStr,
2029-
IntOp, Pred> ;
2030-
defm p64: F_ATOMIC_2_NEG_imp<i64, Int64Regs, regT, regclass, SpaceStr, TypeStr, OpcStr,
2031-
IntOp, Pred> ;
2032-
}
20332019

20342020
// has 3 operands
2035-
multiclass F_ATOMIC_3_imp<ValueType ptrT, NVPTXRegClass ptrclass,
2021+
multiclass F_ATOMIC_3<
20362022
ValueType regT, NVPTXRegClass regclass, string SemStr,
20372023
string SpaceStr, string TypeStr, string OpcStr, PatFrag IntOp,
2038-
Operand IMMType, list<Predicate> Pred> {
2024+
Operand IMMType, list<Predicate> Pred = []> {
20392025
let mayLoad = 1, mayStore = 1, hasSideEffects = 1 in {
2040-
def reg : NVPTXInst<(outs regclass:$dst),
2041-
(ins ptrclass:$addr, regclass:$b, regclass:$c),
2042-
!strconcat("atom", SemStr, SpaceStr, OpcStr, TypeStr, " \t$dst, [$addr], $b, $c;"),
2043-
[(set (regT regclass:$dst), (IntOp (ptrT ptrclass:$addr), (regT regclass:$b), (regT regclass:$c)))]>,
2026+
def rr : NVPTXInst<(outs regclass:$dst),
2027+
(ins ADDR:$addr, regclass:$b, regclass:$c),
2028+
"atom" # SemStr # SpaceStr # OpcStr # TypeStr # " \t$dst, [$addr], $b, $c;",
2029+
[(set (regT regclass:$dst), (IntOp addr:$addr, regT:$b, regT:$c))]>,
20442030
Requires<Pred>;
20452031

2046-
def imm1 : NVPTXInst<(outs regclass:$dst),
2047-
(ins ptrclass:$addr, IMMType:$b, regclass:$c),
2048-
!strconcat("atom", SemStr, SpaceStr, OpcStr, TypeStr, " \t$dst, [$addr], $b, $c;"),
2049-
[(set (regT regclass:$dst), (IntOp (ptrT ptrclass:$addr), imm:$b, (regT regclass:$c)))]>,
2032+
def ir : NVPTXInst<(outs regclass:$dst),
2033+
(ins ADDR:$addr, IMMType:$b, regclass:$c),
2034+
"atom" # SemStr # SpaceStr # OpcStr # TypeStr # " \t$dst, [$addr], $b, $c;",
2035+
[(set (regT regclass:$dst), (IntOp addr:$addr, imm:$b, regT:$c))]>,
20502036
Requires<Pred>;
20512037

2052-
def imm2 : NVPTXInst<(outs regclass:$dst),
2053-
(ins ptrclass:$addr, regclass:$b, IMMType:$c),
2054-
!strconcat("atom", SemStr, SpaceStr, OpcStr, TypeStr, " \t$dst, [$addr], $b, $c;", ""),
2055-
[(set (regT regclass:$dst), (IntOp (ptrT ptrclass:$addr), (regT regclass:$b), imm:$c))]>,
2038+
def ri : NVPTXInst<(outs regclass:$dst),
2039+
(ins ADDR:$addr, regclass:$b, IMMType:$c),
2040+
"atom" # SemStr # SpaceStr # OpcStr # TypeStr # " \t$dst, [$addr], $b, $c;",
2041+
[(set (regT regclass:$dst), (IntOp addr:$addr, regT:$b, imm:$c))]>,
20562042
Requires<Pred>;
20572043

2058-
def imm3 : NVPTXInst<(outs regclass:$dst),
2059-
(ins ptrclass:$addr, IMMType:$b, IMMType:$c),
2060-
!strconcat("atom", SemStr, SpaceStr, OpcStr, TypeStr, " \t$dst, [$addr], $b, $c;"),
2061-
[(set (regT regclass:$dst), (IntOp (ptrT ptrclass:$addr), imm:$b, imm:$c))]>,
2044+
def ii : NVPTXInst<(outs regclass:$dst),
2045+
(ins ADDR:$addr, IMMType:$b, IMMType:$c),
2046+
"atom" # SemStr # SpaceStr # OpcStr # TypeStr # " \t$dst, [$addr], $b, $c;",
2047+
[(set (regT regclass:$dst), (IntOp addr:$addr, imm:$b, imm:$c))]>,
20622048
Requires<Pred>;
20632049
}
20642050
}
2065-
multiclass F_ATOMIC_3<ValueType regT, NVPTXRegClass regclass, string SemStr, string SpaceStr,
2066-
string TypeStr, string OpcStr, PatFrag IntOp, Operand IMMType, list<Predicate> Pred = []> {
2067-
defm p32 : F_ATOMIC_3_imp<i32, Int32Regs, regT, regclass, SemStr, SpaceStr, TypeStr,
2068-
OpcStr, IntOp, IMMType, Pred>;
2069-
defm p64 : F_ATOMIC_3_imp<i64, Int64Regs, regT, regclass, SemStr, SpaceStr, TypeStr,
2070-
OpcStr, IntOp, IMMType, Pred>;
2071-
}
20722051

20732052
// atom_add
20742053

@@ -2540,27 +2519,15 @@ multiclass ATOM2P_impl<string AsmStr, Intrinsic Intr,
25402519
list<Predicate> Preds> {
25412520
let AddedComplexity = 1 in {
25422521
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2543-
(ins Int16Regs:$src, regclass:$b),
2544-
(Intr i16:$src, regT:$b)>;
2545-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2546-
(ins Int32Regs:$src, regclass:$b),
2547-
(Intr i32:$src, regT:$b)>;
2548-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2549-
(ins Int64Regs:$src, regclass:$b),
2550-
(Intr i64:$src, regT:$b)>;
2522+
(ins ADDR:$src, regclass:$b),
2523+
(Intr addr:$src, regT:$b)>;
25512524
}
25522525
// tablegen can't infer argument types from Intrinsic (though it can
25532526
// from Instruction) so we have to enforce specific type on
25542527
// immediates via explicit cast to ImmTy.
25552528
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2556-
(ins Int16Regs:$src, ImmType:$b),
2557-
(Intr i16:$src, (ImmTy Imm:$b))>;
2558-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2559-
(ins Int32Regs:$src, ImmType:$b),
2560-
(Intr i32:$src, (ImmTy Imm:$b))>;
2561-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2562-
(ins Int64Regs:$src, ImmType:$b),
2563-
(Intr i64:$src, (ImmTy Imm:$b))>;
2529+
(ins ADDR:$src, ImmType:$b),
2530+
(Intr addr:$src, (ImmTy Imm:$b))>;
25642531
}
25652532

25662533
multiclass ATOM3P_impl<string AsmStr, Intrinsic Intr,
@@ -2570,32 +2537,20 @@ multiclass ATOM3P_impl<string AsmStr, Intrinsic Intr,
25702537
// Variants for register/immediate permutations of $b and $c
25712538
let AddedComplexity = 2 in {
25722539
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2573-
(ins Int32Regs:$src, regclass:$b, regclass:$c),
2574-
(Intr i32:$src, regT:$b, regT:$c)>;
2575-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2576-
(ins Int64Regs:$src, regclass:$b, regclass:$c),
2577-
(Intr i64:$src, regT:$b, regT:$c)>;
2540+
(ins ADDR:$src, regclass:$b, regclass:$c),
2541+
(Intr addr:$src, regT:$b, regT:$c)>;
25782542
}
25792543
let AddedComplexity = 1 in {
25802544
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2581-
(ins Int32Regs:$src, ImmType:$b, regclass:$c),
2582-
(Intr i32:$src, (ImmTy Imm:$b), regT:$c)>;
2545+
(ins ADDR:$src, ImmType:$b, regclass:$c),
2546+
(Intr addr:$src, (ImmTy Imm:$b), regT:$c)>;
25832547
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2584-
(ins Int64Regs:$src, ImmType:$b, regclass:$c),
2585-
(Intr i64:$src, (ImmTy Imm:$b), regT:$c)>;
2586-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2587-
(ins Int32Regs:$src, regclass:$b, ImmType:$c),
2588-
(Intr i32:$src, regT:$b, (ImmTy Imm:$c))>;
2589-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2590-
(ins Int64Regs:$src, regclass:$b, ImmType:$c),
2591-
(Intr i64:$src, regT:$b, (ImmTy Imm:$c))>;
2548+
(ins ADDR:$src, regclass:$b, ImmType:$c),
2549+
(Intr addr:$src, regT:$b, (ImmTy Imm:$c))>;
25922550
}
25932551
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2594-
(ins Int32Regs:$src, ImmType:$b, ImmType:$c),
2595-
(Intr i32:$src, (ImmTy Imm:$b), (ImmTy Imm:$c))>;
2596-
def : ATOM23_impl<AsmStr, regT, regclass, Preds,
2597-
(ins Int64Regs:$src, ImmType:$b, ImmType:$c),
2598-
(Intr i64:$src, (ImmTy Imm:$b), (ImmTy Imm:$c))>;
2552+
(ins ADDR:$src, ImmType:$b, ImmType:$c),
2553+
(Intr addr:$src, (ImmTy Imm:$b), (ImmTy Imm:$c))>;
25992554
}
26002555

26012556
// Constructs intrinsic name and instruction asm strings.

0 commit comments

Comments
 (0)