Multirate shading improvements and fixes

Fixed bug where r1 would be overwritten in the perpixel phase of a
 multirate shader
Fixed bug where the perpixel phase of a multirate shader was treated
 as the entry function
Fixed bug where the PixelShaderAddMask pass would be run on the
 perpixel phase of a multirate shader more than once
Fixed bug where phi nodes were added to a basic block with only one
 predecessor
Fixed bug where PurgeMetaDataUtils deleted the coarse phase when
 compiling the perpixel phase.
Allowed phase inputs and outputs to use all floating point types

Change-Id: I8079552c08efea31cc8d6ed1cc6207b06c37b66f

Author: davidjwoo

IGC/Compiler/CISACodeGen/CMakeLists.txt

@@ -83,6 +83,7 @@ set(IGC_BUILD__SRC__CISACodeGen_Common
     "${CMAKE_CURRENT_SOURCE_DIR}/WIAnalysis.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/SLMConstProp.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/POSH_RemoveNonPositionOutput.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/CrossPhaseConstProp.cpp"
   )
 
 
@@ -173,6 +174,7 @@ set(IGC_BUILD__HDR__CISACodeGen_Common
     "${CMAKE_CURRENT_SOURCE_DIR}/WIAnalysis.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/SLMConstProp.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/POSH_RemoveNonPositionOutput.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/CrossPhaseConstProp.hpp"
   )
 
 

IGC/Compiler/CISACodeGen/CShader.cpp

@@ -335,7 +335,7 @@ void CShader::CreateImplicitArgs()
 
     // Push Args are only for entry function
     unsigned numPushArgsEntry = m_ModuleMetadata->pushInfo.pushAnalysisWIInfos.size();
-    unsigned numPushArgs = (isEntryFunc(m_pMdUtils, entry) ? numPushArgsEntry : 0);
+    unsigned numPushArgs = (isEntryFunc(m_pMdUtils, entry) && !isPixelPhaseFunction(entry) ? numPushArgsEntry : 0);
     unsigned numFuncArgs = IGCLLVM::GetFuncArgSize(entry) - numImplicitArgs - numPushArgs;
 
     // Create symbol for every arguments [5/2019]
