[Autobackout][FuncReg]Revert of change: 54e89df

 change the forceSpillCompression input to optional

change the forceSpillCompression input to optional

Author: raghushi

IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp

@@ -76,14 +76,6 @@ static const unsigned int MAX_RETVAL_SIZE_IN_BITS = 64;
 static const unsigned int MAX_STRUCT_SIZE_IN_BITS = 128;
 static const unsigned int MAX_SUBROUTINE_STRUCT_SIZE_IN_BITS = 512;
 
-enum ReturnOpt
-{
-    RETURN_DEFAULT = 0,
-    RETURN_BY_REF,
-    RETURN_STRUCT,
-    RETURN_LEGAL_INT
-};
-
 bool LegalizeFunctionSignatures::runOnModule(Module& M)
 {
     auto pMdUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
@@ -275,7 +267,8 @@ void LegalizeFunctionSignatures::FixFunctionSignatures(Module& M)
             continue;
         }
 
-        ReturnOpt retTypeOption = ReturnOpt::RETURN_DEFAULT;
+        bool legalizeReturnType = false;
+        bool promoteSRetType = false;
         bool fixArgType = false;
         std::vector<Type*> argTypes;
 
@@ -287,18 +280,14 @@ void LegalizeFunctionSignatures::FixFunctionSignatures(Module& M)
         // Create the new function signature by replacing the illegal types
         if (FunctionHasPromotableSRetArg(M, pFunc))
         {
-            retTypeOption = ReturnOpt::RETURN_STRUCT;
+            promoteSRetType = true;
             ai++; // Skip adding the first arg
         }
         else if (!isLegalSignatureType(M, pFunc->getReturnType(), isStackCall))
         {
-            retTypeOption = ReturnOpt::RETURN_BY_REF;
+            legalizeReturnType = true;
             argTypes.push_back(PointerType::get(pFunc->getReturnType(), 0));
         }
-        else if (!isLegalIntVectorType(M, pFunc->getReturnType()))
-        {
-            retTypeOption = ReturnOpt::RETURN_LEGAL_INT;
-        }
 
         for (; ai != ei; ai++)
         {
@@ -324,32 +313,33 @@ void LegalizeFunctionSignatures::FixFunctionSignatures(Module& M)
             }
         }
 
-        if (retTypeOption != ReturnOpt::RETURN_DEFAULT || fixArgType)
+        if (!legalizeReturnType && !promoteSRetType && !fixArgType)
         {
-            // Clone function with new signature
-            Type* returnType =
-                retTypeOption == ReturnOpt::RETURN_BY_REF ? Type::getVoidTy(M.getContext()) :
-                retTypeOption == ReturnOpt::RETURN_STRUCT ? PromotedStructValueType(M, pFunc->arg_begin()->getType()) :
-                retTypeOption == ReturnOpt::RETURN_LEGAL_INT ? LegalizedIntVectorType(M, pFunc->getReturnType()) :
-                pFunc->getReturnType();
-            FunctionType* signature = FunctionType::get(returnType, argTypes, false);
-            Function* pNewFunc = Function::Create(signature, pFunc->getLinkage(), pFunc->getName(), pFunc->getParent());
-            pNewFunc->takeName(pFunc);
-            pNewFunc->setCallingConv(pFunc->getCallingConv());
-            pNewFunc->setAttributes(pFunc->getAttributes());
-
-            // Since we need to pass in pointers to be dereferenced by the new function, remove the "readnone" attribute
-            // Also we need to create allocas for these pointers, so set the flag to true
-            if (retTypeOption == ReturnOpt::RETURN_BY_REF)
-            {
-                pNewFunc->removeFnAttr(llvm::Attribute::ReadNone);
-                pNewFunc->removeFnAttr(llvm::Attribute::ReadOnly);
-                pContext->m_instrTypes.hasNonPrimitiveAlloca = true;
-            }
+            // Nothing to fix
+            continue;
+        }
 
