Supporting vector types in constant folding

Few refactoring related to moving functions that are used in multiple
passes into helper.cpp/.h
Added support for vector type in constant folding and in finding
interesting constants

Change-Id: I4ebf93c3c508eec79429e7f4bc916d39f0c57d16

Author: srividyakarumuri

IGC/Compiler/CISACodeGen/helper.cpp

@@ -344,13 +344,15 @@ namespace IGC
                 instList.push_back(baseValue);
             }
 
-            unsigned bufId = 0;
-            IGC::BufferType bufTy = BUFFER_TYPE_UNKNOWN;
-            IGC::BufferAccessType accessTy = BUFFER_ACCESS_TYPE_UNKNOWN;
-            if (GetResourcePointerInfo(baseValue, bufId, bufTy, accessTy))
+            if (GenIntrinsicInst * inst = dyn_cast<GenIntrinsicInst>(baseValue))
             {
-                srcPtr = baseValue;
-                break;
+                // For bindless pointers
+                if ((inst->getIntrinsicID() == GenISAIntrinsic::GenISA_RuntimeValue) ||
+                    (inst->getIntrinsicID() == GenISAIntrinsic::GenISA_GetBufferPtr))
+                {
+                    srcPtr = baseValue;
+                    break;
+                }
             }
             else if (isa<Argument>(baseValue))
             {
@@ -539,6 +541,106 @@ namespace IGC
         return false;
     }
 
