Compiler outputs per-function attributes for function pointer linking support

Change-Id: I9d4170442b0aa02ec6d7a4c542152ba128cd527d

Author: dlei6g

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -4725,6 +4725,42 @@ namespace IGC
         assert(sizeof(vISA::GenRelocEntry) * tableEntries == bufferSize);
     }
 
+    void CEncoder::CreateFuncAttributeTable(void*& buffer, unsigned& bufferSize, unsigned& tableEntries)
+    {
+        buffer = nullptr;
+        bufferSize = 0;
+        tableEntries = 0;
+
+        std::vector<vISA::GenFuncAttribEntry> attribTable;
+        for (auto it : funcAttributeMap)
+        {
+            vISA::GenFuncAttribEntry entry;
+            Function* F = it.first;
+
+            // Ignore internal functions
+            if (!isEntryFunc(m_program->GetContext()->getMetaDataUtils(), F) &&
+                !F->hasFnAttribute("IndirectlyCalled"))
+                continue;
+
+            assert(F->getName().size() <= vISA::MAX_SYMBOL_NAME_LENGTH);
+            strcpy_s(entry.f_name, vISA::MAX_SYMBOL_NAME_LENGTH, F->getName().str().c_str());
+            entry.f_isKernel = it.second.isKernel ? 1 : 0;
+            entry.f_hasBarrier = it.second.hasBarrier ? 1 : 0;
+            entry.f_privateMemPerThread = (uint32_t) (it.second.argumentStackSize + it.second.allocaStackSize);
+
+            attribTable.push_back(entry);
+        }
+
+        if (!attribTable.empty())
+        {
+            tableEntries = attribTable.size();
+            bufferSize = tableEntries * sizeof(vISA::GenFuncAttribEntry);
+            buffer = (void*)malloc(bufferSize);
+            assert(buffer && "Table cannot be allocated");
+            memcpy_s(buffer, bufferSize, attribTable.data(), bufferSize);
+        }
+    }
+
     void CEncoder::Compile(bool hasSymbolTable)
     {
         CodeGenContext* context = m_program->GetContext();
@@ -5010,6 +5046,13 @@ namespace IGC
             CreateRelocationTable(pOutput->m_funcRelocationTable,
                 pOutput->m_funcRelocationTableSize,
                 pOutput->m_funcRelocationTableEntries);
+
+            if (IGC_IS_FLAG_ENABLED(EnableRuntimeFuncAttributePatching))
+            {
+                CreateFuncAttributeTable(pOutput->m_funcAttributeTable,
+                    pOutput->m_funcAttributeTableSize,
+                    pOutput->m_funcAttributeTableEntries);
+            }
         }
 
         if (jitInfo->isSpill == true)

IGC/Compiler/CISACodeGen/CISABuilder.hpp

@@ -474,6 +474,7 @@ namespace IGC
 
         void CreateSymbolTable(void*& buffer, unsigned& bufferSize, unsigned& tableEntries);
         void CreateRelocationTable(void*& buffer, unsigned& bufferSize, unsigned& tableEntries);
+        void CreateFuncAttributeTable(void*& buffer, unsigned& bufferSize, unsigned& tableEntries);
 
         uint32_t getGRFSize() const;
 
@@ -573,6 +574,31 @@ namespace IGC
         VISA_SamplerVar* samplervar;
 
         CShader* m_program;
+
+        // Keep a map between a function and its per-function attributes needed for function pointer support
+        struct FuncAttrib
+        {
+            bool isKernel = false;
+            bool hasBarrier = false;
+            unsigned argumentStackSize = 0;
+            unsigned allocaStackSize = 0;
+        };
+        llvm::SmallDenseMap<llvm::Function*, FuncAttrib> funcAttributeMap;
+
+    public:
+        // Used by EmitVISAPass to set function attributes
+        void SetFunctionIsKernel(llvm::Function* F) {
+            funcAttributeMap[F].isKernel = true;
+        }
+        void SetFunctionHasBarrier(llvm::Function* F) {
+            funcAttributeMap[F].hasBarrier = true;
+        }
+        void SetFunctionMaxArgumentStackSize(llvm::Function* F, unsigned size) {
+            funcAttributeMap[F].argumentStackSize = MAX(funcAttributeMap[F].argumentStackSize, size);
+        }
+        void SetFunctionAllocaStackSize(llvm::Function* F, unsigned size) {
+            funcAttributeMap[F].allocaStackSize = size;
+        }
     };
 
     inline void CEncoder::Jump(uint label)

IGC/Compiler/CISACodeGen/CShader.cpp