-            // Map the old function to the new
-            oldToNewFuncMap[pFunc] = pNewFunc;
+        // Clone function with new signature
+        Type* returnType = legalizeReturnType ? Type::getVoidTy(M.getContext()) :
+            promoteSRetType ? PromotedStructValueType(M, pFunc->arg_begin()->getType()) :
+            pFunc->getReturnType();
+        FunctionType* signature = FunctionType::get(returnType, argTypes, false);
+        Function* pNewFunc = Function::Create(signature, pFunc->getLinkage(), pFunc->getName(), pFunc->getParent());
+        pNewFunc->takeName(pFunc);
+        pNewFunc->setCallingConv(pFunc->getCallingConv());
+        pNewFunc->setAttributes(pFunc->getAttributes());
+
+        // Since we need to pass in pointers to be dereferenced by the new function, remove the "readnone" attribute
+        // Also we need to create allocas for these pointers, so set the flag to true
+        if (legalizeReturnType)
+        {
+            pNewFunc->removeFnAttr(llvm::Attribute::ReadNone);
+            pNewFunc->removeFnAttr(llvm::Attribute::ReadOnly);
+            pContext->m_instrTypes.hasNonPrimitiveAlloca = true;
         }
+
+        // Map the old function to the new
+        oldToNewFuncMap[pFunc] = pNewFunc;
     }
 }
 
@@ -367,28 +357,26 @@ void LegalizeFunctionSignatures::FixFunctionBody(Module& M)
             llvm::SmallVector<llvm::ReturnInst*, 8> Returns;
             auto OldArgIt = pFunc->arg_begin();
             auto NewArgIt = pNewFunc->arg_begin();
-            ReturnOpt retTypeOption = ReturnOpt::RETURN_DEFAULT;
+            bool legalizeReturnType = false;
+            bool promoteSRetType = false;
             bool isStackCall = pFunc->hasFnAttribute("visaStackCall");
             Value* tempAllocaForSRetPointer = nullptr;
             llvm::SmallVector<llvm::Argument*, 8> ArgByVal;
 
             if (FunctionHasPromotableSRetArg(M, pFunc)) {
-                retTypeOption = ReturnOpt::RETURN_STRUCT;
+                promoteSRetType = true;
             }
             else if (!isLegalSignatureType(M, pFunc->getReturnType(), isStackCall)) {
-                retTypeOption = ReturnOpt::RETURN_BY_REF;
+                legalizeReturnType = true;
                 ++NewArgIt; // Skip first argument that we added.
             }
-            else if (!isLegalIntVectorType(M, pFunc->getReturnType())) {
-                retTypeOption = ReturnOpt::RETURN_LEGAL_INT;
-            }
 
             // Fix the usages of arguments that have changed
             BasicBlock* EntryBB = BasicBlock::Create(M.getContext(), "", pNewFunc);
             IGCLLVM::IRBuilder<> builder(EntryBB);
             for (; OldArgIt != pFunc->arg_end(); ++OldArgIt)
             {
-                if (OldArgIt == pFunc->arg_begin() && retTypeOption == ReturnOpt::RETURN_STRUCT)
+                if (OldArgIt == pFunc->arg_begin() && promoteSRetType)
                 {
                     // Create a temp alloca to map the old argument. This will be removed later by SROA.
                     tempAllocaForSRetPointer = builder.CreateAlloca(PromotedStructValueType(M, OldArgIt->getType()));
@@ -449,7 +437,7 @@ void LegalizeFunctionSignatures::FixFunctionBody(Module& M)
             }
 
             // Now fix the return values
-            if (retTypeOption == ReturnOpt::RETURN_BY_REF)
+            if (legalizeReturnType)
             {
                 // Add the 'noalias' and 'sret' attribute to arg0
                 auto retArg = pNewFunc->arg_begin();
@@ -471,7 +459,7 @@ void LegalizeFunctionSignatures::FixFunctionBody(Module& M)
                     RetInst->eraseFromParent();
                 }
             }
-            else if (retTypeOption == ReturnOpt::RETURN_STRUCT)
+            else if (promoteSRetType)
             {
                 // For "sret" returns, we load from the temp alloca created earlier and return the loaded value instead
                 for (auto RetInst : Returns)
@@ -482,19 +470,6 @@ void LegalizeFunctionSignatures::FixFunctionBody(Module& M)
                     RetInst->eraseFromParent();
                 }
             }
