Functions groups with indirect calls can by rebuilt in FGA pass, without having to rerun the entire pass.

Also fixed a bug where we only need to generate a single relocation instruction, instead of one per use.

Change-Id: I9c46171c6ea87e03717b2d047eba3595c9b74411

Author: dlei6g

IGC/AdaptorCommon/AddImplicitArgs.cpp

@@ -557,9 +557,10 @@ void AddImplicitArgs::FixIndirectCalls(Module& M)
                     Value* funcPtr = call->getCalledValue();
                     PointerType* funcTy = PointerType::get(FunctionType::get(call->getType(), argTys, false), 0);
                     funcPtr = builder.CreatePointerBitCastOrAddrSpaceCast(funcPtr, funcTy);
-                    Value* newCall = builder.CreateCall(funcPtr, args);
+                    CallInst* newCall = builder.CreateCall(funcPtr, args);
 
                     call->replaceAllUsesWith(newCall);
+                    newCall->copyMetadata(*call);
                     list_delete.push_back(call);
                 }
             }

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -453,6 +453,7 @@ bool EmitPass::runOnFunction(llvm::Function& F)
 
     if (IGC_IS_FLAG_ENABLED(EnableFunctionPointer))
     {
+        SmallSet<Function*, 8> funcAddrSymbols;
         Module* pModule = F.getParent();
         for (auto& FI : pModule->getFunctionList())
         {
@@ -467,15 +468,21 @@ bool EmitPass::runOnFunction(llvm::Function& F)
                     {
                         if (inst->getParent()->getParent() == &F)
                         {
-                            m_currShader->CreateFunctionSymbol(&FI);
+                            funcAddrSymbols.insert(&FI);
                         }
                     }
                 }
             }
         }
+        for (auto pFunc : funcAddrSymbols)
+        {
+            m_currShader->CreateFunctionSymbol(pFunc);
+        }
     }
+
     if (m_moduleMD->compOpt.EnableGlobalRelocation)
     {
+        SmallSet<GlobalVariable*, 8> globalAddrSymbols;
         Module* pModule = F.getParent();
         for (auto gi = pModule->global_begin(), ge = pModule->global_end(); gi != ge; gi++)
         {
@@ -492,13 +499,17 @@ bool EmitPass::runOnFunction(llvm::Function& F)
                         {
                             if (inst->getParent()->getParent() == &F)
                             {
-                                m_currShader->CreateGlobalSymbol(pGlobal);
+                                globalAddrSymbols.insert(pGlobal);
                             }
                         }
                     }
                 }
             }
         }
+        for (auto pGlobal : globalAddrSymbols)
+        {
+            m_currShader->CreateGlobalSymbol(pGlobal);
+        }
     }
 
     m_VRA->BeginFunction(&F, numLanes(m_SimdMode));
@@ -717,8 +728,8 @@ bool EmitPass::runOnFunction(llvm::Function& F)
     {
         destroyVISABuilder = true;
         // We only need one symbol table per module. If there are multiple kernels, only create a symbol
-        // table for the default one set by FGA
-        bool compileWithSymbolTable = !m_FGA || (m_FGA->getGroup(&F)->getHead() == m_FGA->getDefaultKernel());
+        // table for the one with indirectly called functions attached.
+        bool compileWithSymbolTable = !m_FGA || (m_FGA->getGroup(&F)->hasIndirectFuncs());
         m_encoder->Compile(compileWithSymbolTable);
         // if we are doing stack-call, do the following:
         // - Hard-code a large scratch-space for visa

IGC/Compiler/CISACodeGen/GenCodeGenModule.cpp

@@ -373,7 +373,6 @@ bool GenXCodeGenModule::runOnModule(Module& M)
 
     pMdUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
     CallGraph& CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
-    FGA->setDefaultkernel(nullptr);
 
     std::vector<std::vector<CallGraphNode*>*> SCCVec;
     for (auto I = scc_begin(&CG), IE = scc_end(&CG); I != IE; ++I)
@@ -394,28 +393,10 @@ bool GenXCodeGenModule::runOnModule(Module& M)
                 {
                     FGA->setSubGroupMap(F, F);
                     FGA->createFunctionGroup(F);
-                    // There may be multiple kernels, set one as the default
-                    if (FGA->getDefaultKernel() == nullptr)
-                        FGA->setDefaultkernel(F);
                 }
                 else if (F->hasFnAttribute("IndirectlyCalled"))
                 {
-                    // Add all externally linked functions into the default kernel group
-                    Function* defaultKernel = FGA->getDefaultKernel();
-                    assert(defaultKernel && "kernel does not exist in this group");
-                    FunctionGroup* defaultFG = FGA->getGroupForHead(defaultKernel);
-                    assert(defaultFG && "default kernel group does not exist");
-                    FGA->addToFunctionGroup(F, defaultFG, F);
-
-                    // Mark caller group if it calls or uses this function
-                    for (auto U : F->users())
-                    {
-                        if (CallInst * CI = dyn_cast<CallInst>(U))
-                        {
-                            Function* Caller = CI->getParent()->getParent();
-                            FGA->getGroup(Caller)->m_hasExternFCall = true;
-                        }
-                    }
+                    continue;
                 }
                 else if (SCCNodes->size() == 1)
                 {
@@ -431,6 +412,9 @@ bool GenXCodeGenModule::runOnModule(Module& M)
         delete SCCNodes;
     }
 
+    // Add all indirect functions to the default kernel group
+    FGA->addIndirectFuncsToKernelGroup(&M);
+
     // By swapping, we sort the function list to ensure codegen order for
     // functions. This relies on llvm module pass manager's implementation detail.
     SmallVector<Function*, 16> OrderedList;
@@ -465,7 +449,6 @@ bool GenXCodeGenModule::runOnModule(Module& M)
         }
     }
 