@@ -280,13 +280,26 @@ void CShader::InitKernelStack(CVariable*& stackBase, CVariable*& stackAllocSize,
     encoder.SetSrcSubReg(0, 5);
     encoder.And(pHWTID, GetR0(), ImmToVariable(0x1ff, ISA_TYPE_UD));
     encoder.Push();
-    // hard-code per-workitem private-memory size to 8k
-    CVariable* pSize = ImmToVariable(8 * 1024 * numLanes(m_dispatchSize), ISA_TYPE_UD);
+
+    CVariable* pSize = nullptr;
+    if (IGC_IS_FLAG_ENABLED(EnableRuntimeFuncAttributePatching))
+    {
+        // Experimental: Patch private memory size
+        pSize = GetNewVariable(1, ISA_TYPE_UD, CVariable::getAlignment(getGRFSize()), true);
+        std::string patchName = "INTEL_PATCH_PRIVATE_MEMORY_SIZE";
+        encoder.AddVISASymbol(patchName, pSize);
+    }
+    else
+    {
+        // hard-code per-workitem private-memory size to 8k
+        pSize = ImmToVariable(8 * 1024 * numLanes(m_dispatchSize), ISA_TYPE_UD);
+    }
+
     CVariable* pTemp = GetNewVariable(1, ISA_TYPE_UD, EALIGN_DWORD, true, 1);
     encoder.Mul(pTemp, pHWTID, pSize);
     encoder.Push();
-    // reserve space for alloca
 
+    // reserve space for alloca
     auto funcMDItr = m_ModuleMetadata->FuncMD.find(entry);
     if (funcMDItr != m_ModuleMetadata->FuncMD.end())
     {
@@ -295,8 +308,13 @@ void CShader::InitKernelStack(CVariable*& stackBase, CVariable*& stackAllocSize,
             unsigned totalAllocaSize = funcMDItr->second.privateMemoryPerWI * numLanes(m_dispatchSize);
             encoder.Add(pTemp, pTemp, ImmToVariable(totalAllocaSize, ISA_TYPE_UD));
             encoder.Push();
+
+            // Set the total alloca size for the entry function
+            encoder.SetFunctionAllocaStackSize(entry, totalAllocaSize);
         }
     }
+    // Indicate this is the kernel function
+    encoder.SetFunctionIsKernel(entry);
 
     // modify private-memory size to a large setting
     m_ModuleMetadata->FuncMD[entry].privateMemoryPerWI = 8192;

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -9564,8 +9564,14 @@ void EmitPass::emitStackCall(llvm::CallInst* inst)
             // end of reading return value from stack
         }
     }
-    //  update stack pointer after the call
 
+    // Set the max stack sized pushed in the parent function for this call's args
+    if (offsetS > 0)
+    {
+        m_encoder->SetFunctionMaxArgumentStackSize(inst->getParent()->getParent(), offsetS);
+    }
+
+    //  update stack pointer after the call
     CVariable* pSP = m_currShader->GetSP();
     CVariable* pPopSize = m_currShader->ImmToVariable((uint64_t)(~offsetS + 1), ISA_TYPE_D);
     emitAddSP(pSP, pSP, pPopSize);
@@ -9747,6 +9753,9 @@ void EmitPass::emitStackFuncEntry(Function* F, bool ptr64bits)
             CVariable* pSP = m_currShader->GetSP();
             unsigned totalAllocaSize = funcMDItr->second.privateMemoryPerWI * numLanes(m_currShader->m_dispatchSize);
             emitAddSP(pSP, pSP, m_currShader->ImmToVariable(totalAllocaSize, ISA_TYPE_UD));
+
+            // Set the per-function private mem size
+            m_encoder->SetFunctionAllocaStackSize(F, totalAllocaSize);
         }
     }
 }
@@ -13034,6 +13043,9 @@ void EmitPass::emitThreadGroupBarrier(llvm::Instruction* inst)
         m_currShader->SetHasBarrier();
         m_encoder->Barrier(BarrierKind);
         m_encoder->Push();
+
+        // Set if barrier was used for this function
+        m_encoder->SetFunctionHasBarrier(inst->getParent()->getParent());
     }
 }
 

IGC/Compiler/CodeGenPublic.h

@@ -110,6 +110,9 @@ namespace IGC
         void* m_funcRelocationTable = nullptr;
         unsigned int    m_funcRelocationTableSize = 0;
         unsigned int    m_funcRelocationTableEntries = 0;
+        void* m_funcAttributeTable = nullptr;
+        unsigned int    m_funcAttributeTableSize = 0;
+        unsigned int    m_funcAttributeTableEntries = 0;
         unsigned int    m_offsetToSkipPerThreadDataLoad = 0;
         uint32_t        m_offsetToSkipSetFFIDGP = 0;
         //true means we separate pvtmem and spillfill. pvtmem could go into stateless.

