[SPIR-V] Map IR function pointers to registers in ModuleAnalysis

[mpaszkowski]

Summary

SPIRVModuleAnalysis collects module and external function registers (usually result of OpFunction) for use when emitting OpFunctionCall. This patch makes the mapping between the functions and registers using pointers (instead of name strings) to ensure anonymous functions and calls can be resolved properly.

New LIT test multiple-anonymous-functions.ll replaces the old internal-anonymous-function.ll. Additionally, OpenCL CTS spirv_new/function_pure_ptr test should pass now.

[arsenm]

llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.h

134–135

Typo coresponding

llvm/test/CodeGen/SPIRV/function/multiple-anonymous-functions.ll

35

Don't use anonymous values in tests

[mpaszkowski]

@arsenm Thanks! I uploaded a new updated patch.

[iliya-diyachkov]

Thanks Michal, the patch looks good to me.

llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.h

struct ModuleAnalysisInfo {
   AddressingModel::AddressingModel Addr;
   SourceLanguage::SourceLanguage SrcLang;
   unsigned SrcLangVersion;
   StringSet<> SrcExt;
   // Maps ExtInstSet to corresponding ID register.
   DenseMap<unsigned, Register> ExtInstSetMap;
   // Contains the list of all global OpVariables in the module.
   SmallVector<MachineInstr *, 4> GlobalVarList;
-  // Maps function names to coresponding function ID registers.
-  StringMap<Register> FuncNameMap;
+  // Maps functions to corresponding function ID registers.
+  DenseMap<const Function *, Register> FuncMap;
   // The set contains machine instructions which are necessary
   // for correct MIR but will not be emitted in function bodies.
   DenseSet<MachineInstr *> InstrsToDelete;
   // The set contains machine basic blocks which are necessary
   // for correct MIR but will not be emitted.
   DenseSet<MachineBasicBlock *> MBBsToSkip;
   // The table contains global aliases of local registers for each machine
   // function. The aliases are used to substitute local registers during
   // code emission.
   RegisterAliasMapTy RegisterAliasTable;
   // The counter holds the maximum ID we have in the module.
   unsigned MaxID;
   // The array contains lists of MIs for each module section.
   InstrList MS[NUM_MODULE_SECTIONS];
   // The table maps MBB number to SPIR-V unique ID register.
   DenseMap<int, Register> BBNumToRegMap;
 
   Register getFuncReg(const Function *F) {
     assert(F && "Function is null");
-    auto FuncReg = FuncNameMap.find(getFunctionGlobalIdentifier(F));
-    assert(FuncReg != FuncNameMap.end() && "Cannot find function Id");
-    return FuncReg->second;
+    auto FuncPtrRegPair = FuncMap.find(F);
+    assert(FuncPtrRegPair != FuncMap.end() && "Cannot find function ID");
+    return FuncPtrRegPair->second;
   }
   Register getExtInstSetReg(unsigned SetNum) { return ExtInstSetMap[SetNum]; }
   InstrList &getMSInstrs(unsigned MSType) { return MS[MSType]; }
   void setSkipEmission(MachineInstr *MI) { InstrsToDelete.insert(MI); }
   bool getSkipEmission(const MachineInstr *MI) {
     return InstrsToDelete.contains(MI);
   }
   void setRegisterAlias(const MachineFunction *MF, Register Reg,

 private:
   void setBaseInfo(const Module &M);
   void collectGlobalEntities(
       const std::vector<SPIRV::DTSortableEntry *> &DepsGraph,
       SPIRV::ModuleSectionType MSType,
       std::function<bool(const SPIRV::DTSortableEntry *)> Pred,
       bool UsePreOrder);
   void processDefInstrs(const Module &M);
-  void collectFuncNames(MachineInstr &MI, const Function &F);
+  void collectFuncNames(MachineInstr &MI, const Function *F);
   void processOtherInstrs(const Module &M);
   void numberRegistersGlobally(const Module &M);
 
   const SPIRVSubtarget *ST;
   SPIRVGlobalRegistry *GR;
   const SPIRVInstrInfo *TII;
   MachineModuleInfo *MMI;
 };
 } // namespace llvm
 #endif // LLVM_LIB_TARGET_SPIRV_SPIRVMODULEANALYSIS_H

llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp

 }
 
 void SPIRVModuleAnalysis::setBaseInfo(const Module &M) {
   MAI.MaxID = 0;
   for (int i = 0; i < SPIRV::NUM_MODULE_SECTIONS; i++)
     MAI.MS[i].clear();
   MAI.RegisterAliasTable.clear();
   MAI.InstrsToDelete.clear();
-  MAI.FuncNameMap.clear();
+  MAI.FuncMap.clear();
   MAI.GlobalVarList.clear();
   MAI.ExtInstSetMap.clear();
   MAI.Reqs.clear();
   MAI.Reqs.initAvailableCapabilities(*ST);
 
   // TODO: determine memory model and source language from the configuratoin.
   if (auto MemModel = M.getNamedMetadata("spirv.MemoryModel")) {
     auto MemMD = MemModel->getOperand(0);
for (unsigned i = StartOpIndex; i < NumAOps && AllOpsMatch; ++i) {
       }
     }
     if (AllOpsMatch)
       return true;
   }
   return false;
 }
 
-// Look for IDs declared with Import linkage, and map the imported name string
+// Look for IDs declared with Import linkage, and map the corresponding function
 // to the register defining that variable (which will usually be the result of
 // an OpFunction). This lets us call externally imported functions using
 // the correct ID registers.
 void SPIRVModuleAnalysis::collectFuncNames(MachineInstr &MI,
-                                           const Function &F) {
+                                           const Function *F) {
   if (MI.getOpcode() == SPIRV::OpDecorate) {
     // If it's got Import linkage.
     auto Dec = MI.getOperand(1).getImm();
     if (Dec == static_cast<unsigned>(SPIRV::Decoration::LinkageAttributes)) {
       auto Lnk = MI.getOperand(MI.getNumOperands() - 1).getImm();
       if (Lnk == static_cast<unsigned>(SPIRV::LinkageType::Import)) {
         // Map imported function name to function ID register.
-        std::string Name = getStringImm(MI, 2);
+        const Function *ImportedFunc =
+            F->getParent()->getFunction(getStringImm(MI, 2));
         Register Target = MI.getOperand(0).getReg();
-        // TODO: check defs from different MFs.
-        MAI.FuncNameMap[Name] = MAI.getRegisterAlias(MI.getMF(), Target);
+        MAI.FuncMap[ImportedFunc] = MAI.getRegisterAlias(MI.getMF(), Target);
       }
     }
   } else if (MI.getOpcode() == SPIRV::OpFunction) {
     // Record all internal OpFunction declarations.
     Register Reg = MI.defs().begin()->getReg();
     Register GlobalReg = MAI.getRegisterAlias(MI.getMF(), Reg);
     assert(GlobalReg.isValid());
-    // TODO: check that it does not conflict with existing entries.
-    MAI.FuncNameMap[getFunctionGlobalIdentifier(&F)] = GlobalReg;
+    MAI.FuncMap[F] = GlobalReg;
   }
 }
 
 // Collect the given instruction in the specified MS. We assume global register
 // numbering has already occurred by this point. We can directly compare reg
 // arguments when detecting duplicates.
 static void collectOtherInstr(MachineInstr &MI, SPIRV::ModuleAnalysisInfo &MAI,
                               SPIRV::ModuleSectionType MSType,
for (MachineBasicBlock &MBB : *MF)
           continue;
         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);
+          collectFuncNames(MI, &*F);
         } else if (TII->isConstantInstr(MI)) {
           // Now OpSpecConstant*s are not in DT,
           // but they need to be collected anyway.
           collectOtherInstr(MI, MAI, SPIRV::MB_TypeConstVars);
         } else if (OpCode == SPIRV::OpFunction) {
-          collectFuncNames(MI, *F);
+          collectFuncNames(MI, &*F);
         } else if (OpCode == SPIRV::OpTypeForwardPointer) {
           collectOtherInstr(MI, MAI, SPIRV::MB_TypeConstVars, false);
         }
       }
   }
 }
 
 // Number registers in all functions globally from 0 onwards and store

