[SPIR-V] Add SPIRVGlobalInstrRegistry, don't emit OpEntryPoint in MF

michalpaszkowski · michalpaszkowski · commit 00a3c26f0582 · 2023-04-10T12:13:34.000+02:00
diff --git a/llvm/lib/Target/SPIRV/Registries/SPIRVGlobalInstrRegistry.h b/llvm/lib/Target/SPIRV/Registries/SPIRVGlobalInstrRegistry.h
@@ -0,0 +1,60 @@
+//===-- SPIRVGlobalInstrRegistry.h - SPIR-V Global Instr Registry -*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===------------------------------------------------------------------------===//
+//
+// The SPIRVGlobalInstrRegistry class is used to collect and contain information
+// required for emitting SPIR-V global instructions (instructions which do not
+// belong to any function and are emittied on a module level).
+//
+//===------------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_SPIRV_SPIRVGLOBALINSTRREGISTRY_H
+#define LLVM_LIB_TARGET_SPIRV_SPIRVGLOBALINSTRREGISTRY_H
+
+#include "MCTargetDesc/SPIRVBaseInfo.h"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/Function.h"
+
+namespace llvm {
+
+/// Struct storing info on module's entry point for later printing of global
+/// OpEntryPoint instruction.
+struct SPIRVEntryPoint {
+  const SPIRV::ExecutionModel::ExecutionModel ExecModel;
+  const Function *const EntryFunction;
+
+  SPIRVEntryPoint(const SPIRV::ExecutionModel::ExecutionModel ExecModel,
+                  const Function *const EntryFunction)
+      : ExecModel(ExecModel), EntryFunction(EntryFunction) {}
+  SPIRVEntryPoint &operator=(const SPIRVEntryPoint &) = delete;
+};
+
+/// SPIRVGlobalInstrRegistry collects and stores information required for
+/// emitting SPIR-V global instructions.
+class SPIRVGlobalInstrRegistry {
+private:
+  SmallVector<SPIRVEntryPoint> EntryPoints;
+
+public:
+  SPIRVGlobalInstrRegistry() {}
+
+  /// Declare a new SPIR-V entry point.
+  void addEntryPoint(const SPIRV::ExecutionModel::ExecutionModel ExecModel,
+                     const Function *const EntryFunction) {
+    EntryPoints.push_back(SPIRVEntryPoint(ExecModel, EntryFunction));
+  }
+
+  /// Get all already declared SPIR-V entry points.
+  const SmallVector<SPIRVEntryPoint> &getAllEntryPoints() const {
+    return EntryPoints;
+  }
+};
+
+} // end namespace llvm
+#endif // LLVM_LIB_TARGET_SPIRV_SPIRVGLOBALINSTRREGISTRY_H
diff --git a/llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp b/llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp
@@ -84,6 +84,7 @@ class SPIRVAsmPrinter : public AsmPrinter {
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
   SPIRV::ModuleAnalysisInfo *MAI;
+  SPIRVGlobalInstrRegistry *GIR;
 };
 } // namespace
 
@@ -308,10 +309,15 @@ void SPIRVAsmPrinter::outputEntryPoints() {
   }
 
   // Output OpEntryPoints adding interface args to all of them.