IGC/common/igc_flags.def

@@ -290,8 +290,9 @@ DECLARE_IGC_REGKEY(bool, UniformMemOptLimit,            false, "Limit of uniform
 DECLARE_IGC_REGKEY(bool, EnableFunctionPointer,         true,  "Enables support for function pointers and indirect calls", false)
 DECLARE_IGC_REGKEY(bool, EnableIndirectCallOptimization, false, "Enables inlining indirect calls by comparing function addresses", false)
 DECLARE_IGC_REGKEY(bool, ForceFFIDOverwrite,            false, "Force overwriting ffid in sr0.0", false)
-
 DECLARE_IGC_REGKEY(bool, EnableReadGTPinInput,          true,  "Enables setting GTPin context flags by reading the input to the compiler adapters", false)
+DECLARE_IGC_REGKEY(bool, EnableRuntimeFuncAttributePatching, false,  "Creates a relocation entry to let runtime calculate the max call depth and patch required scratch space usage", true)
+
 
 DECLARE_IGC_GROUP("Performance experiments")
 DECLARE_IGC_REGKEY(bool, ForceNonCoherentStatelessBTI,  false, "Enable gneeration of non cache coherent stateless messages", false)

visa/TranslationInterface.cpp

@@ -2386,7 +2386,16 @@ int IR_Builder::translateVISACFSymbolInst(const std::string& symbolName, G4_DstR
     startTimer(TIMER_VISA_BUILDER_IR_CONSTRUCTION);
 #endif
 
-    if (no64bitType())
+    if (symbolName.compare("INTEL_PATCH_PRIVATE_MEMORY_SIZE") == 0)
+    {
+        // Relocation for runtime-calculated private memory size
+        auto* privateMemPatch = createRelocImm(Type_UD);
+        dst->setType(Type_UD);
+        G4_INST* mov = createMov(1, dst, privateMemPatch, InstOpt_WriteEnable, true);
+        RelocationEntry relocEntry = RelocationEntry::createSymbolAddrReloc(mov, 0, symbolName, GenRelocType::R_SYM_ADDR_32);
+        kernel.addRelocation(relocEntry);
+    }
+    else if (no64bitType())
     {
         auto* funcAddrLow = createRelocImm(Type_UD);
         auto* funcAddrHigh = createRelocImm(Type_UD);

visa/include/RelocationInfo.h

@@ -44,21 +44,21 @@ enum GenSymType {
     S_FUNC             = 2,    // The symbol is associated with a function
     S_GLOBAL_VAR       = 3,    // The symbol is associated with a global variable in global address space
     S_GLOBAL_VAR_CONST = 4,    // The symbol is associated with a global variable in constant address space
-    S_CONST_SAMPLER   = 5      // The symbol is associated with a constant sampler
+    S_CONST_SAMPLER    = 5     // The symbol is associated with a constant sampler
 };
 
 /// GenSymEntry - An symbol table entry
 typedef struct {
     uint32_t   s_type;            // The symbol's type
     uint32_t   s_offset;          // The binary offset of this symbol. This field is ignored if s_type is S_UNDEF
-    uint32_t   s_size;
+    uint32_t   s_size;            // The size in bytes of the function binary
     char       s_name[MAX_SYMBOL_NAME_LENGTH]; // The symbol's name
 } GenSymEntry;
 
 /// GenRelocType - Specify the relocation's type
 enum GenRelocType {
-    R_NONE     = 0,
-    R_SYM_ADDR = 1,      //64-bit type
+    R_NONE = 0,
+    R_SYM_ADDR = 1,      //64-bit type address
     R_SYM_ADDR_32 = 2,   //lower 32-bit of 64-bit address.
     R_SYM_ADDR_32_HI = 3 //higher 32bits of 64-bit address
 };
@@ -70,6 +70,14 @@ typedef struct {
     char       r_symbol[MAX_SYMBOL_NAME_LENGTH]; // The relocation target symbol's name
 } GenRelocEntry;
 
+/// GenFuncAttribEntry - Per-function attribute entry
+typedef struct {
+    uint8_t    f_isKernel;      // Is the function a kernel
+    uint8_t    f_hasBarrier;    // Does the function use barriers
+    uint32_t   f_privateMemPerThread; // Total private memory (in bytes) used by this function per thread
+    char       f_name[MAX_SYMBOL_NAME_LENGTH]; // The function's name
+} GenFuncAttribEntry;
+
 }
 
 #endif