llvm/lib/Target/SPIRV/SPIRVUtils.h

 std::string getOclOrSpirvBuiltinDemangledName(StringRef Name);
 
 // If Type is a pointer type and it is not opaque pointer, return its
 // element type, otherwise return Type.
 const Type *getTypedPtrEltType(const Type *Type);
 
 // Check if given LLVM type is a special opaque builtin type.
 bool isSpecialOpaqueType(const Type *Ty);
-
-std::string getFunctionGlobalIdentifier(const Function *F);
 } // namespace llvm
 #endif // LLVM_LIB_TARGET_SPIRV_SPIRVUTILS_H

llvm/lib/Target/SPIRV/SPIRVUtils.cpp

const Type *getTypedPtrEltType(const Type *Ty) {
   return PType->getNonOpaquePointerElementType();
 }
 
 bool isSpecialOpaqueType(const Type *Ty) {
   if (auto SType = dyn_cast<StructType>(getTypedPtrEltType(Ty)))
     return isOpenCLBuiltinType(SType) || isSPIRVBuiltinType(SType);
   return false;
 }
-
-std::string getFunctionGlobalIdentifier(const Function *F) {
-  StringRef Name = F->hasName() ? F->getName() : ".anonymous";
-  GlobalValue::LinkageTypes Linkage = F->getLinkage();
-  StringRef ModuleFileName = F->getParent()->getSourceFileName();
-  return GlobalValue::getGlobalIdentifier(Name, Linkage, ModuleFileName);
-}
 } // namespace llvm

llvm/test/CodeGen/SPIRV/function/internal-anonymous-function.ll

-; RUN: llc -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
-
-;; Types:
-; CHECK-DAG:  %[[#F32:]] = OpTypeFloat 32
-; CHECK-DAG:  %[[#FNF32:]] = OpTypeFunction %[[#F32]] %[[#F32]]
-;; Function decl:
-; CHECK:      %[[#ANON:]] = OpFunction %[[#F32]] None %[[#FNF32]]
-; CHECK-NEXT: OpFunctionParameter %[[#F32]]
-; CHECK-NEXT: OpLabel
-; CHECK-NEXT: OpReturnValue
-; CHECK-NEXT: OpFunctionEnd
-define internal spir_func float @0(float %a) {
-  ret float %a
-}
-
-; CHECK:      OpFunctionCall %[[#F32]] %[[#ANON]]
-define spir_kernel void @foo(float %a) {
-  %1 = call spir_func float @0(float %a)
-  ret void
-}

llvm/test/CodeGen/SPIRV/function/multiple-anonymous-functions.ll

+; RUN: llc -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+
+;; Types:
+; CHECK-DAG:  %[[#I32:]] = OpTypeInt 32
+; CHECK-DAG:  %[[#F32:]] = OpTypeFloat 32
+; CHECK-DAG:  %[[#FNI32:]] = OpTypeFunction %[[#I32]] %[[#I32]]
+; CHECK-DAG:  %[[#FNF32:]] = OpTypeFunction %[[#F32]] %[[#F32]]
+
+;; Function declarations:
+; CHECK:      %[[#ANON0:]] = OpFunction %[[#I32]] None %[[#FNI32]]
+; CHECK-NEXT: OpFunctionParameter %[[#I32]]
+; CHECK-NEXT: OpLabel
+; CHECK-NEXT: OpReturnValue
+; CHECK-NEXT: OpFunctionEnd
+define internal spir_func i32 @0(i32 %a) {
+  ret i32 %a
+}
+
+; CHECK:      %[[#ANON1:]] = OpFunction %[[#F32]] None %[[#FNF32]]
+; CHECK-NEXT: OpFunctionParameter %[[#F32]]
+; CHECK-NEXT: OpLabel
+; CHECK-NEXT: OpReturnValue
+; CHECK-NEXT: OpFunctionEnd
+define internal spir_func float @1(float %a) {
+  ret float %a
+}
+
+;; Calls:
+; CHECK:      OpFunctionCall %[[#I32]] %[[#ANON0]]
+; CHECK:      OpFunctionCall %[[#F32]] %[[#ANON1]]
+define spir_kernel void @foo(i32 %a) {
+  %call1 = call spir_func i32 @0(i32 %a)
+  %b = sitofp i32 %a to float
+  %call2 = call spir_func float @1(float %b)
+  ret void
+}