Implementation of SPV_INTEL_function_pointers extension

The extension specification is published here
https://github.com/intel/llvm/blob/sycl/sycl/doc/extensions/spirv/SPV_INTEL_function_pointers.asciidoc

Overview:
This extensions brings two "levels" of function pointers support added under
corresponding capabilities:

Two new instructions are added under FunctionPointersINTEL capability:
 - OpFunctionPointerINTEL to support "address of" operator for functions,
 - OpFunctionPointerCallINTEL to do indirect function calls.

ReferencedIndirectlyINTEL decoration is added under IndirectReferencesINTEL
capability. This decoration can be attached to functions which are not
referenced directly in the module. These function must not be optimized out
based on call graph/reachability analysis.

Signed-off-by: Alexey Sachkov <[email protected]>
Signed-off-by: Alexey Sotkin <[email protected]>

Author: AlexeySachkov

llvm-spirv/lib/SPIRV/SPIRVReader.cpp

@@ -383,11 +383,12 @@ Type *SPIRVToLLVM::transType(SPIRVType *T, bool IsClassMember) {
   case OpTypeArray:
     return mapType(T, ArrayType::get(transType(T->getArrayElementType()),
                                      T->getArrayLength()));
-  case OpTypePointer:
+  case OpTypePointer: {
     return mapType(
         T, PointerType::get(
                transType(T->getPointerElementType(), IsClassMember),
                SPIRSPIRVAddrSpaceMap::rmap(T->getPointerStorageClass())));
+  }
   case OpTypeVector:
     return mapType(T, VectorType::get(transType(T->getVectorComponentType()),
                                       T->getVectorComponentCount()));
@@ -500,8 +501,19 @@ std::string SPIRVToLLVM::transTypeToOCLTypeName(SPIRVType *T, bool IsSigned) {
     break;
   case OpTypeArray:
     return "array";
-  case OpTypePointer:
-    return transTypeToOCLTypeName(T->getPointerElementType()) + "*";
+  case OpTypePointer: {
+    SPIRVType *ET = T->getPointerElementType();
+    if (isa<OpTypeFunction>(ET)) {
+      SPIRVTypeFunction *TF = static_cast<SPIRVTypeFunction*>(ET);
+      std::string name = transTypeToOCLTypeName(TF->getReturnType());
+      name += " (*)(";
+      for(unsigned I = 0, E = TF->getNumParameters(); I < E; ++I)
+        name += transTypeToOCLTypeName(TF->getParameterType(I)) + ',';
+      name.back() = ')'; // replace the last comma with a closing brace.
+      return name;
+    }
+    return transTypeToOCLTypeName(ET) + "*";
+  }
   case OpTypeVector:
     return transTypeToOCLTypeName(T->getVectorComponentType()) +
            T->getVectorComponentCount();
@@ -1687,6 +1699,27 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
     return mapValue(BV, Call);
   }
 
+  case OpFunctionPointerCallINTEL: {
+    SPIRVFunctionPointerCallINTEL *BC =
+        static_cast<SPIRVFunctionPointerCallINTEL *>(BV);
+    auto Call = CallInst::Create(transValue(BC->getCalledValue(), F, BB),
+                                 transValue(BC->getArgumentValues(), F, BB),
+                                 BC->getName(), BB);
+    // Assuming we are calling a regular device function
+    Call->setCallingConv(CallingConv::SPIR_FUNC);
+    // Don't set attributes, because at translation time we don't know which
+    // function exactly we are calling.
+    return mapValue(BV, Call);
+  }
+
+  case OpFunctionPointerINTEL: {
+    SPIRVFunctionPointerINTEL *BC =
+      static_cast<SPIRVFunctionPointerINTEL *>(BV);
+    SPIRVFunction* F = BC->getFunction();
+    BV->setName(F->getName());
+    return mapValue(BV, transFunction(F));
+  }
+
   case OpExtInst: {
     auto *ExtInst = static_cast<SPIRVExtInst *>(BV);
     switch (ExtInst->getExtSetKind()) {
@@ -1869,6 +1902,10 @@ Function *SPIRVToLLVM::transFunction(SPIRVFunction *BF) {
   Function *F = cast<Function>(
       mapValue(BF, Function::Create(FT, Linkage, BF->getName(), M)));
   mapFunction(BF, F);
+
+  if (BF->hasDecorate(DecorationReferencedIndirectlyINTEL))
+    F->addFnAttr("referenced-indirectly");
+
   if (!F->isIntrinsic()) {
     F->setCallingConv(IsKernel ? CallingConv::SPIR_KERNEL
                                : CallingConv::SPIR_FUNC);

llvm-spirv/lib/SPIRV/SPIRVRegularizeLLVM.cpp

@@ -182,8 +182,8 @@ void SPIRVRegularizeLLVM::lowerFuncPtr(Module *M) {
     auto AI = F.arg_begin();
     if (hasFunctionPointerArg(&F, AI)) {
       auto OC = getSPIRVFuncOC(F.getName());
-      assert(OC != OpNop && "Invalid function pointer usage");
-      Work.push_back(std::make_pair(&F, OC));
+      if (OC != OpNop) // not a user-defined function
+        Work.push_back(std::make_pair(&F, OC));
     }
   }
   for (auto &I : Work)

llvm-spirv/lib/SPIRV/SPIRVWriter.cpp

@@ -261,7 +261,19 @@ SPIRVType *LLVMToSPIRV::transType(Type *T) {
   // (non-pointer) image or pipe type.
   if (T->isPointerTy()) {
     auto ET = T->getPointerElementType();
-    assert(!ET->isFunctionTy() && "Function pointer type is not allowed");
+    bool IsFuncPtrAllowed = true;
+    // TODO: uncomment the line below once
+    // https://github.com/KhronosGroup/SPIRV-LLVM-Translator/pull/244 is merged.
+    //    BM->isAllowedToUseExtension(ExtensionID::SPV_INTEL_function_pointers);
+    if (ET->isFunctionTy() && !IsFuncPtrAllowed) {
+      std::string S;
+      raw_string_ostream RSOS(S);
+      T->print(RSOS);
+      BM->getErrorLog().checkError(false, SPIRVEC_FunctionPointersDisallowed,
+                                   RSOS.str());
+      BM->setInvalid();
+      return nullptr;
+    }
     auto ST = dyn_cast<StructType>(ET);
     auto AddrSpc = T->getPointerAddressSpace();
     if (ST && !ST->isSized()) {
@@ -505,6 +517,11 @@ SPIRVFunction *LLVMToSPIRV::transFunctionDecl(Function *F) {
     BF->addDecorate(DecorationFuncParamAttr, FunctionParameterAttributeZext);
   if (Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
     BF->addDecorate(DecorationFuncParamAttr, FunctionParameterAttributeSext);
+  if (Attrs.hasFnAttribute("referenced-indirectly")) {
+    assert(!oclIsKernel(F) &&
+           "kernel function was marked as referenced-indirectly");
+    BF->addDecorate(DecorationReferencedIndirectlyINTEL);
+  }
   SPIRVDBG(dbgs() << "[transFunction] " << *F << " => ";
            spvdbgs() << *BF << '\n';)
   return BF;
@@ -780,9 +797,19 @@ SPIRVValue *LLVMToSPIRV::transValueWithoutDecoration(Value *V,
       MemoryAccess[0] |= MemoryAccessNontemporalMask;
     if (MemoryAccess.front() == 0)
       MemoryAccess.clear();
+
+    SPIRVValue *BSV = nullptr;
+    if(Function *F = dyn_cast<Function>(ST->getValueOperand())) {
+      // store of function pointer
+      BSV = BM->addFunctionPointerINTELInst(
+          transType(F->getType()),
+          static_cast<SPIRVFunction *>(transValue(F, BB)), BB);
+    } else {
+      BSV = transValue(ST->getValueOperand(), BB);
+    }
+
     return mapValue(V, BM->addStoreInst(transValue(ST->getPointerOperand(), BB),
-                                        transValue(ST->getValueOperand(), BB),
-                                        MemoryAccess, BB));
+                                        BSV, MemoryAccess, BB));
   }
 
   if (LoadInst *LD = dyn_cast<LoadInst>(V)) {
@@ -911,8 +938,17 @@ SPIRVValue *LLVMToSPIRV::transValueWithoutDecoration(Value *V,
 
   if (auto Phi = dyn_cast<PHINode>(V)) {
     std::vector<SPIRVValue *> IncomingPairs;
+
     for (size_t I = 0, E = Phi->getNumIncomingValues(); I != E; ++I) {
-      IncomingPairs.push_back(transValue(Phi->getIncomingValue(I), BB));
+      SPIRVValue *BV = nullptr;
+      if (Function *F = dyn_cast<Function>(Phi->getIncomingValue(I))) {
+        BV = BM->addFunctionPointerINTELInst(
+            transType(F->getType()),
+            static_cast<SPIRVFunction *>(transValue(F, BB)), BB);
+      } else {
+        BV = transValue(Phi->getIncomingValue(I), BB);
+      }
+      IncomingPairs.push_back(BV);
       IncomingPairs.push_back(transValue(Phi->getIncomingBlock(I), nullptr));
     }
     return mapValue(
@@ -1425,6 +1461,12 @@ SPIRVValue *LLVMToSPIRV::transIntrinsicInst(IntrinsicInst *II,
 }
 
 SPIRVValue *LLVMToSPIRV::transCallInst(CallInst *CI, SPIRVBasicBlock *BB) {
+  if (CI->isIndirectCall())
+    return transIndirectCallInst(CI, BB);
+  return transDirectCallInst(CI, BB);
+}
+
+SPIRVValue *LLVMToSPIRV::transDirectCallInst(CallInst *CI, SPIRVBasicBlock *BB) {
   SPIRVExtInstSetKind ExtSetKind = SPIRVEIS_Count;
   SPIRVWord ExtOp = SPIRVWORD_MAX;
   llvm::Function *F = CI->getCalledFunction();
@@ -1456,6 +1498,14 @@ SPIRVValue *LLVMToSPIRV::transCallInst(CallInst *CI, SPIRVBasicBlock *BB) {
       BB);
 }
 
+SPIRVValue *LLVMToSPIRV::transIndirectCallInst(CallInst *CI,
+                                               SPIRVBasicBlock *BB) {
+  return BM->addIndirectCallInst(
+      transValue(CI->getCalledValue(), BB), transType(CI->getType()),
+      transArguments(CI, BB, SPIRVEntry::createUnique(OpFunctionCall).get()),
+      BB);
+}
+
 bool LLVMToSPIRV::transAddressingMode() {
   Triple TargetTriple(M->getTargetTriple());
 

llvm-spirv/lib/SPIRV/SPIRVWriter.h

@@ -95,6 +95,8 @@ class LLVMToSPIRV : public ModulePass {
   bool transBuiltinSet();
   SPIRVValue *transIntrinsicInst(IntrinsicInst *Intrinsic, SPIRVBasicBlock *BB);
   SPIRVValue *transCallInst(CallInst *Call, SPIRVBasicBlock *BB);
+  SPIRVValue *transDirectCallInst(CallInst *Call, SPIRVBasicBlock *BB);
+  SPIRVValue *transIndirectCallInst(CallInst *Call, SPIRVBasicBlock *BB);
   bool transDecoration(Value *V, SPIRVValue *BV);
   SPIRVWord transFunctionControlMask(Function *);
   SPIRVFunction *transFunctionDecl(Function *F);

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVDecorate.h

@@ -152,6 +152,8 @@ class SPIRVDecorate : public SPIRVDecorateGeneric {
     case DecorationSimpleDualPortINTEL:
     case DecorationMergeINTEL:
       return getSet(SPV_INTEL_fpga_memory_attributes);
+    case DecorationReferencedIndirectlyINTEL:
+      return getSet(SPV_INTEL_function_pointers);
     default:
       return SPIRVExtSet();
     }

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVEnum.h

@@ -119,7 +119,8 @@ enum SPIRVExtensionKind {
   SPV_INTEL_device_side_avc_motion_estimation,
   SPV_INTEL_fpga_reg,
   SPV_INTEL_fpga_memory_attributes,
-  SPV_INTEL_unstructured_loop_controls
+  SPV_INTEL_unstructured_loop_controls,
+  SPV_INTEL_function_pointers
 };
 
 typedef std::set<SPIRVExtensionKind> SPIRVExtSet;
@@ -133,6 +134,7 @@ template <> inline void SPIRVMap<SPIRVExtensionKind, std::string>::init() {
   add(SPV_KHR_no_integer_wrap_decoration, "SPV_KHR_no_integer_wrap_decoration");
   add(SPV_INTEL_fpga_reg, "SPV_INTEL_fpga_reg");
   add(SPV_INTEL_fpga_memory_attributes, "SPV_INTEL_fpga_memory_attributes");
+  add(SPV_INTEL_function_pointers, "SPV_INTEL_function_pointers");
 }
 
 template <> inline void SPIRVMap<SPIRVExtInstSetKind, std::string>::init() {
@@ -376,6 +378,7 @@ template <> inline void SPIRVMap<Decoration, SPIRVCapVec>::init() {
   ADD_VEC_INIT(DecorationSimpleDualPortINTEL,
                {CapabilityFPGAMemoryAttributesINTEL});
   ADD_VEC_INIT(DecorationMergeINTEL, {CapabilityFPGAMemoryAttributesINTEL});
+  ADD_VEC_INIT(DecorationReferencedIndirectlyINTEL, {CapabilityIndirectReferencesINTEL});
 }
 
 template <> inline void SPIRVMap<BuiltIn, SPIRVCapVec>::init() {

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVErrorEnum.h

@@ -10,3 +10,4 @@ _SPIRV_OP(InvalidFunctionCall, "Unexpected llvm intrinsic:")
 _SPIRV_OP(InvalidArraySize, "Array size must be at least 1:")
 _SPIRV_OP(InvalidModule, "Invalid SPIR-V module:")
 _SPIRV_OP(UnimplementedOpCode, "Unimplemented opcode")
+_SPIRV_OP(FunctionPointersDisallowed, "Can't translate the function pointer:\n")

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVInstruction.cpp

@@ -119,6 +119,31 @@ void SPIRVFunctionCall::validate() const {
   SPIRVFunctionCallGeneric::validate();
 }
 
+SPIRVFunctionPointerCallINTEL::SPIRVFunctionPointerCallINTEL(
+    SPIRVId TheId, SPIRVValue *TheCalledValue, SPIRVType *TheReturnType,
+    const std::vector<SPIRVWord> &TheArgs, SPIRVBasicBlock *BB)
+    : SPIRVFunctionCallGeneric(TheReturnType, TheId, TheArgs, BB),
+      CalledValueId(TheCalledValue->getId()) {
+  validate();
+}
+
+void SPIRVFunctionPointerCallINTEL::validate() const {
+  SPIRVFunctionCallGeneric::validate();
+}
+
+SPIRVFunctionPointerINTEL::SPIRVFunctionPointerINTEL(SPIRVId TheId,
+                                                     SPIRVType *TheType,
+                                                     SPIRVFunction *TheFunction,
+                                                     SPIRVBasicBlock *BB)
+    : SPIRVInstruction(FixedWordCount, OC, TheType, TheId, BB),
+      TheFunction(TheFunction->getId()) {
+  validate();
+}
+
+void SPIRVFunctionPointerINTEL::validate() const {
+  SPIRVInstruction::validate();
+}
+
 // ToDo: Each instruction should implement this function
 std::vector<SPIRVValue *> SPIRVInstruction::getOperands() {
   std::vector<SPIRVValue *> Empty;

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVInstruction.h

@@ -1451,6 +1451,50 @@ class SPIRVFunctionCall : public SPIRVFunctionCallGeneric<OpFunctionCall, 4> {
   SPIRVId FunctionId;
 };
 
+class SPIRVFunctionPointerCallINTEL
+    : public SPIRVFunctionCallGeneric<OpFunctionPointerCallINTEL, 4> {
+public:
+  SPIRVFunctionPointerCallINTEL(SPIRVId TheId, SPIRVValue *TheCalledValue,
+                            SPIRVType *TheReturnType,
+                            const std::vector<SPIRVWord> &TheArgs,
+                            SPIRVBasicBlock *BB);
+  SPIRVFunctionPointerCallINTEL() : CalledValueId(SPIRVID_INVALID) {}
+  SPIRVValue *getCalledValue() const { return get<SPIRVValue>(CalledValueId); }
+  _SPIRV_DEF_ENCDEC4(Type, Id, CalledValueId, Args)
+  void validate() const override;
+  bool isOperandLiteral(unsigned Index) const override { return false; }
+  SPIRVExtSet getRequiredExtensions() const override {
+    return getSet(SPV_INTEL_function_pointers);
+  }
+  SPIRVCapVec getRequiredCapability() const override {
+    return getVec(CapabilityFunctionPointersINTEL);
+  }
+
+protected:
+  SPIRVId CalledValueId;
+};
+
+class SPIRVFunctionPointerINTEL : public SPIRVInstruction {
+  const static Op OC = OpFunctionPointerINTEL;
+  const static SPIRVWord FixedWordCount = 4;
+public:
+  SPIRVFunctionPointerINTEL(SPIRVId TheId, SPIRVType *TheType,
+                            SPIRVFunction *TheFunction, SPIRVBasicBlock *BB);
+  SPIRVFunctionPointerINTEL() : SPIRVInstruction(OC), TheFunction(SPIRVID_INVALID) {}
+  SPIRVFunction *getFunction() const { return get<SPIRVFunction>(TheFunction); }
+  _SPIRV_DEF_ENCDEC3(Type, Id, TheFunction)
+  void validate() const override;
+  bool isOperandLiteral(unsigned Index) const override { return false; }
+  SPIRVExtSet getRequiredExtensions() const override {
+    return getSet(SPV_INTEL_function_pointers);
+  }
+  SPIRVCapVec getRequiredCapability() const override {
+    return getVec(CapabilityFunctionPointersINTEL);
+  }
+protected:
+  SPIRVId TheFunction;
+};
+
 class SPIRVExtInst : public SPIRVFunctionCallGeneric<OpExtInst, 5> {
 public:
   SPIRVExtInst(SPIRVType *TheType, SPIRVId TheId, SPIRVId TheBuiltinSet,

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVIsValidEnum.h

@@ -405,6 +405,7 @@ inline bool isValid(spv::Decoration V) {
   case DecorationMaxPrivateCopiesINTEL:
   case DecorationSinglepumpINTEL:
   case DecorationDoublepumpINTEL:
+  case DecorationReferencedIndirectlyINTEL:
     return true;
   default:
     return false;