[TableGen] Allow BitsInit to init integer in pseudo expansion

[Paul-C-Anagnostopoulos]

llvm/utils/TableGen/PseudoLoweringEmitter.cpp

111

I would declare BI as BitsInit *BI, for consistency.

113

Please include a message in the assert, in the usual way.

[sepavloff]

Addressed reviewer's notes

[Paul-C-Anagnostopoulos]

I presume this change passes all the TableGen tests?

[sepavloff]

In D99057#2641714, @Paul-C-Anagnostopoulos wrote:

I presume this change passes all the TableGen tests?

I ran check-llvm.

[Paul-C-Anagnostopoulos]

Looks good to me.

[craig.topper]

llvm/utils/TableGen/PseudoLoweringEmitter.cpp

113

Just use a cast instead of checking dyn_cast with an assert.

[sepavloff]

llvm/utils/TableGen/PseudoLoweringEmitter.cpp

113

Thank you!
Fixed in https://reviews.llvm.org/rGcf0f2884a1d9

llvm/test/TableGen/pseudo-inst-expansion.td

+// RUN: llvm-tblgen -gen-pseudo-lowering -I %p/../../include %s | FileCheck %s
+
+include "llvm/Target/Target.td"
+
+def TestTargetInstrInfo : InstrInfo;
+
+def TestTarget : Target {
+  let InstructionSet = TestTargetInstrInfo;
+}
+
+def REG : Register<"REG">;
+def GPR : RegisterClass<"TestTarget", [i32], 32, (add REG)>;
+
+class SysReg<bits<12> op> {
+  bits<12> Encoding = op;
+}
+def SR : SysReg<0b111100001111>;
+
+class Pseudo<dag outs, dag ins, list<dag> pattern>
+    : Instruction {
+  dag OutOperandList = outs;
+  dag InOperandList = ins;
+  let Pattern = pattern;
+  let isPseudo = 1;
+}
+
+def INSTR : Instruction {
+  let OutOperandList = (outs GPR:$rd);
+  let InOperandList = (ins i32imm:$val);
+  let Pattern = [];
+}
+
+def PSEUDO : Pseudo<(outs GPR:$rd), (ins),
+                    [(set GPR:$rd, (i32 SR.Encoding))]>,
+             PseudoInstExpansion<(INSTR GPR:$rd, SR.Encoding)>;
+
+// CHECK: .addOperand(MCOperand::createImm(3855));

llvm/utils/TableGen/PseudoLoweringEmitter.cpp

if (DefInit *DI = dyn_cast<DefInit>(Dag->getArg(i))) {
       // for each corresponding MachineInstr operand, not just the first.
       for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I)
         OperandMap[BaseIdx + i + I].Kind = OpData::Operand;
       OpsAdded += Insn.Operands[i].MINumOperands;
     } else if (IntInit *II = dyn_cast<IntInit>(Dag->getArg(i))) {
       OperandMap[BaseIdx + i].Kind = OpData::Imm;
       OperandMap[BaseIdx + i].Data.Imm = II->getValue();
       ++OpsAdded;
+    } else if (auto BI = dyn_cast<BitsInit>(Dag->getArg(i))) {
+      auto II = dyn_cast<IntInit>(BI->convertInitializerTo(IntRecTy::get()));
+      assert(II);
+      OperandMap[BaseIdx + i].Kind = OpData::Imm;
+      OperandMap[BaseIdx + i].Data.Imm = II->getValue();
+      ++OpsAdded;
     } else if (DagInit *SubDag = dyn_cast<DagInit>(Dag->getArg(i))) {
       // Just add the operands recursively. This is almost certainly
       // a constant value for a complex operand (> 1 MI operand).
       unsigned NewOps =
         addDagOperandMapping(Rec, SubDag, Insn, OperandMap, BaseIdx + i);
       OpsAdded += NewOps;
       // Since we added more than one, we also need to adjust the base.
       BaseIdx += NewOps - 1;