Replace lambda with list of operands

Author: cassiebeckley

llvm/lib/Target/SPIRV/SPIRVBuiltins.cpp

@@ -2876,49 +2876,46 @@ static SPIRVType *getInlineSpirvType(const TargetExtType *ExtensionType,
          "parameter");
   auto Opcode = ExtensionType->getIntParameter(0);
 
-  return GR->getOrCreateUnknownType(
-      ExtensionType, MIRBuilder, Opcode,
-      [&ExtensionType, &GR, &MIRBuilder](llvm::MachineInstrBuilder Instr) {
-        for (llvm::Type *Param : ExtensionType->type_params()) {
-          if (const TargetExtType *ParamEType =
-                  dyn_cast<TargetExtType>(Param)) {
-            if (ParamEType->getName() == "spirv.IntegralConstant") {
-              assert(ParamEType->getNumTypeParameters() == 1 &&
-                     "Inline SPIR-V integral constant builtin must have a type "
-                     "parameter");
-              assert(ParamEType->getNumIntParameters() == 1 &&
-                     "Inline SPIR-V integral constant builtin must have a "
-                     "value parameter");
-
-              auto OperandValue = ParamEType->getIntParameter(0);
-              auto *OperandType = ParamEType->getTypeParameter(0);
-
-              const SPIRVType *OperandSPIRVType =
-                  GR->getOrCreateSPIRVType(OperandType, MIRBuilder);
-
-              Instr = Instr.addUse(GR->buildConstantInt(
-                  OperandValue, MIRBuilder, OperandSPIRVType, true));
-              continue;
-            } else if (ParamEType->getName() == "spirv.Literal") {
-              assert(ParamEType->getNumTypeParameters() == 0 &&
-                     "Inline SPIR-V literal builtin does not take type "
-                     "parameters");
-              assert(ParamEType->getNumIntParameters() == 1 &&
-                     "Inline SPIR-V literal builtin must have an integer "
-                     "parameter");
-
-              auto OperandValue = ParamEType->getIntParameter(0);
-
-              Instr = Instr.addImm(OperandValue);
-              continue;
-            }
-          }
-          const SPIRVType *TypeOperand =
-              GR->getOrCreateSPIRVType(Param, MIRBuilder);
-          Instr = Instr.addUse(GR->getSPIRVTypeID(TypeOperand));
-        }
-        return Instr;
-      });
+  SmallVector<MCOperand> Operands;
+  for (llvm::Type *Param : ExtensionType->type_params()) {
+    if (const TargetExtType *ParamEType = dyn_cast<TargetExtType>(Param)) {
+      if (ParamEType->getName() == "spirv.IntegralConstant") {
+        assert(ParamEType->getNumTypeParameters() == 1 &&
+               "Inline SPIR-V integral constant builtin must have a type "
+               "parameter");
+        assert(ParamEType->getNumIntParameters() == 1 &&
+               "Inline SPIR-V integral constant builtin must have a "
+               "value parameter");
+
+        auto OperandValue = ParamEType->getIntParameter(0);
+        auto *OperandType = ParamEType->getTypeParameter(0);
+
+        const SPIRVType *OperandSPIRVType =
+            GR->getOrCreateSPIRVType(OperandType, MIRBuilder);
+
+        Operands.push_back(MCOperand::createReg(GR->buildConstantInt(
+            OperandValue, MIRBuilder, OperandSPIRVType, true)));
+        continue;
+      } else if (ParamEType->getName() == "spirv.Literal") {
+        assert(ParamEType->getNumTypeParameters() == 0 &&
+               "Inline SPIR-V literal builtin does not take type "
+               "parameters");
+        assert(ParamEType->getNumIntParameters() == 1 &&
+               "Inline SPIR-V literal builtin must have an integer "
+               "parameter");
+
+        auto OperandValue = ParamEType->getIntParameter(0);
+
+        Operands.push_back(MCOperand::createImm(OperandValue));
+        continue;
+      }
+    }
+    const SPIRVType *TypeOperand = GR->getOrCreateSPIRVType(Param, MIRBuilder);
+    Operands.push_back(MCOperand::createReg(GR->getSPIRVTypeID(TypeOperand)));
+  }
+
+  return GR->getOrCreateUnknownType(ExtensionType, MIRBuilder, Opcode,
+                                    Operands);
 }
 
 namespace SPIRV {

llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.cpp

@@ -1408,17 +1408,24 @@ SPIRVType *SPIRVGlobalRegistry::getOrCreateOpTypeByOpcode(
 
 SPIRVType *SPIRVGlobalRegistry::getOrCreateUnknownType(
     const Type *Ty, MachineIRBuilder &MIRBuilder, unsigned Opcode,
-    const std::function<llvm::MachineInstrBuilder(llvm::MachineInstrBuilder)>
-        &buildInstr) {
+    const ArrayRef<MCOperand> Operands) {
   Register ResVReg = DT.find(Ty, &MIRBuilder.getMF());
   if (ResVReg.isValid())
     return MIRBuilder.getMF().getRegInfo().getUniqueVRegDef(ResVReg);
   ResVReg = createTypeVReg(MIRBuilder);
-  SPIRVType *SpirvTy = buildInstr(MIRBuilder.buildInstr(SPIRV::UNKNOWN_type)
-                                      .addDef(ResVReg)
-                                      .addImm(Opcode));
+
+  MachineInstrBuilder MIB =
+      MIRBuilder.buildInstr(SPIRV::UNKNOWN_type).addDef(ResVReg).addImm(Opcode);
+  for (MCOperand Operand : Operands) {
+    if (Operand.isReg()) {
+      MIB.addUse(Operand.getReg());
+    } else if (Operand.isImm()) {
+      MIB.addImm(Operand.getImm());
+    }
+  }
+
   DT.add(Ty, &MIRBuilder.getMF(), ResVReg);
-  return SpirvTy;
+  return MIB;
 }
 
 const MachineInstr *

llvm/lib/Target/SPIRV/SPIRVGlobalRegistry.h

@@ -618,10 +618,10 @@ class SPIRVGlobalRegistry {
                                        MachineIRBuilder &MIRBuilder,
                                        unsigned Opcode);
 
-  SPIRVType *getOrCreateUnknownType(
-      const Type *Ty, MachineIRBuilder &MIRBuilder, unsigned Opcode,
-      const std::function<llvm::MachineInstrBuilder(llvm::MachineInstrBuilder)>
-          &buildInstr);
+  SPIRVType *getOrCreateUnknownType(const Type *Ty,
+                                    MachineIRBuilder &MIRBuilder,
+                                    unsigned Opcode,
+                                    const ArrayRef<MCOperand> Operands);
 
   const TargetRegisterClass *getRegClass(SPIRVType *SpvType) const;
   LLT getRegType(SPIRVType *SpvType) const;