-
 #if defined(_DEBUG)
     assert(FGA->verify());
 #endif
@@ -545,6 +528,50 @@ bool GenXFunctionGroupAnalysis::useStackCall(llvm::Function* F)
     return (F->hasFnAttribute("visaStackCall"));
 }
 
+void GenXFunctionGroupAnalysis::addIndirectFuncsToKernelGroup(llvm::Module* pModule)
+{
+    auto pMdUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
+
+    Function* defaultKernel = nullptr;
+    // Set the first kernel as the default
+    for (auto I = pModule->begin(), E = pModule->end(); I != E; ++I)
+    {
+        Function* F = &(*I);
+        if (isEntryFunc(pMdUtils, F))
+        {
+            defaultKernel = F;
+            break;
+        }
+    }
+    assert(defaultKernel && "kernel does not exist in this group");
+
+    FunctionGroup* defaultFG = getGroupForHead(defaultKernel);
+    assert(defaultFG && "default kernel group does not exist");
+
+    // Add all externally linked functions into the default kernel group
+    for (auto I = pModule->begin(), E = pModule->end(); I != E; ++I)
+    {
+        Function* F = &(*I);
+        if (F->isDeclaration() || isEntryFunc(pMdUtils, F)) continue;
+
+        if (F->hasFnAttribute("IndirectlyCalled"))
+        {
+            addToFunctionGroup(F, defaultFG, F);
+            defaultFG->m_hasIndirectFuncs = true;
+
+            // Mark caller group if it calls or uses this function
+            for (auto U : F->users())
+            {
+                if (CallInst * CI = dyn_cast<CallInst>(U))
+                {
+                    Function* Caller = CI->getParent()->getParent();
+                    getGroup(Caller)->m_hasExternFCall = true;
+                }
+            }
+        }
+    }
+}
+
 bool GenXFunctionGroupAnalysis::rebuild(llvm::Module* Mod) {
     clear();
     auto pMdUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
@@ -570,6 +597,10 @@ bool GenXFunctionGroupAnalysis::rebuild(llvm::Module* Mod) {
             CurFG = createFunctionGroup(F);
             CurSubGrpH = F;
         }
+        else if (F->hasFnAttribute("IndirectlyCalled"))
+        {
+            continue;
+        }
         else
         {
             if (useStackCall(F))
@@ -584,6 +615,9 @@ bool GenXFunctionGroupAnalysis::rebuild(llvm::Module* Mod) {
         }
     }
 
+    // Re-add all indirect functions to the default kernel group
+    addIndirectFuncsToKernelGroup(Mod);
+
     // Verification.
     if (!verify())
     {

IGC/Compiler/CISACodeGen/GenCodeGenModule.h

@@ -71,7 +71,7 @@ namespace IGC {
     /// \brief A collection of functions that are reachable from a kernel.
     class FunctionGroup {
     public:
-        friend class GenXCodeGenModule;
+        friend class GenXFunctionGroupAnalysis;
         /// \brief use 2-d vector of Functions to represent FunctionGroup. 
         /// Each sub-vector is a subgroup led by a kernel or a stack-call function.
         /// Element [0][0] is the group head. Element[i][0] is the sub-group head.
@@ -100,6 +100,9 @@ namespace IGC {
         /// \brief Indicate if any function in this group directly calls an externally linked function
         bool hasExternFCall() { return m_hasExternFCall; }
 
+        /// \brief Indicate if there are indirectly functions attached to this group
+        bool hasIndirectFuncs() { return m_hasIndirectFuncs; }
+
         void replaceGroupHead(llvm::Function* OH, llvm::Function* NH) {
             auto headSG = Functions[0];
             llvm::AssertingVH<llvm::Function>& HVH = (*headSG)[0];
@@ -109,6 +112,7 @@ namespace IGC {
 
     private:
         bool m_hasExternFCall = false;
+        bool m_hasIndirectFuncs = false;
     };
 
     class GenXFunctionGroupAnalysis : public llvm::ImmutablePass {
@@ -124,9 +128,6 @@ namespace IGC {
         /// \brief Each function also belongs to a uniquely defined sub-group of a stack-call entry
         llvm::DenseMap<llvm::Function*, llvm::Function*> SubGroupMap;
 
-        /// \brief the main kernel in this module
-        llvm::Function* DefaultKernel = nullptr;
-
     public:
         static char ID;
         explicit GenXFunctionGroupAnalysis();
@@ -146,6 +147,9 @@ namespace IGC {
         ///
         bool rebuild(llvm::Module* Mod);
 
+        // Attach all indirectly called functions to a single kernel group
+        void addIndirectFuncsToKernelGroup(llvm::Module* pModule);
+
         // Replace OF with NF in Groups and GroupMap
         void replaceEntryFunc(llvm::Function* OF, llvm::Function* NF);
 
@@ -175,9 +179,6 @@ namespace IGC {
             return I->second;
         }
 
-        llvm::Function* getDefaultKernel() { return DefaultKernel; }
-        void setDefaultkernel(llvm::Function* F) { DefaultKernel = F; }
-
         void setSubGroupMap(llvm::Function* F, llvm::Function* SubGroupHead) {
             SubGroupMap[F] = SubGroupHead;
         }