[SPIRV] Fix call lowering of "anonymous" functions

[mpaszkowski]

Summary

The patch fixes lowering of anonymous functions, removes file/linkage info for builtin call demangling, and adds relevant test demonstrating a fixed problem. This patch fixes several OpenCL CTS spirv_new subtests.

[andreytr]

Suggest format of lit tests as it is in existing ones.

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

4–8

[arsenm]

llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp

467

This should probably be report_fatal_error

llvm/lib/Target/SPIRV/SPIRVMCInstLower.cpp

34

Does getFuncReg really handle the null case?

[mpaszkowski]

Updated the patch with the following changes:

• Corrected formatting of the LIT test to match the style of other tests.
• Changed llvm_unreachable to report_fatal_error.
• Extracted some duplicate code into an util getFunctionGlobalIdentifier function.
• Added (for now) an assert masking sure the function passed into getFuncReg is not nullptr. Will rework some of this in the upcoming patch.

Thank you @andreytr and @arsenm for comments!

[iliya-diyachkov]

It looks good to me. Thank you for the patch, Michal.

llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp

 static void addOpsFromMDNode(MDNode *MDN, MCInst &Inst,
                              SPIRV::ModuleAnalysisInfo *MAI) {
   for (const MDOperand &MDOp : MDN->operands()) {
     if (auto *CMeta = dyn_cast<ConstantAsMetadata>(MDOp)) {
       Constant *C = CMeta->getValue();
       if (ConstantInt *Const = dyn_cast<ConstantInt>(C)) {
         Inst.addOperand(MCOperand::createImm(Const->getZExtValue()));
       } else if (auto *CE = dyn_cast<Function>(C)) {
-        Register FuncReg = MAI->getFuncReg(CE->getName().str());
+        Register FuncReg = MAI->getFuncReg(CE);
         assert(FuncReg.isValid());
         Inst.addOperand(MCOperand::createReg(FuncReg));
       }
     }
   }
 }
 
 void SPIRVAsmPrinter::outputExecutionModeFromMDNode(
for (unsigned i = 0; i < Node->getNumOperands(); i++) {
       addOpsFromMDNode(cast<MDNode>(Node->getOperand(i)), Inst, MAI);
       outputMCInst(Inst);
     }
   }
   for (auto FI = M.begin(), E = M.end(); FI != E; ++FI) {
     const Function &F = *FI;
     if (F.isDeclaration())
       continue;
-    Register FReg = MAI->getFuncReg(F.getGlobalIdentifier());
+    Register FReg = MAI->getFuncReg(&F);
     assert(FReg.isValid());
     if (MDNode *Node = F.getMetadata("reqd_work_group_size"))
       outputExecutionModeFromMDNode(FReg, Node,
                                     SPIRV::ExecutionMode::LocalSize);
     if (MDNode *Node = F.getMetadata("work_group_size_hint"))
       outputExecutionModeFromMDNode(FReg, Node,
                                     SPIRV::ExecutionMode::LocalSizeHint);
     if (MDNode *Node = F.getMetadata("intel_reqd_sub_group_size"))
for (auto F = M.global_begin(), E = M.global_end(); F != E; ++F) {
     const GlobalVariable *V = &(*F);
     const ConstantArray *CA = cast<ConstantArray>(V->getOperand(0));
     for (Value *Op : CA->operands()) {
       ConstantStruct *CS = cast<ConstantStruct>(Op);
       // The first field of the struct contains a pointer to
       // the annotated variable.
       Value *AnnotatedVar = CS->getOperand(0)->stripPointerCasts();
       if (!isa<Function>(AnnotatedVar))
-        llvm_unreachable("Unsupported value in llvm.global.annotations");
+        report_fatal_error("Unsupported value in llvm.global.annotations");
       Function *Func = cast<Function>(AnnotatedVar);
-      Register Reg = MAI->getFuncReg(Func->getGlobalIdentifier());
+      Register Reg = MAI->getFuncReg(Func);
 
       // The second field contains a pointer to a global annotation string.
       GlobalVariable *GV =
           cast<GlobalVariable>(CS->getOperand(1)->stripPointerCasts());
 
       StringRef AnnotationString;
       getConstantStringInfo(GV, AnnotationString);
       MCInst Inst;

llvm/lib/Target/SPIRV/SPIRVCallLowering.cpp

if (Info.Callee.isGlobal()) {
     // TODO: support constexpr casts and indirect calls.
     if (CF == nullptr)
       return false;
     FTy = getOriginalFunctionType(*CF);
   }
 
   Register ResVReg =
       Info.OrigRet.Regs.empty() ? Register(0) : Info.OrigRet.Regs[0];
-  std::string FuncName = Info.Callee.getGlobal()->getGlobalIdentifier();
+  std::string FuncName = Info.Callee.getGlobal()->getName().str();
   std::string DemangledName = getOclOrSpirvBuiltinDemangledName(FuncName);
   const auto *ST = static_cast<const SPIRVSubtarget *>(&MF.getSubtarget());
   // TODO: check that it's OCL builtin, then apply OpenCL_std.
   if (!DemangledName.empty() && CF && CF->isDeclaration() &&
       ST->canUseExtInstSet(SPIRV::InstructionSet::OpenCL_std)) {
     const Type *OrigRetTy = Info.OrigRet.Ty;
     if (FTy)
       OrigRetTy = FTy->getReturnType();

llvm/lib/Target/SPIRV/SPIRVMCInstLower.cpp

void SPIRVMCInstLower::lower(const MachineInstr *MI, MCInst &OutMI,
   const MachineFunction *MF = MI->getMF();
   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
     const MachineOperand &MO = MI->getOperand(i);
     MCOperand MCOp;
     switch (MO.getType()) {
     default:
       llvm_unreachable("unknown operand type");
     case MachineOperand::MO_GlobalAddress: {
-      Register FuncReg = MAI->getFuncReg(MO.getGlobal()->getGlobalIdentifier());
+      Register FuncReg = MAI->getFuncReg(dyn_cast<Function>(MO.getGlobal()));
       assert(FuncReg.isValid() && "Cannot find function Id");
       MCOp = MCOperand::createReg(FuncReg);
       break;
     }
     case MachineOperand::MO_MachineBasicBlock:
       MCOp = MCOperand::createReg(MAI->getOrCreateMBBRegister(*MO.getMBB()));
       break;
     case MachineOperand::MO_Register: {

llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_SPIRV_SPIRVMODULEANALYSIS_H
 #define LLVM_LIB_TARGET_SPIRV_SPIRVMODULEANALYSIS_H
 
 #include "MCTargetDesc/SPIRVBaseInfo.h"
 #include "SPIRVGlobalRegistry.h"
+#include "SPIRVUtils.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 
 namespace llvm {
 class SPIRVSubtarget;
struct ModuleAnalysisInfo {
   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(std::string FuncName) {
-    auto FuncReg = FuncNameMap.find(FuncName);
+  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;
   }
   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);

llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp

if (Dec == static_cast<unsigned>(SPIRV::Decoration::LinkageAttributes)) {
       }
     }
   } 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[F.getGlobalIdentifier()] = GlobalReg;
+    MAI.FuncNameMap[getFunctionGlobalIdentifier(&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,

llvm/lib/Target/SPIRV/SPIRVUtils.h

 Type *getMDOperandAsType(const MDNode *N, unsigned I);
 
 // If OpenCL or SPIR-V builtin function name is recognized, return a demangled
 // name, otherwise return an empty string.
 std::string getOclOrSpirvBuiltinDemangledName(StringRef Name);
 
 // 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

bool isSpecialOpaqueType(const Type *Ty) {
   if (auto PType = dyn_cast<PointerType>(Ty)) {
     if (!PType->isOpaque())
       Ty = PType->getNonOpaquePointerElementType();
   }
   if (auto SType = dyn_cast<StructType>(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
+}