-  for (MachineInstr *MI : MAI->getMSInstrs(SPIRV::MB_EntryPoints)) {
-    SPIRVMCInstLower MCInstLowering;
+  for (const SPIRVEntryPoint &EP : GIR->getAllEntryPoints()) {
     MCInst TmpInst;
-    MCInstLowering.lower(MI, TmpInst, MAI);
+    TmpInst.setOpcode(SPIRV::OpEntryPoint);
+    TmpInst.addOperand(
+        MCOperand::createImm(static_cast<unsigned>(EP.ExecModel)));
+    Register EntryFuncReg = MAI->getFuncReg(EP.EntryFunction);
+    TmpInst.addOperand(MCOperand::createReg(EntryFuncReg));
+    addStringImm(EP.EntryFunction->getName(), TmpInst);
+
     for (Register Reg : InterfaceIDs) {
       assert(Reg.isValid());
       TmpInst.addOperand(MCOperand::createReg(Reg));
@@ -500,6 +506,7 @@ void SPIRVAsmPrinter::outputModuleSections() {
   ST = static_cast<const SPIRVTargetMachine &>(TM).getSubtargetImpl();
   TII = ST->getInstrInfo();
   MAI = &SPIRVModuleAnalysis::MAI;
+  GIR = ST->getSPIRVGlobalInstrRegistry();
   assert(ST && TII && MAI && M && "Module analysis is required");
   // Output instructions according to the Logical Layout of a Module:
   // 1,2. All OpCapability instructions, then optional OpExtension instructions.
diff --git a/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp b/llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp
@@ -16,6 +16,7 @@
 #include "SPIRV.h"
 #include "SPIRVBuiltins.h"
 #include "Registries/SPIRVGlobalTypeRegistry.h"
+#include "Registries/SPIRVGlobalInstrRegistry.h"
 #include "SPIRVISelLowering.h"
 #include "SPIRVRegisterInfo.h"
 #include "SPIRVSubtarget.h"
@@ -26,8 +27,9 @@
 using namespace llvm;
 
 SPIRVCallLowering::SPIRVCallLowering(const SPIRVTargetLowering &TLI,
-                                     SPIRVGlobalTypeRegistry *GTR)
-    : CallLowering(&TLI), GTR(GTR) {}
+                                     SPIRVGlobalTypeRegistry *GTR,
+                                     SPIRVGlobalInstrRegistry *GIR)
+    : CallLowering(&TLI), GTR(GTR), GIR(GIR) {}
 
 bool SPIRVCallLowering::lowerReturn(MachineIRBuilder &MIRBuilder,
                                     const Value *Val, ArrayRef<Register> VRegs,
@@ -339,10 +341,7 @@ bool SPIRVCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
 
   // Handle entry points and function linkage.
   if (F.getCallingConv() == CallingConv::SPIR_KERNEL) {
-    auto MIB = MIRBuilder.buildInstr(SPIRV::OpEntryPoint)
-                   .addImm(static_cast<uint32_t>(SPIRV::ExecutionModel::Kernel))
-                   .addUse(FuncVReg);
-    addStringImm(F.getName(), MIB);
+    GIR->addEntryPoint(SPIRV::ExecutionModel::Kernel, &F);
   } else if (F.getLinkage() == GlobalValue::LinkageTypes::ExternalLinkage ||
              F.getLinkage() == GlobalValue::LinkOnceODRLinkage) {
     auto LnkTy = F.isDeclaration() ? SPIRV::LinkageType::Import
diff --git a/llvm/lib/Target/SPIRV/SPIRVCallLowering.h b/llvm/lib/Target/SPIRV/SPIRVCallLowering.h
@@ -14,6 +14,7 @@
 #define LLVM_LIB_TARGET_SPIRV_SPIRVCALLLOWERING_H
 
 #include "Registries/SPIRVGlobalTypeRegistry.h"
+#include "Registries/SPIRVGlobalInstrRegistry.h"
 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
 
 namespace llvm {
@@ -26,9 +27,13 @@ class SPIRVCallLowering : public CallLowering {
   // Used to create and assign function, argument, and return type information.
   SPIRVGlobalTypeRegistry *GTR;
 
+  // Used to create global instructions which do not belong to any function.
+  SPIRVGlobalInstrRegistry *GIR;
+
 public:
   SPIRVCallLowering(const SPIRVTargetLowering &TLI,
-                    SPIRVGlobalTypeRegistry *GTR);
+                    SPIRVGlobalTypeRegistry *GTR,
+                    SPIRVGlobalInstrRegistry *GIR);
 
   // Built OpReturn or OpReturnValue.
   bool lowerReturn(MachineIRBuilder &MIRBuiler, const Value *Val,
diff --git a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
@@ -338,8 +338,6 @@ void SPIRVModuleAnalysis::processOtherInstrs(const Module &M) {
         const unsigned OpCode = MI.getOpcode();
         if (OpCode == SPIRV::OpName || OpCode == SPIRV::OpMemberName) {
           collectOtherInstr(MI, MAI, SPIRV::MB_DebugNames);
-        } else if (OpCode == SPIRV::OpEntryPoint) {
-          collectOtherInstr(MI, MAI, SPIRV::MB_EntryPoints);
         } else if (TII->isDecorationInstr(MI)) {
           collectOtherInstr(MI, MAI, SPIRV::MB_Annotations);
           collectFuncNames(MI, &*F);
@@ -969,6 +967,7 @@ bool SPIRVModuleAnalysis::runOnModule(Module &M) {
       getAnalysis<TargetPassConfig>().getTM<SPIRVTargetMachine>();
   ST = TM.getSubtargetImpl();
   GTR = ST->getSPIRVGlobalTypeRegistry();
+  GIR = ST->getSPIRVGlobalInstrRegistry();
   TII = ST->getInstrInfo();
 
   MMI = &getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
@@ -990,7 +989,7 @@ bool SPIRVModuleAnalysis::runOnModule(Module &M) {
   processOtherInstrs(M);
 
   // If there are no entry points, we need the Linkage capability.
-  if (MAI.MS[SPIRV::MB_EntryPoints].empty())
+  if (GIR->getAllEntryPoints().empty())
     MAI.Reqs.addCapability(SPIRV::Capability::Linkage);
 
   return false;
diff --git a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.h b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.h
@@ -16,6 +16,7 @@
 
 #include "MCTargetDesc/SPIRVBaseInfo.h"
 #include "Registries/SPIRVGlobalTypeRegistry.h"
+#include "Registries/SPIRVGlobalInstrRegistry.h"
 #include "SPIRVUtils.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallSet.h"
@@ -31,7 +32,6 @@ namespace SPIRV {
 // The enum contains logical module sections for the instruction collection.
 enum ModuleSectionType {
   //  MB_Capabilities, MB_Extensions, MB_ExtInstImports, MB_MemoryModel,
-  MB_EntryPoints, // All OpEntryPoint instructions (if any).
   //  MB_ExecutionModes, MB_DebugSourceAndStrings,
   MB_DebugNames,           // All OpName and OpMemberName intrs.
   MB_DebugModuleProcessed, // All OpModuleProcessed instructions.
@@ -214,6 +214,7 @@ struct SPIRVModuleAnalysis : public ModulePass {
 
   const SPIRVSubtarget *ST;
   SPIRVGlobalTypeRegistry *GTR;
+  SPIRVGlobalInstrRegistry *GIR;
   const SPIRVInstrInfo *TII;
   MachineModuleInfo *MMI;
 };
diff --git a/llvm/lib/Target/SPIRV/SPIRVSubtarget.cpp b/llvm/lib/Target/SPIRV/SPIRVSubtarget.cpp
@@ -51,7 +51,9 @@ SPIRVSubtarget::SPIRVSubtarget(const Triple &TT, const std::string &CPU,
   initAvailableExtInstSets();
 
   GTR = std::make_unique<SPIRVGlobalTypeRegistry>(PointerSize);
-  CallLoweringInfo = std::make_unique<SPIRVCallLowering>(TLInfo, GTR.get());
+  GIR = std::make_unique<SPIRVGlobalInstrRegistry>();
+  CallLoweringInfo =
+      std::make_unique<SPIRVCallLowering>(TLInfo, GTR.get(), GIR.get());
   Legalizer = std::make_unique<SPIRVLegalizerInfo>(*this);
   RegBankInfo = std::make_unique<SPIRVRegisterBankInfo>();
   InstSelector.reset(
diff --git a/llvm/lib/Target/SPIRV/SPIRVSubtarget.h b/llvm/lib/Target/SPIRV/SPIRVSubtarget.h
@@ -17,6 +17,8 @@
 #include "SPIRVFrameLowering.h"
 #include "SPIRVISelLowering.h"
 #include "SPIRVInstrInfo.h"
+#include "Registries/SPIRVGlobalTypeRegistry.h"
+#include "Registries/SPIRVGlobalInstrRegistry.h"
 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
 #include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
@@ -41,6 +43,7 @@ class SPIRVSubtarget : public SPIRVGenSubtargetInfo {
   SmallSet<SPIRV::Extension::Extension, 4> AvailableExtensions;
   SmallSet<SPIRV::InstructionSet::InstructionSet, 4> AvailableExtInstSets;
   std::unique_ptr<SPIRVGlobalTypeRegistry> GTR;
+  std::unique_ptr<SPIRVGlobalInstrRegistry> GIR;
 
   SPIRVInstrInfo InstrInfo;
   SPIRVFrameLowering FrameLowering;
@@ -86,6 +89,10 @@ class SPIRVSubtarget : public SPIRVGenSubtargetInfo {
     return GTR.get();
   }
 
+  SPIRVGlobalInstrRegistry *getSPIRVGlobalInstrRegistry() const {
+    return GIR.get();
+  }
+
   const CallLowering *getCallLowering() const override {
     return CallLoweringInfo.get();
   }