-            else if (retTypeOption == ReturnOpt::RETURN_LEGAL_INT)
-            {
-                // Extend illegal int returns to legal type
-                for (auto RetInst : Returns)
-                {
-                    IGCLLVM::IRBuilder<> builder(RetInst);
-                    Value* retVal = RetInst->getReturnValue();
-                    Type* retTy = retVal->getType();
-                    retVal = builder.CreateZExt(retVal, LegalizedIntVectorType(M, retTy));
-                    builder.CreateRet(retVal);
-                    RetInst->eraseFromParent();
-                }
-            }
         }
 
         // Now that all instructions are transferred to the new func, delete the old func
@@ -558,7 +533,8 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
 {
     Function* calledFunc = callInst->getCalledFunction();
     SmallVector<Value*, 16> callArgs;
-    ReturnOpt retTypeOption = ReturnOpt::RETURN_DEFAULT;
+    bool legalizeReturnType = false;
+    bool promoteSRetType = false;
     bool fixArgType = false;
     bool isStackCall = !calledFunc || calledFunc->hasFnAttribute("visaStackCall");
 
@@ -577,7 +553,7 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
         isPromotableStructType(M, callInst->getArgOperand(0)->getType(), isStackCall, true /* retval */))
     {
         opNum++; // Skip the first call operand
-        retTypeOption = ReturnOpt::RETURN_STRUCT;
+        promoteSRetType = true;
     }
     else if (!isLegalSignatureType(M, callInst->getType(), isStackCall))
     {
@@ -590,11 +566,7 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
         ArgAttrs.addAttribute(llvm::Attribute::NoAlias);
         ArgAttrs.addStructRetAttr(callInst->getType());
         ArgAttrVec.push_back(AttributeSet::get(M.getContext(), ArgAttrs));
-        retTypeOption = ReturnOpt::RETURN_BY_REF;
-    }
-    else if (!isLegalIntVectorType(M, callInst->getType()))
-    {
-        retTypeOption = ReturnOpt::RETURN_LEGAL_INT;
+        legalizeReturnType = true;
     }
 
     // Check call operands if it needs to be replaced
@@ -640,7 +612,7 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
         }
     }
 