+    // Get GRF offset from GenISA_RuntimeValue intrinsic call
+    bool GetGRFOffsetFromRTV(Value* pointerSrc, unsigned& GRFOffset)
+    {
+        if (GenIntrinsicInst * inst = dyn_cast<GenIntrinsicInst>(pointerSrc))
+        {
+            // For bindless pointers with encoded metadata
+            if (inst->getIntrinsicID() == GenISAIntrinsic::GenISA_RuntimeValue)
+            {
+                GRFOffset = (unsigned)llvm::cast<llvm::ConstantInt>(inst->getOperand(0))->getZExtValue();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool GetStatelessBufferInfo(Value* pointer, unsigned& bufIdOrGRFOffset,
+            BufferType & bufferTy, Value*& bufferSrcPtr, bool& isDirectBuf)
+    {
+        isDirectBuf = false;
+        // If the buffer info is not encoded in the address space, we can still find it by
+        // tracing the pointer to where it's created.
+        Value * src = IGC::TracePointerSource(pointer);
+        BufferAccessType accType;
+        if (!src)   return false;
+        if (IGC::GetResourcePointerInfo(src, bufIdOrGRFOffset, bufferTy, accType))
+        {
+            bufferSrcPtr = src;
+            isDirectBuf = true;
+            return true;
+        }
+        else if (GetGRFOffsetFromRTV(src, bufIdOrGRFOffset))
+        {
+            bufferSrcPtr = src;
+            bufferTy = BUFFER_TYPE_UNKNOWN;
+            return true;
+        }
+        return false;
+    }
+
+    bool EvalConstantAddress(Value* address, unsigned int& offset, const llvm::DataLayout* pDL, Value* ptrSrc)
+    {
+        if ((ptrSrc == nullptr && isa<ConstantPointerNull>(address)) ||
+            (ptrSrc == address))
+        {
+            offset = 0;
+            return true;
+        }
+        else if (Instruction * ptrExpr = dyn_cast<Instruction>(address))
+        {
+            if (ptrExpr->getOpcode() == Instruction::BitCast ||
+                ptrExpr->getOpcode() == Instruction::AddrSpaceCast)
+            {
+                return EvalConstantAddress(ptrExpr->getOperand(0), offset, pDL, ptrSrc);
+            }
+            if (ptrExpr->getOpcode() == Instruction::IntToPtr)
+            {
+                Value * eltIdxVal = ptrExpr->getOperand(0);
+                ConstantInt * eltIdx = dyn_cast<ConstantInt>(eltIdxVal);
+                if (!eltIdx)
+                    return false;
+                offset = int_cast<unsigned>(eltIdx->getZExtValue());
+                return true;
+            }
+            else if (ptrExpr->getOpcode() == Instruction::GetElementPtr)
+            {
+                offset = 0;
+                if (!EvalConstantAddress(ptrExpr->getOperand(0), offset, pDL, ptrSrc))
+                {
+                    return false;
+                }
+                Type * Ty = ptrExpr->getType();
+                gep_type_iterator GTI = gep_type_begin(ptrExpr);
+                for (auto OI = ptrExpr->op_begin() + 1, E = ptrExpr->op_end(); OI != E; ++OI, ++GTI) {
+                    Value * Idx = *OI;
+                    if (StructType * StTy = GTI.getStructTypeOrNull()) {
+                        unsigned Field = int_cast<unsigned>(cast<ConstantInt>(Idx)->getZExtValue());
+                        if (Field) {
+                            offset += int_cast<unsigned int>(pDL->getStructLayout(StTy)->getElementOffset(Field));
+                        }
+                        Ty = StTy->getElementType(Field);
+                    }
+                    else {
+                        Ty = GTI.getIndexedType();
+                        if (const ConstantInt * CI = dyn_cast<ConstantInt>(Idx)) {
+                            offset += int_cast<unsigned int>(
+                            pDL->getTypeAllocSize(Ty) * CI->getSExtValue());
+
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
     ///
     /// Wrapper method for changing PTRType for PromoteToBindless Pass.
     /// Replaces oldPtr with newPtr in a sample/ld intrinsic's argument list. The new instrinsic will

IGC/Compiler/CISACodeGen/helper.h

@@ -152,8 +152,12 @@ namespace IGC
     llvm::Value* TracePointerSource(llvm::Value* resourcePtr);
     llvm::Value* TracePointerSource(llvm::Value* resourcePtr, bool hasBranching, bool fillList, std::vector<llvm::Value*>& instList);
     llvm::Value* TracePointerSource(llvm::Value* resourcePtr, bool hasBranching, bool fillList, std::vector<llvm::Value*>& instList, llvm::SmallSet<llvm::PHINode*, 8> & visitedPHIs);
-    bool GetResourcePointerInfo(llvm::Value* srcPtr, unsigned& resID,
-        IGC::BufferType& resTy, IGC::BufferAccessType& accessTy);
+    bool GetResourcePointerInfo(llvm::Value* srcPtr, unsigned& resID, IGC::BufferType& resTy, IGC::BufferAccessType& accessTy);
+    bool GetGRFOffsetFromRTV(llvm::Value* pointerSrc, unsigned& GRFOffset);
+    bool GetStatelessBufferInfo(llvm::Value* pointer, unsigned& bufIdOrGRFOffset, IGC::BufferType& bufferTy, llvm::Value*& bufferSrcPtr, bool& isDirectBuf);
+    // try to evaluate the address if it is constant.
+    bool EvalConstantAddress(llvm::Value* address, unsigned int& offset, const llvm::DataLayout* pDL, llvm::Value* ptrSrc = nullptr);
+
 
     bool isSampleLoadGather4InfoInstruction(llvm::Instruction* inst);
     bool isSampleInstruction(llvm::Instruction* inst);

IGC/Compiler/CustomSafeOptPass.cpp

@@ -2096,107 +2096,81 @@ static Constant* GetConstantValue(Type* type, char* rawData)
     return nullptr;
 }
 
-bool IGCConstProp::EvalConstantAddress(Value* address, unsigned int& offset, Value* ptrSrc)
+Constant* IGCConstProp::ReplaceFromDynConstants(unsigned bufId, unsigned eltId, unsigned int size_in_bytes, LoadInst* inst)
 {
-    if ((ptrSrc == nullptr && isa<ConstantPointerNull>(address)) ||
-        (ptrSrc == address))
-    {
-        offset = 0;
-        return true;
-    }
-    else if (Instruction * ptrExpr = dyn_cast<Instruction>(address))
+    Type* type = inst->getType();
+
+    CodeGenContext* ctx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
+    ModuleMetaData* modMD = ctx->getModuleMetaData();
+
+    // Handling for base types (Integer/FloatingPoint)
+    if (!(type->isVectorTy()))
     {
-        if (ptrExpr->getOpcode() == Instruction::BitCast ||
-            ptrExpr->getOpcode() == Instruction::AddrSpaceCast)
-        {
-            return EvalConstantAddress(ptrExpr->getOperand(0), offset, ptrSrc);
-        }
-        if (ptrExpr->getOpcode() == Instruction::IntToPtr)
-        {
-            Value* eltIdxVal = ptrExpr->getOperand(0);
-            ConstantInt* eltIdx = dyn_cast<ConstantInt>(eltIdxVal);
-            if (!eltIdx)
-                return false;
-            offset = int_cast<unsigned>(eltIdx->getZExtValue());
-            return true;
-        }
-        else if (ptrExpr->getOpcode() == Instruction::GetElementPtr)
+        ConstantAddress cl;
+        cl.bufId = bufId;
+        cl.eltId = eltId;
+        cl.size = size_in_bytes;
+
+        // Inline the constants for constant buffer accesses of size <= 32bit only.
+        if (size_in_bytes > 4)
+            return nullptr;
+
+        auto it = modMD->inlineDynConstants.find(cl);
+        if (it != modMD->inlineDynConstants.end() && (it->first.size == cl.size))
         {
-            offset = 0;
-            if (!EvalConstantAddress(ptrExpr->getOperand(0), offset, ptrSrc))
-            {
-                return false;
-            }
-            Type* Ty = ptrExpr->getType();
-            gep_type_iterator GTI = gep_type_begin(ptrExpr);
-            for (auto OI = ptrExpr->op_begin() + 1, E = ptrExpr->op_end(); OI != E; ++OI, ++GTI) {
-                Value* Idx = *OI;
-                if (StructType * StTy = GTI.getStructTypeOrNull()) {
-                    unsigned Field = int_cast<unsigned>(cast<ConstantInt>(Idx)->getZExtValue());
-                    if (Field) {
-                        offset += int_cast<unsigned int>(m_TD->getStructLayout(StTy)->getElementOffset(Field));
-                    }
-                    Ty = StTy->getElementType(Field);
-                }
-                else {
-                    Ty = GTI.getIndexedType();
-                    if (const ConstantInt * CI = dyn_cast<ConstantInt>(Idx)) {
-                        offset += int_cast<unsigned int>(
-                            m_TD->getTypeAllocSize(Ty) * CI->getSExtValue());
-                    }
-                    else
-                    {
-                        return false;
-                    }
-                }
-            }
-            return true;
+            // This constant is
+            //          found in the Dynamic inline constants list, and
+            //          sizes match (find only looking for bufId and eltId, so need to compare size field explicitly)
+            char* pConstVal;
+            pConstVal = (char*)(&(it->second));
+            return GetConstantValue(type, pConstVal);
         }
     }
-    return false;
-}
-
-bool GetStatelessBufferInfo(Value* pointer, unsigned& bufferId,
-    BufferType& bufferTy, Value*& bufferSrcPtr)
-{
-    // If the buffer info is not encoded in the address space, we can still find it by
-    // tracing the pointer to where it's created.
-    Value* src = IGC::TracePointerSource(pointer);
-    BufferAccessType accType;
-    if (src && IGC::GetResourcePointerInfo(src, bufferId, bufferTy, accType))
+    else
     {
-        bufferSrcPtr = src;
-        return true;
-    }
-    return false;
-}
+        Type * srcEltTy = type->getVectorElementType();
+        uint32_t srcNElts = type->getVectorNumElements();
+        uint32_t eltSize_in_bytes = srcEltTy->getPrimitiveSizeInBits() / 8;
+        std::vector<uint32_t> constValVec;
 
-Constant* IGCConstProp::ReplaceFromDynConstants(unsigned bufId, unsigned eltId, unsigned int size_in_bytes, Type* type)
-{
-    ConstantAddress cl;
-    char* pConstVal;
-    cl.bufId = bufId;
-    cl.eltId = eltId;
-    cl.size = size_in_bytes;
+        if (eltSize_in_bytes > 4)
+            return nullptr;
 
-    CodeGenContext* ctx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
-    ModuleMetaData* modMD = ctx->getModuleMetaData();
+        // First make sure all elements of vector are available in the dynamic inline constants
+        //    If not, we cannot inline the vector
+        for (uint i = 0; i < srcNElts; i++)
+        {
+            ConstantAddress cl;
+            cl.bufId = bufId;
+            cl.eltId = eltId + (i * eltSize_in_bytes);
+            cl.size = eltSize_in_bytes;
 
-    auto it = modMD->inlineDynConstants.find(cl);
-    if ((it != modMD->inlineDynConstants.end()) && (it->first.size == cl.size))
-    {
-        // For constant buffer accesses of size <= 32bit.
-        if (size_in_bytes <= 4)
+            auto it = modMD->inlineDynConstants.find(cl);
+            if (it != modMD->inlineDynConstants.end() && (it->first.size == cl.size))
+            {
+                constValVec.push_back(it->second);
+            }
+            else
+            {
+                // All elements of the vector has to be available for inlining,
+                //     otherwise we cannot replace the load instruction, hence return nullptr
+                return nullptr;
+            }
+        }
+        if (constValVec.size() == srcNElts)
         {
-            // This constant is
-            //          found in the Dynamic inline constants list, and
-            //          sizes match (find only looking for bufId and eltId, so need to look for size explicitly)
-            if (!(type->isVectorTy()))
+            IRBuilder<> builder(inst);
+            Value * vectorValue = UndefValue::get(inst->getType());
+            for (uint i = 0; i < srcNElts; i++)
             {
-                // Handling for base types (Integer/FloatingPoint)
-                pConstVal = (char*)(&(it->second));
-                return GetConstantValue(type, pConstVal);
+                char* pConstVal;
+                pConstVal = (char*)(&(constValVec[i]));
+                vectorValue = builder.CreateInsertElement(
+                vectorValue,
+                GetConstantValue(srcEltTy, pConstVal),
+                builder.getInt32(i));
             }
+            return dyn_cast<Constant>(vectorValue);
         }
     }
     return nullptr;
@@ -2206,7 +2180,8 @@ Constant* IGCConstProp::replaceShaderConstant(LoadInst* inst)
 {
     unsigned as = inst->getPointerAddressSpace();
     bool directBuf = false;
-    unsigned bufId = 0;
+    bool statelessBuf = false;
+    unsigned bufIdOrGRFOffset = 0;
     unsigned int size_in_bytes = 0;
     CodeGenContext* ctx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
     ModuleMetaData* modMD = ctx->getModuleMetaData();
@@ -2216,32 +2191,47 @@ Constant* IGCConstProp::replaceShaderConstant(LoadInst* inst)
 
     if (as == ADDRESS_SPACE_CONSTANT)
     {
-        if (!GetStatelessBufferInfo(inst->getPointerOperand(), bufId, bufType, pointerSrc))
+        if (!GetStatelessBufferInfo(inst->getPointerOperand(), bufIdOrGRFOffset, bufType, pointerSrc, directBuf))
         {
             return nullptr;
         }
-        directBuf = true;
+        if (!directBuf)
+        {
+            // Make sure constant folding is safe by looking up in pushableAddresses
+            CodeGenContext* ctx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
+            PushInfo& pushInfo = ctx->getModuleMetaData()->pushInfo;
+
+            for (auto it : pushInfo.pushableAddresses)
+            {
+                if (bufIdOrGRFOffset * 4 == it.addressOffset && it.isStatic)
+                {
+                    statelessBuf = true;
+                    break;
+                }
+            }
+        }
     }
     else
     {
-        bufType = IGC::DecodeAS4GFXResource(as, directBuf, bufId);
+        bufType = IGC::DecodeAS4GFXResource(as, directBuf, bufIdOrGRFOffset);
     }
 
-    if (bufType == CONSTANT_BUFFER &&
-        directBuf && modMD)
+    // If it is statelessBuf, we made sure it is a constant buffer by finding it in pushableAddresses
+    if (modMD && ((directBuf && (bufType == CONSTANT_BUFFER)) || statelessBuf))
     {
         Value* ptrVal = inst->getPointerOperand();
         unsigned eltId = 0;
         size_in_bytes = inst->getType()->getPrimitiveSizeInBits() / 8;
-        if (!EvalConstantAddress(ptrVal, eltId, pointerSrc))
+        if (!EvalConstantAddress(ptrVal, eltId, m_TD, pointerSrc))
         {
             return nullptr;
         }
 
         if (size_in_bytes)
         {
             if (modMD->immConstant.data.size() &&
-                (bufId == modMD->pushInfo.inlineConstantBufferSlot))
+                ((statelessBuf && (bufIdOrGRFOffset == modMD->pushInfo.inlineConstantBufferGRFOffset))||
+                (directBuf && (bufIdOrGRFOffset == modMD->pushInfo.inlineConstantBufferSlot))))
             {
                 char* offset = &(modMD->immConstant.data[0]);
                 if (inst->getType()->isVectorTy())
@@ -2267,7 +2257,7 @@ Constant* IGCConstProp::replaceShaderConstant(LoadInst* inst)
             }
             else if ((!IGC_IS_FLAG_ENABLED(DisableDynamicConstantFolding)) && (modMD->inlineDynConstants.size() > 0))
             {
-                return ReplaceFromDynConstants(bufId, eltId, size_in_bytes, inst->getType());
+                return ReplaceFromDynConstants(bufIdOrGRFOffset, eltId, size_in_bytes, inst);
             }
         }
     }