[AMDGPU][AsmParser][NFC] Specify parser methods directly in operand classes.

[kosarev]

Summary

Eliminates the need for custom operand classes whose only purpose is to
define a parser method.

Part of https://github.com/llvm/llvm-project/issues/62629.

[dp]

LGTM.

[kosarev]

@dp Thanks a lot for reviewing these, Dmitry! Will try to find someone to help with reviewing future AsmParser patches.

llvm/lib/Target/AMDGPU/AMDGPUInstructions.td

 def NoFP64Denormals : Predicate<"!MF->getInfo<SIMachineFunctionInfo>()->getMode().allFP64FP16Denormals()">;
 def UnsafeFPMath : Predicate<"TM.Options.UnsafeFPMath">;
 }
 
 def FMA : Predicate<"Subtarget->hasFMA()">;
 
 def InstFlag : OperandWithDefaultOps <i32, (ops (i32 0))>;
 
-class CustomOperandClass<string name, bit optional> : AsmOperandClass {
+class CustomOperandClass<string name, bit optional, string parserMethod>
+    : AsmOperandClass {
   let Name = name;
   let PredicateMethod = "is"#name;
-  let ParserMethod = "parse"#name;
+  let ParserMethod = parserMethod;
   let RenderMethod = "addImmOperands";
   let IsOptional = optional;
   let DefaultMethod = "default"#name;
 }
 
-class CustomOperandProps<bit optional = 0, string name = NAME,
-    AsmOperandClass opClass = CustomOperandClass<name, optional>> {
+class CustomOperandProps<bit optional = 0, string name = NAME> {
+  string ParserMethod = "parse"#name;
   string PrintMethod = "print"#name;
-  AsmOperandClass ParserMatchClass = opClass;
+  AsmOperandClass ParserMatchClass =
+    CustomOperandClass<name, optional, ParserMethod>;
   string OperandType = "OPERAND_IMMEDIATE";
 }
 
-class CustomOperand<ValueType type, bit optional = 0, string name = NAME,
-    AsmOperandClass opClass = CustomOperandClass<name, optional>>
-  : Operand<type>, CustomOperandProps<optional, name, opClass>;
-
-class ImmOperandClass<string name, bit optional>
-    : CustomOperandClass<name, optional> {
-  let ParserMethod = "";
-}
+class CustomOperand<ValueType type, bit optional = 0, string name = NAME>
+  : Operand<type>, CustomOperandProps<optional, name>;
 
 class ImmOperand<ValueType type, string name, bit optional = 0,
                  string printer = "print"#name>
-    : CustomOperand<type, optional, name, ImmOperandClass<name, optional>> {
+    : CustomOperand<type, optional, name> {
+  let ParserMethod = "";
   let PrintMethod = printer;
 }
 
 def s16imm : ImmOperand<i16, "S16Imm", 0, "printU16ImmOperand">;
 def u16imm : ImmOperand<i16, "U16Imm", 0, "printU16ImmOperand">;
 
 //===--------------------------------------------------------------------===//
 // Custom Operands

llvm/lib/Target/AMDGPU/SIInstrInfo.td

 def SDWAVopcDst : BoolRC {
   let OperandNamespace = "AMDGPU";
   let OperandType = "OPERAND_SDWA_VOPC_DST";
   let EncoderMethod = "getSDWAVopcDstEncoding";
   let DecoderMethod = "decodeSDWAVopcDst";
   let PrintMethod = "printVOPDst";
 }
 
-class NamedIntOperandClass<string Prefix, string Name, string ConvertMethod>
-    : CustomOperandClass<Name, 1> {
+class NamedIntOperand<ValueType Type, string Prefix, string Name = NAME,
+                      string ConvertMethod = "nullptr">
+    : CustomOperand<Type, 1, Name> {
   string ImmTy = "AMDGPUOperand::ImmTy"#Name;
   let ParserMethod =
     "[this](OperandVector &Operands) -> OperandMatchResultTy { "#
     "return parseIntWithPrefix(\""#Prefix#"\", Operands, "#ImmTy#", "#
     ConvertMethod#"); }";
 }
 
-class NamedIntOperand<ValueType Type, string Prefix, string Name = NAME,
-                      string ConvertMethod = "nullptr">
-  : CustomOperand<Type, 1, Name, NamedIntOperandClass<Prefix, Name, ConvertMethod>>;
-
-class BitOperandClass<string Id, string Name>
-    : CustomOperandClass<Name, 1> {
+class NamedBitOperand<string Id, string Name = NAME>
+    : CustomOperand<i1, 1, Name> {
   string ImmTy = "AMDGPUOperand::ImmTy"#Name;
   let ParserMethod =
     "[this](OperandVector &Operands) -> OperandMatchResultTy { "#
     "return parseNamedBit(\""#Id#"\", Operands, "#ImmTy#"); }";
 }
 
-class NamedBitOperand<string Id, string Name = NAME>
-  : CustomOperand<i1, 1, Name, BitOperandClass<Id, Name>>;
-
 class DefaultOperand<CustomOperand Op, int Value>
   : OperandWithDefaultOps<Op.Type, (ops (Op.Type Value))>,
-    CustomOperandProps<1, Op.ParserMatchClass.Name, Op.ParserMatchClass>;
+    CustomOperandProps<1, Op.ParserMatchClass.Name> {
+  let ParserMethod = Op.ParserMatchClass.ParserMethod;
+}
 
-class SDWAOperandClass<string Id, string Name>
-    : CustomOperandClass<Name, 1> {
+class SDWAOperand<string Id, string Name = NAME>
+    : CustomOperand<i32, 1, Name> {
   string ImmTy = "AMDGPUOperand::ImmTy"#Name;
   let ParserMethod =
     "[this](OperandVector &Operands) -> OperandMatchResultTy { "#
     "return parseSDWASel(Operands, \""#Id#"\", "#ImmTy#"); }";
 }
 
-class SDWAOperand<string Id, string Name = NAME>
-  : CustomOperand<i32, 1, Name, SDWAOperandClass<Id, Name>>;
-
-class ArrayOperandClass<string Id, string Name>
-    : CustomOperandClass<Name, 1> {
+class ArrayOperand0<string Id, string Name = NAME>
+  : OperandWithDefaultOps<i32, (ops (i32 0))>,
+    CustomOperandProps<1, Name> {
   string ImmTy = "AMDGPUOperand::ImmTy"#Name;
   let ParserMethod =
     "[this](OperandVector &Operands) -> OperandMatchResultTy { "#
     "return parseOperandArrayWithPrefix(\""#Id#"\", Operands, "#ImmTy#"); }";
 }
 
-class ArrayOperand0<string Id, string Name = NAME>
-  : OperandWithDefaultOps<i32, (ops (i32 0))>,
-    CustomOperandProps<1, Name, ArrayOperandClass<Id, Name>>;
-
 def flat_offset : CustomOperand<i32, 1, "FlatOffset">;
 def offset : NamedIntOperand<i32, "offset", "Offset">;
 def offset0 : NamedIntOperand<i8, "offset0", "Offset0">;
 def offset1 : NamedIntOperand<i8, "offset1", "Offset1">;
 
 def gds : NamedBitOperand<"gds", "GDS">;
 
 def omod : CustomOperand<i32, 1, "OModSI">;