@@ -2072,7 +2072,7 @@ CVariable* CShader::getOrCreateArgumentSymbol(
     ImplicitArgs implicitArgs(*F, m_pMdUtils);
     unsigned numImplicitArgs = implicitArgs.size();
     unsigned numPushArgsEntry = m_ModuleMetadata->pushInfo.pushAnalysisWIInfos.size();
-    unsigned numPushArgs = (isEntryFunc(m_pMdUtils, F) ? numPushArgsEntry : 0);
+    unsigned numPushArgs = (isEntryFunc(m_pMdUtils, F) && !isPixelPhaseFunction(F) ? numPushArgsEntry : 0);
     unsigned numFuncArgs = IGCLLVM::GetFuncArgSize(F) - numImplicitArgs - numPushArgs;
 
     CVariable* var = nullptr;
@@ -2107,7 +2107,7 @@ CVariable* CShader::getOrCreateArgumentSymbol(
                 uint32_t nIAs = (uint32_t)IAs.size();
                 uint32_t iArgIx = IAs.getArgIndex(ArgType);
                 uint32_t argIx = (uint32_t)IGCLLVM::GetFuncArgSize(K) - nIAs + iArgIx;
-                if (isEntryFunc(m_pMdUtils, &K)) {
+                if (isEntryFunc(m_pMdUtils, &K) && !isPixelPhaseFunction(&K)) {
                     argIx = argIx - numPushArgsEntry;
                 }
                 Function::arg_iterator arg = K.arg_begin();

IGC/Compiler/CISACodeGen/CrossPhaseConstProp.cpp

@@ -0,0 +1,129 @@
+/*===================== begin_copyright_notice ==================================
+
+Copyright (c) 2017 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+======================= end_copyright_notice ==================================*/
+
+#include "Compiler/CISACodeGen/CrossPhaseConstProp.hpp"
+#include "LLVMWarningsPush.hpp"
+#include "llvm/Pass.h"
+#include "LLVMWarningsPop.hpp"
+#include "Compiler/CISACodeGen/PixelShaderCodeGen.hpp"
+#include "Compiler/CISACodeGen/helper.h"
+#include "Compiler/MetaDataUtilsWrapper.h"
+using namespace llvm;
+namespace
+{
+    class CrossPhaseConstProp : public FunctionPass
+    {
+    public:
+        static char ID; // Pass identification, replacement for typeid
+
+        CrossPhaseConstProp(IGC::PSSignature* signature=nullptr);
+
+        bool runOnFunction(Function& F) override;
+
+        void getAnalysisUsage(AnalysisUsage& AU) const override
+        {
+            AU.addRequired<IGC::MetaDataUtilsWrapper>();
+            AU.setPreservesCFG();
+        }
+    private:
+        IGC::PSSignature* m_signature;
+    };
+}  // namespace
+
+
+#define PASS_FLAG "igc-crossphaseconstprop"
+#define PASS_DESCRIPTION "Special const prop for multirate shading"
+#define PASS_CFG_ONLY false
+#define PASS_ANALYSIS false
+IGC_INITIALIZE_PASS_BEGIN(CrossPhaseConstProp, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
+IGC_INITIALIZE_PASS_DEPENDENCY(MetaDataUtilsWrapper)
+IGC_INITIALIZE_PASS_END(CrossPhaseConstProp, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
+
+CrossPhaseConstProp::CrossPhaseConstProp(IGC::PSSignature* signature) : FunctionPass(ID), m_signature(signature)
+{
+    initializeCrossPhaseConstPropPass(*PassRegistry::getPassRegistry());
+}
+
+char CrossPhaseConstProp::ID = 0;
+
+FunctionPass* IGC::createCrossPhaseConstPropPass(IGC::PSSignature* signature)
+{
+    return new CrossPhaseConstProp(signature);
+}
+
+bool CrossPhaseConstProp::runOnFunction(Function& F)
+{
+    IGC::IGCMD::MetaDataUtils* pMdUtils = getAnalysis<IGC::MetaDataUtilsWrapper>().getMetaDataUtils();
+    if (!IGC::isEntryFunc(pMdUtils, &F) || m_signature == nullptr)
+    {
+        return false;
+    }
+
+    std::vector<Instruction*> instructionsToRemove;
+    bool isCoarse = IGC::isCoarsePhaseFunction(&F);
+    bool isPerPixel = IGC::isPixelPhaseFunction(&F);
+    if (isCoarse || isPerPixel)
+    {
+        for (auto& BB : F)
+        {
+            for (auto& I : BB)
+            {
+                if (GenIntrinsicInst * inst = dyn_cast<GenIntrinsicInst>(&I))
+                {
+                    GenISAIntrinsic::ID IID = inst->getIntrinsicID();
+                    if (isPerPixel && IID == GenISAIntrinsic::GenISA_PHASE_INPUT)
+                    {
+                        unsigned int index = (unsigned int)cast<llvm::ConstantInt>(inst->getOperand(0))->getZExtValue();
+                        auto constantOutput = m_signature->PSConstantOutput.find(index);
+                        if (constantOutput != m_signature->PSConstantOutput.end())
+                        {
+                            inst->replaceAllUsesWith(
+                                ConstantFP::get(inst->getType(),
+                                    APFloat(inst->getType()->getFltSemantics(), APInt(inst->getType()->getScalarSizeInBits(), constantOutput->second))));
+                            instructionsToRemove.push_back(inst);
+                        }
+                    }
+                    else if (isCoarse && IID == GenISAIntrinsic::GenISA_PHASE_OUTPUT)
+                    {
+                        if (auto fpValue = dyn_cast<ConstantFP>(inst->getArgOperand(0)))
+                        {
+                            unsigned int index = (unsigned int)cast<llvm::ConstantInt>(inst->getArgOperand(1))->getZExtValue();
+                            m_signature->PSConstantOutput[index] = fpValue->getValueAPF().bitcastToAPInt().getLimitedValue();
+                            instructionsToRemove.push_back(inst);
+                        }
+                    }
+                }
+            }
+        }
+
+        for (auto inst : instructionsToRemove)
+        {
+            inst->eraseFromParent();
+        }
+    }
+
+    return instructionsToRemove.size() > 0;
+}

IGC/Compiler/CISACodeGen/CrossPhaseConstProp.hpp

@@ -0,0 +1,38 @@
+/*===================== begin_copyright_notice ==================================
+
+Copyright (c) 2017 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+======================= end_copyright_notice ==================================*/
+
+#pragma once
+
+namespace llvm
+{
+    class FunctionPass;
+}
+
+namespace IGC
+{
+    struct PSSignature;
+    llvm::FunctionPass* createCrossPhaseConstPropPass(PSSignature* signature);
+}  // namespace IGC

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -7017,7 +7017,8 @@ void EmitPass::getCoarsePixelSize(CVariable* destination, const uint component)
     assert(component < 2);
 
     CPixelShader* const psProgram = static_cast<CPixelShader*>(m_currShader);
-    CVariable* const coarsePixelSize = m_currShader->BitCast(psProgram->GetR1(), ISA_TYPE_UB);
+    CVariable* r1 = psProgram->GetPhase() == PSPHASE_PIXEL ? psProgram->GetCoarseR1() : psProgram->GetR1();
+    CVariable* const coarsePixelSize = m_currShader->BitCast(r1, ISA_TYPE_UB);
     m_encoder->SetSrcRegion(0, 0, 1, 0);
     m_encoder->SetSrcSubReg(0, (component == 0) ? 0 : 1);
     m_encoder->Cast(destination, coarsePixelSize);
@@ -13103,7 +13104,7 @@ void EmitPass::emitPhaseInput(llvm::GenIntrinsicInst* inst)
     assert(psProgram->GetPhase() == PSPHASE_PIXEL);
 
     unsigned int inputIndex = (unsigned int)cast<llvm::ConstantInt>(inst->getOperand(0))->getZExtValue();
-    CVariable* input = psProgram->GetCoarseInput(inputIndex);
+    CVariable* input = psProgram->GetCoarseInput(inputIndex, m_destination->GetType());
 
     // address variable represents register a0
     CVariable* pDstArrElm = m_currShader->GetNewAddressVariable(
@@ -13115,7 +13116,8 @@ void EmitPass::emitPhaseInput(llvm::GenIntrinsicInst* inst)
     // we add offsets to the base that is the beginning of the vector variable
     CVariable* index = psProgram->GetCoarseParentIndex();
     CVariable* byteAddress = psProgram->GetNewVariable(numLanes(m_SimdMode), ISA_TYPE_UW, EALIGN_OWORD);
-    m_encoder->Shl(byteAddress, index, psProgram->ImmToVariable(2, ISA_TYPE_UW));
+    DWORD shiftAmount = iSTD::Log2(CEncoder::GetCISADataTypeSize(input->GetType()));
+    m_encoder->Shl(byteAddress, index, psProgram->ImmToVariable(shiftAmount, ISA_TYPE_UW));
     m_encoder->Push();
 
     m_encoder->AddrAdd(pDstArrElm, input, byteAddress);

IGC/Compiler/CISACodeGen/PixelShaderCodeGen.cpp

@@ -52,6 +52,12 @@ namespace IGC
         return m_R1;
     }
 
+    CVariable* CPixelShader::GetCoarseR1()
+    {
+        assert(m_phase == PSPHASE_PIXEL);
+        return m_CoarseR1;
+    }
+
     void CPixelShader::AllocatePayload()
     {
         if (m_phase == PSPHASE_COARSE)
@@ -74,6 +80,8 @@ namespace IGC
 
     void CPixelShader::AllocatePixelPhasePayload()
     {
+        unsigned int r1Offset = GetDispatchSignature().r1;
+        AllocateInput(m_CoarseR1, r1Offset);
         for (uint i = 0; i < setup.size(); i++)
         {
             if (setup[i])
@@ -126,6 +134,10 @@ namespace IGC
         offset += getGRFSize();
 
         assert(m_R1);
+        if (m_Signature)
+        {
+            GetDispatchSignature().r1 = offset;
+        }
         for (uint i = 0; i < m_R1->GetNumberInstance(); i++)
         {
             AllocateInput(m_R1, offset, i);
@@ -651,6 +663,7 @@ namespace IGC
         m_NeedPSSync = false;
         m_CoarseoMask = nullptr;
         m_CoarseMaskInput = nullptr;
+        m_CoarseR1 = nullptr;
 
         m_CoarseOutput.clear();
         m_CoarseInput.clear();
@@ -980,6 +993,7 @@ namespace IGC
         if (m_phase == PSPHASE_PIXEL)
         {
             uint responseLength = 2;
+            m_CoarseR1 = m_R1;
             m_PixelPhasePayload = GetNewVariable(responseLength * (getGRFSize() >> 2), ISA_TYPE_D, EALIGN_GRF);
             m_PixelPhaseCounter = GetNewAlias(m_PixelPhasePayload, ISA_TYPE_UW, 0, 1);
             m_CoarseParentIndex = GetNewAlias(m_PixelPhasePayload, ISA_TYPE_UW, getGRFSize(), numLanes(m_SIMDSize));
@@ -1015,7 +1029,6 @@ namespace IGC
                 encoder.Push();
             }
             encoder.SetPredicate(m_KillPixelMask);
-            encoder.SetInversePredicate(true);
             encoder.Copy(m_CoarseoMask, ImmToVariable(0x0, ISA_TYPE_UD));
             encoder.Push();
         }
@@ -1044,13 +1057,13 @@ namespace IGC
         m_CoarseOutput[index] = output;
     }
 
-    CVariable* CPixelShader::GetCoarseInput(unsigned int index)
+    CVariable* CPixelShader::GetCoarseInput(unsigned int index, VISA_Type type)
     {
         auto it = m_CoarseInput.find(index);
         CVariable* coarseInput = nullptr;
         if (it == m_CoarseInput.end())
         {
-            coarseInput = GetNewVariable(numLanes(m_SIMDSize), ISA_TYPE_F, EALIGN_GRF);
+            coarseInput = GetNewVariable(numLanes(m_SIMDSize), type, EALIGN_GRF);
             m_CoarseInput[index] = coarseInput;
         }
         else
@@ -1362,6 +1375,7 @@ namespace IGC
             // if there is no pixel phase we have nothing to do
             return;
         }
+        encoder.MarkAsOutput(m_R1);
         Function* pixelPhase = mdconst::dyn_extract<Function>(pixelNode->getOperand(0)->getOperand(0));
         for (auto BB = pixelPhase->begin(), BE = pixelPhase->end(); BB != BE; ++BB)
         {

IGC/Compiler/CISACodeGen/PixelShaderCodeGen.hpp

@@ -39,10 +39,12 @@ namespace IGC
             unsigned int              pixelOffset;
             unsigned int              ZWDelta;
             unsigned int              oMaskOffset;
+            unsigned int              r1;
             bool                      CoarseMask;
             DispatchSignature() : CoarseMask(false) {}
         };
         DispatchSignature dispatchSign[3];
+        std::map<unsigned int, uint64_t> PSConstantOutput;
     };
 
 
@@ -52,6 +54,7 @@ namespace IGC
         CPixelShader(llvm::Function* pFunc, CShaderProgram* pProgram);
         ~CPixelShader();
         CVariable* GetR1();
+        CVariable* GetCoarseR1();
         CVariable* GetBaryReg(e_interpolation mode);
         CVariable* GetBaryRegLowered(e_interpolation mode);
         CVariable* GetInputDelta(uint index, bool loweredInput = false);
@@ -91,7 +94,7 @@ namespace IGC
         void        PullPixelPhasePayload();
 
         void        AddCoarseOutput(CVariable* var, unsigned int index);
-        CVariable* GetCoarseInput(unsigned int index);
+        CVariable* GetCoarseInput(unsigned int index, VISA_Type type);
         void        SetCoarseoMask(CVariable* var);
         CVariable* GetCoarseMask();
         void        OutputDepth() { m_HasoDepth = true; };
@@ -128,6 +131,7 @@ namespace IGC
 
         PSSignature::DispatchSignature& GetDispatchSignature();
         CVariable* m_R1;
+        CVariable* m_CoarseR1;
         CVariable* m_PerspectivePixel;
         CVariable* m_PerspectiveCentroid;
         CVariable* m_PerspectiveSample;