[Xe] Canonicalize XeSymbolOperand in TableGen

Continue refactoring from intel#1140, intel#1143, intel#1166
bader · May 14, 2024 · 77cf8f3 · 77cf8f3
1 parent be00b2a
commit 77cf8f3
Show file tree

Hide file tree

Showing 7 changed files with 33 additions and 16 deletions.
diff --git a/llvm/lib/Target/Xe/AsmParser/XeAsmParser.cpp b/llvm/lib/Target/Xe/AsmParser/XeAsmParser.cpp
@@ -72,8 +72,8 @@ class XeOperand : public MCParsedAsmOperand {
     k_Immf64Opnd,
     k_LoadFields,
     k_StoreFields,
-    k_UIPOpnd,
-    k_JIPOpnd,
+    k_UIPOtherOpnd,
+    k_JIPOtherOpnd,
     k_SAAddrOpnd, // addr with $indaddr, $addr and $ldstoff operands
     k_SNAddrOpnd, // addr with $indaddr and $ldstoff operands
     k_NAAddrOpnd, // addr with $addr and $ldstoff operands
@@ -244,10 +244,12 @@ class XeOperand : public MCParsedAsmOperand {
   bool isNNAddrOpnd() const { return Kind == k_NNAddrOpnd; }
   bool isMem() const override { return false; }
 
-  bool isSymbolRef() const { return Kind == k_UIPOpnd || Kind == k_JIPOpnd; }
+  bool isSymbolRef() const {
+    return Kind == k_UIPOtherOpnd || Kind == k_JIPOtherOpnd;
+  }
 
-  bool isUIPOpnd() const { return Kind == k_UIPOpnd; }
-  bool isJIPOpnd() const { return Kind == k_JIPOpnd; }
+  bool isUIPOtherOpnd() const { return Kind == k_UIPOtherOpnd; }
+  bool isJIPOtherOpnd() const { return Kind == k_JIPOtherOpnd; }
   bool isGlobalVarOrImm64Opnd() const { return Kind == k_GlobalVarOrImm64Opnd; }
   bool isBfnSubOpcode() const { return Kind == k_BfnSubOpcode; }
 
@@ -567,11 +569,11 @@ class XeOperand : public MCParsedAsmOperand {
     MCI.addOperand(MCOperand::createDFPImm(getImmf64Opnd()));
   }
 
-  void addUIPOpndOperands(MCInst &MCI, unsigned N) const {
+  void addUIPOtherOpndOperands(MCInst &MCI, unsigned N) const {
     assert(N == 1 && "Invalid number of operands!");
     MCI.addOperand(MCOperand::createExpr(getSymbolRef()));
   }
-  void addJIPOpndOperands(MCInst &MCI, unsigned N) const {
+  void addJIPOtherOpndOperands(MCInst &MCI, unsigned N) const {
     assert(N == 1 && "Invalid number of operands!");
     MCI.addOperand(MCOperand::createExpr(getSymbolRef()));
   }
@@ -833,11 +835,14 @@ class XeAsmParser : public MCTargetAsmParser {
 
   ParseStatus parseSymbolRef(XeOperand::KindTy K, OperandVector &Operands);
 
+  template <MVT::SimpleValueType T>
   ParseStatus parseUIPOpnd(OperandVector &Operands) {
-    return parseSymbolRef(XeOperand::k_UIPOpnd, Operands);
+    return parseSymbolRef(XeOperand::k_UIPOtherOpnd, Operands);
   }
+
+  template <MVT::SimpleValueType T>
   ParseStatus parseJIPOpnd(OperandVector &Operands) {
-    return parseSymbolRef(XeOperand::k_JIPOpnd, Operands);
+    return parseSymbolRef(XeOperand::k_JIPOtherOpnd, Operands);
   }
   ParseStatus parseGlobalVarOrImm64Opnd(OperandVector &Operands) {
     // A symbol reference starts with "@", otherwise it is an imm64 operand

diff --git a/llvm/lib/Target/Xe/Disassembler/XeDisassembler.cpp b/llvm/lib/Target/Xe/Disassembler/XeDisassembler.cpp
@@ -409,6 +409,7 @@ static DecodeStatus decodeNoMaskOpnd(MCInst &MCI, uint64_t Bits,
   return MCDisassembler::Success;
 }
 
+template <MVT::SimpleValueType T>
 static DecodeStatus decodeJIPOpnd(MCInst &MCI, uint64_t Bits, uint64_t Address,
                                   const MCDisassembler *Decoder) {
   LLVM_DEBUG(dumpDecodeInfo(__FUNCTION__, MCI, Decoder));
@@ -423,6 +424,7 @@ static DecodeStatus decodeJIPOpnd(MCInst &MCI, uint64_t Bits, uint64_t Address,
   return MCDisassembler::Success;
 }
 
+template <MVT::SimpleValueType T>
 static DecodeStatus decodeUIPOpnd(MCInst &MCI, uint64_t Bits, uint64_t Address,
                                   const MCDisassembler *Decoder) {
   LLVM_DEBUG(dumpDecodeInfo(__FUNCTION__, MCI, Decoder));

diff --git a/llvm/lib/Target/Xe/MCTargetDesc/XeInstPrinter.cpp b/llvm/lib/Target/Xe/MCTargetDesc/XeInstPrinter.cpp
@@ -656,12 +656,14 @@ void XeInstPrinter::printImmOpnd(const MCInst *MCI, unsigned OpNo,
   }
 }
 
+template <MVT::SimpleValueType T>
 void XeInstPrinter::printUIPOpnd(const MCInst *MCI, uint64_t Address,
                                  unsigned OpNo, raw_ostream &OS) {
   const MCOperand &MCOp = MCI->getOperand(OpNo);
   MCOp.getExpr()->print(OS, &MAI);
 }
 
+template <MVT::SimpleValueType T>
 void XeInstPrinter::printJIPOpnd(const MCInst *MCI, uint64_t Address,
                                  unsigned OpNo, raw_ostream &OS) {
   const MCOperand &MCOp = MCI->getOperand(OpNo);

diff --git a/llvm/lib/Target/Xe/MCTargetDesc/XeInstPrinter.h b/llvm/lib/Target/Xe/MCTargetDesc/XeInstPrinter.h
@@ -50,8 +50,11 @@ class XeInstPrinter : public MCInstPrinter {
   template <MVT::SimpleValueType T>
   void printImmOpnd(const MCInst *MCI, unsigned OpNo, raw_ostream &OS);
 
+  template <MVT::SimpleValueType T>
   void printUIPOpnd(const MCInst *MCI, uint64_t Address, unsigned OpNo,
                     raw_ostream &OS);
+
+  template <MVT::SimpleValueType T>
   void printJIPOpnd(const MCInst *MCI, uint64_t Address, unsigned OpNo,
                     raw_ostream &OS);
   void printGlobalVarOrImm64Opnd(const MCInst *MCI, unsigned OpNo,

diff --git a/llvm/lib/Target/Xe/MCTargetDesc/XeMCCodeEmitter.cpp b/llvm/lib/Target/Xe/MCTargetDesc/XeMCCodeEmitter.cpp
@@ -94,9 +94,11 @@ class XeMCCodeEmitter : public MCCodeEmitter {
   void encodeSBIDOpnd(const MCInst &MI, unsigned OpNo, APInt &Op,
                       SmallVectorImpl<MCFixup> &Fixups,
                       const MCSubtargetInfo &STI) const;
+  template <MVT::SimpleValueType T>
   void encodeUIPOpnd(const MCInst &MI, unsigned OpNo, APInt &Op,
                      SmallVectorImpl<MCFixup> &Fixups,
                      const MCSubtargetInfo &STI) const;
+  template <MVT::SimpleValueType T>
   void encodeJIPOpnd(const MCInst &MI, unsigned OpNo, APInt &Op,
                      SmallVectorImpl<MCFixup> &Fixups,
                      const MCSubtargetInfo &STI) const;
@@ -281,6 +283,7 @@ void XeMCCodeEmitter::encodeSBIDOpnd(const MCInst &MI, unsigned OpNo, APInt &Op,
   Op = MI.getOperand(OpNo).getImm();
 }
 
+template <MVT::SimpleValueType T>
 void XeMCCodeEmitter::encodeUIPOpnd(const MCInst &MCI, unsigned OpNo, APInt &Op,
                                     SmallVectorImpl<MCFixup> &Fixups,
                                     const MCSubtargetInfo &STI) const {
@@ -290,6 +293,7 @@ void XeMCCodeEmitter::encodeUIPOpnd(const MCInst &MCI, unsigned OpNo, APInt &Op,
   encodePCRel32ImmOpnd(MCI, MCOp.getExpr(), /*Offset=*/5, Op, Fixups, STI);
 }
 
+template <MVT::SimpleValueType T>
 void XeMCCodeEmitter::encodeJIPOpnd(const MCInst &MCI, unsigned OpNo, APInt &Op,
                                     SmallVectorImpl<MCFixup> &Fixups,
                                     const MCSubtargetInfo &STI) const {

diff --git a/llvm/lib/Target/Xe/XeInstrFormats.td b/llvm/lib/Target/Xe/XeInstrFormats.td
@@ -49,16 +49,17 @@ class XeOperandNameWithRC<string BaseName, RegisterClass rc> {
   string dm = "decode" # Name;
 }
 
-class XeAsmOperandWithTY<string BaseName, ValueType ty, string NameWithTY>
+class XeAsmOperandWithTY<string BaseName, string TyName, string NameWithTY>
   : AsmOperandClass {
-  let Name = BaseName # ty # "Opnd";
+  let Name = BaseName # TyName # "Opnd";
   let ParserMethod = "parse" # NameWithTY;
 }
 
 class XeOperandNameWithTY<string BaseName, ValueType ty> {
-  string Name = BaseName # "Opnd" # "<MVT::" # ty # ">";
+  string TyName = !if ( !eq(ty, OtherVT), "Other", !cast<string>(ty) );
+  string Name = BaseName # "Opnd" # "<MVT::" # TyName # ">";
   string pm = "print" # Name;
-  AsmOperandClass pmc = XeAsmOperandWithTY<BaseName, ty, Name>;
+  AsmOperandClass pmc = XeAsmOperandWithTY<BaseName, TyName, Name>;
   string em = "encode" # Name;
   string sm = "select" # Name;
   string dm = "decode" # Name;
@@ -84,7 +85,7 @@ class XeSymbolOrImmOperand<ValueType ty, string name>
   : XeOperandOld<ty, name>;
 
 class XeSymbolOperand<ValueType ty, string name>
-  : XeOperandOld<ty, name> {
+  : XeOperand<ty, name> {
   let OperandType = "OPERAND_PCREL";
 }
 

diff --git a/llvm/lib/Target/Xe/XeInstrInfo.td b/llvm/lib/Target/Xe/XeInstrInfo.td
@@ -680,8 +680,8 @@ let isReturn = 1, isBarrier = 1, isTerminator = 1, isNotDuplicable = 1,
   }
 }
 
-def UIPOpnd : XeSymbolOperand<OtherVT, "UIPOpnd">;
-def JIPOpnd : XeSymbolOperand<OtherVT, "JIPOpnd">;
+def UIPOpnd : XeSymbolOperand<OtherVT, "UIP">;
+def JIPOpnd : XeSymbolOperand<OtherVT, "JIP">;
 
 let swsb = 0, src0 = 0 in {
   let fields = 0, uip = 0 in {