-    if (retTypeOption != ReturnOpt::RETURN_DEFAULT || fixArgType)
+    if (legalizeReturnType || promoteSRetType || fixArgType)
     {
         IGCLLVM::IRBuilder<> builder(callInst);
         Value* newCalledValue = nullptr;
@@ -653,10 +625,8 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
             {
                 argTypes.push_back(arg->getType());
             }
-            Type* retType =
-                retTypeOption == ReturnOpt::RETURN_BY_REF ? Type::getVoidTy(callInst->getContext()) :
-                retTypeOption == ReturnOpt::RETURN_STRUCT ? PromotedStructValueType(M, callInst->getArgOperand(0)->getType()) :
-                retTypeOption == ReturnOpt::RETURN_LEGAL_INT ? LegalizedIntVectorType(M, callInst->getType()) :
+            Type* retType = legalizeReturnType ? Type::getVoidTy(callInst->getContext()) :
+                promoteSRetType ? PromotedStructValueType(M, callInst->getArgOperand(0)->getType()) :
                 callInst->getType();
             newFnTy = FunctionType::get(retType, argTypes, false);
             Value* calledValue = IGCLLVM::getCalledValue(callInst);
@@ -676,24 +646,18 @@ void LegalizeFunctionSignatures::FixCallInstruction(Module& M, CallInst* callIns
         newCallInst->setAttributes(AttributeList::get(M.getContext(), IGCLLVM::getFnAttrs(PAL), IGCLLVM::getRetAttrs(PAL), ArgAttrVec));
         newCallInst->setDebugLoc(callInst->getDebugLoc());
 
-        if (retTypeOption == ReturnOpt::RETURN_BY_REF)
+        if (legalizeReturnType)
         {
             // Load the return value from the arg pointer before using it
             IGC_ASSERT(returnPtr);
             Value* load = builder.CreateLoad(returnPtr);
             callInst->replaceAllUsesWith(load);
         }
-        else if (retTypeOption == ReturnOpt::RETURN_STRUCT)
+        else if (promoteSRetType)
         {
             // Store the struct value into the orginal pointer operand
             StoreToStruct(builder, newCallInst, callInst->getArgOperand(0));
         }
-        else if (retTypeOption == ReturnOpt::RETURN_LEGAL_INT)
-        {
-            // Truncate legal type back into original value
-            Value* trunc = builder.CreateTrunc(newCallInst, callInst->getType());
-            callInst->replaceAllUsesWith(trunc);
-        }
         else
         {
             callInst->replaceAllUsesWith(newCallInst);

IGC/BiFModule/CMakeLists.txt

@@ -637,6 +637,7 @@ generate_bif_src_checksum(${IGC_BUILD__PROJ__BiFModule_OCL})
 generate_bif_prebuild_pack(${IGC_BUILD__PROJ__BiFModule_OCL} "${IGC_BUILD__PROJ_DEPENDS_BiFModule_OCL}")
 set(IGC_BUILD__PROJ__BiFModuleCache_OCL       "${IGC_BUILD__PROJ__BiFModuleCache_OCL}" PARENT_SCOPE)
 
+
 # =========================================== SPIRV Headers ============================================
 
 add_library(IGCSPIRVHeaders INTERFACE)

IGC/Compiler/CISACodeGen/CShader.cpp

@@ -107,7 +107,6 @@ void CShader::InitEncoder(SIMDMode simdSize, bool canAbortOnSpill, ShaderDispatc
     m_SavedSRetPtr = nullptr;
     m_ImplArgBufPtr = nullptr;
     m_LocalIdBufPtr = nullptr;
-    m_GlobalBufferArg = nullptr;
 
     // SIMD32 is a SIMD16 shader with 2 instance of each instruction
     m_SIMDSize = (simdSize == SIMDMode::SIMD8 ? SIMDMode::SIMD8 : SIMDMode::SIMD16);
@@ -319,12 +318,6 @@ void CShader::InitializeStackVariables()
         m_LocalIdBufPtr = GetNewVariable(1, ISA_TYPE_UQ, EALIGN_QWORD, true, 1, "LocalIdPtr");
         encoder.GetVISAPredefinedVar(m_LocalIdBufPtr, PREDEFINED_LOCAL_ID_BUF_PTR);
     }
-    // reserve a temp GRF for implicit arguments programmed by FE
-    if (m_ctx->m_DriverInfo.SupportGlobalStackArgs() &&
-        m_ctx->type != ShaderType::RAYTRACING_SHADER)
-    {
-        m_GlobalBufferArg = GetNewVariable(2, ISA_TYPE_UQ, EALIGN_QWORD, true, 1, "GlobalBufferArg");
-    }
 
     auto& argRegisterReservations = m_ctx->getModuleMetaData()->argRegisterReservations;
     m_ARGVReservedVariablesTotalSize = 0;
@@ -365,10 +358,9 @@ void CShader::RestoreStackState()
     // Restore FP to previous frame's FP
     encoder.Copy(m_FP, m_SavedFP);
     encoder.Push();
+
     // Reset temp variables
     m_SavedFP = nullptr;
-    m_GlobalBufferArg = nullptr;
-
     for (auto& arg : m_ARGVReservedVariables)
         arg = nullptr;
 }
@@ -1055,11 +1047,6 @@ CVariable* CShader::GetLocalIdBufPtr()
     return m_LocalIdBufPtr;
 }
 
-CVariable* CShader::GetGlobalBufferArg()
-{
-    return m_GlobalBufferArg;
-}
-
 CVariable* CShader::GetFP()
 {
     IGC_ASSERT(m_FP);

IGC/Compiler/CISACodeGen/DriverInfo.hpp

@@ -205,9 +205,6 @@ namespace IGC
         /// support predicate add pattern match
         virtual bool SupportMatchPredAdd() const { return false; }
 
-        /// Support passing globally accessed pointers implicitly to callees using argument registers
-        virtual bool SupportGlobalStackArgs() const { return false; }
-
         /// Adjust adapter to adjust the loop unrolling threshold
         virtual unsigned int GetLoopUnrollThreshold() const
         {