/*========================== begin_copyright_notice ============================

Copyright (C) 2017-2023 Intel Corporation

SPDX-License-Identifier: MIT

============================= end_copyright_notice ===========================*/

#pragma once

#include "Compiler/CISACodeGen/WIAnalysis.hpp"
#include "Compiler/CISACodeGen/ResourceLoopAnalysis.h"
#include "Compiler/CISACodeGen/PatternMatchPass.hpp"
#include "Compiler/MetaDataUtilsWrapper.h"
#include "Compiler/CISACodeGen/PayloadMapping.hpp"
#include "common/LLVMWarningsPush.hpp"
#include <llvm/Pass.h>
#include <llvm/ADT/DenseSet.h>
#include <llvm/IR/InstVisitor.h>
#include <llvm/IR/Dominators.h>
#include <llvm/Support/Debug.h>
#include <llvm/Support/Allocator.h>
#include "common/LLVMWarningsPop.hpp"
#include "GenISAIntrinsics/GenIntrinsicInst.h"
#include "Probe/Assertion.h"

namespace IGC {

    class CEncoder;
    class CVariable;
    class CodeGenContextWrapper;
    class DeSSA;


    class CoalescingEngine : public llvm::FunctionPass, public llvm::InstVisitor<CoalescingEngine>
    {
        //TODO: this is fixed for now, but once we have pressure heuristic, could be relaxed
        static const int MaxTouchedTuples = 8;
        static const int MaxTupleSize = MaxTouchedTuples + 4;

    public:
        static char ID; // Pass identification, replacement for typeid
        CoalescingEngine();

        virtual void getAnalysisUsage(llvm::AnalysisUsage& AU) const override;

        virtual void releaseMemory() override {
            Allocator.Reset();

            for (auto itr = m_CCTupleList.begin(),
                iend = m_CCTupleList.end();
                itr != iend; ++itr)
            {
                CCTuple* ccTuple = *itr;
                delete ccTuple;
            }
            m_CCTupleList.clear();
            //Nodes need not be deallocated since they are
            //owned by bump allocator (Allocator), and are destroyed
            //once bump allocator goes out the the scope.
            NodeCCTupleMap.clear();
            ValueNodeMap.clear();
            BBProcessingDefs.clear();
            NodeOffsetMap.clear();
        }

        bool runOnFunction(llvm::Function&) override;

        virtual llvm::StringRef getPassName() const override {
            return "CoalescingEngine";
        }

        /// print - print partitions in human readable form
        void print(llvm::raw_ostream& OS, const llvm::Module* = 0) const override;

        /// dump - Dump the partitions to dbgs().
        void dump() const;

        void ProcessBlock(llvm::BasicBlock* bb);

        //
        bool MatchSingleInstruction(llvm::GenIntrinsicInst* I);


        int GetSingleElementWidth(
            SIMDMode simdMode,
            const llvm::DataLayout* pDL,
            llvm::Value* val)
        {
            int result = 0;
            int mult = 1;
            if (val->getType()->isHalfTy() && simdMode == SIMDMode::SIMD8)
            {
                mult = 2;
            }

            result = int_cast<int>(mult *
                numLanes(simdMode) *
                pDL->getTypeAllocSize(val->getType()));

            return result;
        }

        //
        CVariable* PrepareExplicitPayload(
            CShader* outProgram,
            CEncoder* encoder,
            SIMDMode simdMode,
            const llvm::DataLayout* pDL,
            llvm::Instruction* inst,
            int& payloadOffset);


        CVariable* PrepareUniformUrbWritePayload(
            CShader* shader,
            CEncoder* encoder,
            llvm::GenIntrinsicInst* inst);

        CVariable* PrepareSplitUrbWritePayload(
            CShader* outProgram,
            CEncoder* encoder,
            SIMDMode simdMode,
            uint32_t splitPartNo,
            llvm::Instruction* inst);

        void visitCastInst(llvm::CastInst& I);
        void visitBinaryOperator(llvm::BinaryOperator& I);
        void visitCmpInst(llvm::CmpInst& I);
        void visitPHINode(llvm::PHINode& I);
        void visitUnaryInstruction(llvm::UnaryInstruction& I);
        void visitCallInst(llvm::CallInst& I);
        void visitSelectInst(llvm::SelectInst& I);
        void visitBitCastInst(llvm::BitCastInst& I);
        void visitInstruction(llvm::Instruction& I);
        void visitLoadInst(llvm::LoadInst& I);
        void visitStoreInst(llvm::StoreInst& I);


        //////////////////////////////////////////////////////////////////////////
        struct ElementNode
        {
            enum Flags {
                kRegisterIsolatedFlag = 1,
                kPHIIsolatedFlag = 2
            };
            ElementNode(llvm::Value* _value) :
                value(_value), rank(0)
            {
                parent.setPointer(this);
            }

            ElementNode* getLeader();

            // Fields:
            llvm::PointerIntPair<ElementNode*, 2> parent;
            llvm::Value* value;
            unsigned rank;
        };

        //////////////////////////////////////////////////////////////////////////
        struct CCTuple
        {
            CCTuple() :
                leftBound(0),
                rightBound(0),
                hasNonHomogeneousElements(false),
                rootInst(nullptr)
            {
            }

            int leftBound;
            int rightBound;


            int GetLeftBound() const
            {
                return leftBound;
            }

            int GetRightBound() const
            {
                return rightBound;
            }


            //cannot be safely extended left/right (used for non-homogeneous payload modeling)
            bool hasNonHomogeneousElements;

            llvm::Instruction* rootInst;

            inline bool HasNonHomogeneousElements() const
            {
                return hasNonHomogeneousElements;
            }

            inline void SetHasNonHomogeneousElements(llvm::Instruction* _rootInst)
            {
                IGC_ASSERT(rootInst == nullptr);
                rootInst = _rootInst;
                hasNonHomogeneousElements = true;
            }

            inline llvm::Instruction* GetRoot() const
            {
                return rootInst;
            }


            inline uint GetNumElements() const
            {
                IGC_ASSERT(rightBound >= leftBound);
                return rightBound - leftBound + 1;
            }

            inline void InitializeIndexWithCCRoot(int index, ElementNode* elNode)
            {
                OffsetToCCMap[index] = elNode;

                ResizeBounds(index);
            }

            inline void ResizeBounds(int index)
            {
                if (index < leftBound)
                {
                    leftBound = index;
                }

                if (index > rightBound)
                {
                    rightBound = index;
                }
            }

            inline void CheckIndexForNonInitializedSlot(int index)
            {
                //if (OffsetToCCMap.count(index) == 0)
                {
                    ResizeBounds(index);
                }
            }


            ElementNode* GetCCNodeWithIndex(int index)
            {
                return OffsetToCCMap[index];
            }

            void AttachNodeAtIndex(int index, ElementNode* node, CoalescingEngine& CE)
            {
                if (OffsetToCCMap.count(index) == 0 || OffsetToCCMap[index] == NULL)
                {
                    IGC_ASSERT(node->value == CE.getRegRoot(node->value));

                    CE.NodeCCTupleMap[node] = this;
                    CE.NodeOffsetMap[node] = index;

                    InitializeIndexWithCCRoot(index, node);
                    CE.CurrentDominatingParent[node->value] = node->value;
                    CE.ImmediateDominatingParent[node->value] = NULL;
                }
                else
                {
                    if (OffsetToCCMap[index] == node)
                    {
                        //Do nothing, it is already there.
                    }
                    else
                    {
                        //Here comes a logic that will attach a new node to CC.
                        IGC_ASSERT(OffsetToCCMap.count(index));
                        IGC_ASSERT(OffsetToCCMap[index]);

                        llvm::Value* ccRootValue = OffsetToCCMap[index]->value;

                        CE.unionRegs(ccRootValue, node->value);

                        llvm::Value* NewParent = CE.GetActualDominatingParent(
                            ccRootValue,
                            llvm::dyn_cast<llvm::Instruction>(node->value));

                        CE.ImmediateDominatingParent[node->value] = NewParent;
                        CE.CurrentDominatingParent[ccRootValue] = node->value;
                    }
                }
            }

            //print in human readable form
            void print(llvm::raw_ostream& OS, const llvm::Module* = 0) const;

            void dump() const;

            //FIXME: not sure whether this is the best choice
        protected:
            llvm::DenseMap<int, ElementNode*> OffsetToCCMap;

            friend class CoalescingEngine;
        };

        friend struct CCTuple;

        ///returns non-null CCtuple pointer if there is at least
        // one value that is 'coalesced' into the tuple.
        // It returns one of those values (e.g. for type insepction)
        // if the condition is true.
        CCTuple* IsAnyValueCoalescedInCCTuple(
            llvm::Instruction* inst,
            const uint numOperands,
            int& zeroBasedPayloadElementOffset,
            llvm::Value*& val);

        ///
        bool IsPayloadCovered(
            llvm::Instruction* inst,
            CCTuple* ccTuple,
            const uint numOperands,
            const int payloadToCCTupleRelativeOffset);


        //FIXME: do a filter over relevant (TGI) instructions
        uint DetermineWeight(llvm::Value* val)
        {
            if (ValueWeightMap.count(val)) {
                return ValueWeightMap[val];
            }
            else {
                uint numUsers = 0;
                {
                    llvm::SmallPtrSet<llvm::User*, MaxTouchedTuples> touchedUsers;
                    for (llvm::Value::user_iterator i = val->user_begin(), e = val->user_end(); i != e; ++i) {
                        llvm::User* user = *i;
                        if (llvm::isa<llvm::Instruction>(user)) {
                            if (!touchedUsers.count(user))
                            {
                                numUsers++;
                                touchedUsers.insert(user);
                            }
                        }
                    }
                }
                ValueWeightMap[val] = numUsers;
                return numUsers;
            }
        }

        //FIXME: this might not be the most effective way if called multiple times
        bool IsolationFilter(llvm::Value* val) const
        {
            if (isCoalescedByDeSSA(val)) {
                return true;
            }
            if (llvm::dyn_cast<llvm::PHINode>(val)) {
                return true;
            }
            else if (llvm::dyn_cast<llvm::ExtractElementInst>(val)) {
                return true;
            }
            else {
                for (llvm::Value::user_iterator i = val->user_begin(), e = val->user_end(); i != e; ++i)
                {
                    if (llvm::dyn_cast<llvm::PHINode>(*i)) {
                        return true;
                    }
                }
            }

            return false;
        }

        bool IsValIsolated(llvm::Value* val)
        {
            return IsolationFilter(val) ||
                isUniform(val) ||
                llvm::isa<llvm::Argument>(val);
        }

        inline bool IsValConstOrIsolated(llvm::Value* val) const
        {
            return llvm::isa<llvm::Constant>(val) ||
                IsolationFilter(val) ||
                isUniform(val) ||
                llvm::isa<llvm::Argument>(val);
        }


        void IncrementalCoalesce(llvm::BasicBlock*);
        void PrepareTuple(
            const uint numOperands,
            llvm::Instruction* tupleGeneratingInstruction,
            llvm::SmallPtrSet<CCTuple*, MaxTouchedTuples> & touchedTuplesSet,
            llvm::SmallVector<CCTuple*, MaxTouchedTuples> & touchedTuples,
            bool& isAnyNodeAnchored,
            bool& isAnyNodeCoalescable);

        void DecideSplit(llvm::Instruction* tupleGeneratingInstruction);

        void CreateTuple(
            const uint numOperands,
            llvm::Instruction* tupleGeneratingInstruction);

        void DetermineAnchor(
            const uint numOperands,
            const llvm::Instruction* tupleGeneratingInstruction,
            CCTuple*& ccTuple,
            int& rootTupleStartOffset,
            int& thisTupleStartOffset);

        //Return true if it is ok to continue, false if interference is detected
        bool EvictOrStop(
            CCTuple* ccTuple,
            const int index,
            llvm::Instruction* tupleGeneratingInstruction,
            bool const forceEviction,
            //out:
            bool& interferes)
        {
            if (!IsInsertionSlotAvailable(ccTuple, index, tupleGeneratingInstruction)) {
                if (forceEviction) {
                    PrepareInsertionSlot(ccTuple, index, tupleGeneratingInstruction);
                    return true; //we can continue
                }
                else {
                    interferes = true;
                    return false; //abort whole 'transaction'
                }
            }
            return true;
        }

        class ProcessInterferencesElementFunctor;

        bool InterferenceCheck(
            const uint numOperands,
            llvm::Instruction* tupleGeneratingInstruction,
            const int offsetDiff,
            CCTuple* ccTuple,
            //out:
            ProcessInterferencesElementFunctor* interferencesFunctor);

        /// \brief return true if element slot is safe for copying-in
        /// canExtend - if true, it is assumed that ccTuple can be 'still' extended
        ///
        ///
        bool IsInsertionSlotAvailable(
            CCTuple* ccTuple,
            const int index,
            llvm::Instruction* tupleGeneratingInstruction,
            const bool canExtend = true);

        void PrepareInsertionSlot(
            CCTuple* ccTuple,
            const int index,
            llvm::Instruction* tupleGeneratingInstruction,
            const bool evictFullCongruenceClass = false);

        bool CheckIntersectionForNonHomogeneous(
            const uint numOperands,
            llvm::Instruction* tupleGeneratingInstruction,
            const int offsetDiff,
            CCTuple* ccTuple);

        void ProcessTuple(llvm::Instruction* tupleGeneratingInstruction);
        void GreedyHeuristic(llvm::Instruction* tupleGeneratingInstruction);

        std::vector<CCTuple*>& GetCCTupleList()
        {
            return m_CCTupleList;
        }

        /// Get the union-root of a register. The root is 0 if the register has been
        /// isolated.
        llvm::Value* getRegRoot(llvm::Value*) const;

        ///Given the currentInstruction and root identifier of CC, find the element
        ///that belongs to CC and is a proper dominator of the currentInstruction.
        ///In straight-line codes and in separate payload and de-ssa phases, this
        ///actually should always give the results in one iteration.
        // Pop registers from the stack represented by ImmediateDominatingParent
        // until we find a parent that dominates the current instruction.
        inline llvm::Value* GetActualDominatingParent(llvm::Value* RootV, llvm::Instruction* currentInstruction)
        {
            llvm::Value* NewParent = CurrentDominatingParent[RootV];

            while (NewParent) {
                if (getRegRoot(NewParent)) {
                    //Fixme: here it does not apply.
                    // we have added the another condition because the domination-test
                    // does not work between two phi-node. See the following comments
                    // from the DT::dominates:
                    // " It is not possible to determine dominance between two PHI nodes
                    //   based on their ordering
                    //  if (isa<PHINode>(A) && isa<PHINode>(B))
                    //    return false;"
                    if (llvm::isa<llvm::Argument>(NewParent)) {
                        break;
                    }
                    else if (DT->dominates(llvm::cast<llvm::Instruction>(NewParent), currentInstruction)) {
                        break;
                    } /* else if (cast<llvm::Instruction>(NewParent)->getParent() == MBB &&
                        isa<PHINode>(DefMI) && isa<PHINode>(NewParent)) {
                            break;
                    } */
                }
                NewParent = ImmediateDominatingParent[NewParent];
            }

            return NewParent;
        }

        //Here we test the interference between the
        //Algorithm:
        //Starting from the currentDominatingParent, walk the congruence class
        //dominance tree upward, until an element that dominates the currentInstruction
        //is found.
        //Since this method could be called on the non-dominance traversal (e.g.
        //currentInstruction dominates some elements in the tree)
        // Say we have a dominance tree that is already constructed (lifetime goes
        // downwards):
        // CC dominance tree
        //    v67
        //    ^
        //    |
        //   v121 (dominating)
        //    ^
        //    |    -----   v181
        //    |
        //   v190 <- (dominated)
        //
        // Want to check the interference with v181, which dominates v190, but is dominated
        // by v121. if we would just look for a dominating element for v181, we would find
        // out that v121 is dominator of v181 and (say) it is not interfering with v181, thus
        // leading to conclusion that there is no interference between v181 and CC dominance tree.

        inline void SymmetricInterferenceTest(
            llvm::Value* RootV,
            llvm::Instruction* currentInstruction,
            llvm::Value*& dominating, //in-out
            llvm::Value*& dominated)
        {
            llvm::Value* NewParent = CurrentDominatingParent[RootV];
            dominating = nullptr;
            dominated = nullptr;

            while (NewParent)
            {
                if (getRegRoot(NewParent)) //not isolated
                {
                    if (llvm::isa<llvm::Argument>(NewParent))
                    {
                        dominating = NewParent;
                        break;
                    }
                    else if (DT->dominates(llvm::cast<llvm::Instruction>(NewParent), currentInstruction))
                    {
                        dominating = NewParent;
                        break;
                    }
                    dominated = NewParent;
                }
                NewParent = ImmediateDominatingParent[NewParent];
            }
        }

        inline CCTuple* GetValueCCTupleMapping(llvm::Value* val)
        {
            llvm::Value* RootV = getRegRoot(val);
            if (!RootV) {
                return NULL;
            }

            IGC_ASSERT(ValueNodeMap.count(RootV));
            auto RI = ValueNodeMap.find(RootV);
            ElementNode* Node = RI->second;

            auto CCI = NodeCCTupleMap.find(Node);
            if (CCI != NodeCCTupleMap.end()) {
                return CCI->second;
            }
            else {
                return NULL;
            }
        }

        /// Caller is responsible for assuring that value is not isolated
        // e.g. by calling GetCalueCCTupleMapping previously.
        inline int GetValueOffsetInCCTuple(llvm::Value* val)
        {
            llvm::Value* RootV = getRegRoot(val);
            IGC_ASSERT(nullptr != RootV);
            IGC_ASSERT(ValueNodeMap.count(RootV));

            auto RI = ValueNodeMap.find(RootV);
            ElementNode* Node = RI->second;

            auto CCI = NodeOffsetMap.find(Node);
            IGC_ASSERT(CCI != NodeOffsetMap.end());
            return CCI->second;
        }

        //////////////////////////////////////////////////////////////////////////
        class ElementFunctor {
        public:
            virtual void SetIndex(int index) = 0;
            virtual bool visitCopy() = 0;
            virtual bool visitConstant() = 0;
            virtual bool visitArgument() = 0;
            virtual bool visitIsolated() = 0;
            virtual bool visitAnchored() = 0;
            virtual bool visitInterfering(llvm::Value* val, const bool evictFullCongruenceClass) = 0;
            virtual bool visitPackedNonInterfering(llvm::Value* val) = 0;
            virtual ~ElementFunctor() {}
        };

        //////////////////////////////////////////////////////////////////////////
        class GatherWeightElementFunctor : public ElementFunctor
        {
        public:
            GatherWeightElementFunctor() :
                nAlignedAnchors(0),
                nInsertionSlotRequired(0),
                nNeedsDisplacement(0)
            {
            }

            virtual void SetIndex(int index)
            {
                IGC_UNUSED(index);
            }

            virtual bool visitCopy()
            {
                nInsertionSlotRequired++;
                return true;
            }

            virtual bool visitConstant()
            {
                nInsertionSlotRequired++;
                return true;
            }

            ///Not used yet, but is here in an interface
            ///for completeness.
            virtual bool visitArgument()
            {
                return true;
            }

            virtual bool visitIsolated()
            {
                nInsertionSlotRequired++;
                return true;
            }

            ///Visits constrained (anchored) element.
            virtual bool visitAnchored()
            {
                nAlignedAnchors++;
                return true;
            }

            ///Visits a value in a tuple that interferes with some (non-isolated)
            ///element in a CC class that occupies the same slot.
            virtual bool visitInterfering(
                llvm::Value* val,
                const bool evictFullCongruenceClass)
            {
                IGC_UNUSED(val);
                IGC_UNUSED(evictFullCongruenceClass);
                nNeedsDisplacement++;
                return true;
            }

            virtual bool visitPackedNonInterfering(llvm::Value* val)
            {
                IGC_UNUSED(val);
                return true;
            }

            ///Gets the number of 'anchored' elements in a tuple.
            inline int GetNumAlignedAnchors() const
            {
                return nAlignedAnchors;
            }

            inline int GetNumInsertionSlotsRequired() const
            {
                return nInsertionSlotRequired;
            }

            ///Gets the number of values in a tuple
            inline int GetNumNeedsDisplacement() const
            {
                return nNeedsDisplacement;
            }

        private:
            int nAlignedAnchors;
            int nInsertionSlotRequired;
            int nNeedsDisplacement;
        };

        //////////////////////////////////////////////////////////////////////////
        class ProcessInterferencesElementFunctor : public ElementFunctor
        {
        private:
            bool m_forceEviction;
            bool m_interferes;
            llvm::Instruction* m_tupleInst;
            const int m_offsetDiff;
            CCTuple* m_ccTuple;
            CoalescingEngine* m_CE;
            int m_index;
            llvm::SmallPtrSet<llvm::Value*, MaxTouchedTuples> m_valuesForIsolation;

        public:
            ProcessInterferencesElementFunctor(
                bool forceEviction,
                llvm::Instruction* inst,
                const int offsetDiff,
                CCTuple* ccTuple,
                CoalescingEngine* CE) :
                m_forceEviction(forceEviction),
                m_interferes(false),
                m_tupleInst(inst),
                m_offsetDiff(offsetDiff),
                m_ccTuple(ccTuple),
                m_CE(CE),
                m_index(0)
            {

            }

            llvm::SmallPtrSet<llvm::Value*, MaxTouchedTuples> & GetComputedValuesForIsolation()
            {
                return m_valuesForIsolation;
            }

            inline void SetForceEviction(bool force)
            {
                m_forceEviction = force;
            }

            inline bool IsInterfering() const
            {
                return m_interferes;
            }

            virtual void SetIndex(int index)
            {
                m_index = index;
            }

            virtual bool visitCopy()
            {
                return m_CE->EvictOrStop(
                    m_ccTuple,
                    m_index + m_offsetDiff,
                    m_tupleInst,
                    m_forceEviction,
                    m_interferes);
            }
            virtual bool visitConstant()
            {
                return m_CE->EvictOrStop(
                    m_ccTuple,
                    m_index + m_offsetDiff,
                    m_tupleInst,
                    m_forceEviction,
                    m_interferes);
            }
            virtual bool visitIsolated()
            {
                return m_CE->EvictOrStop(
                    m_ccTuple,
                    m_index + m_offsetDiff,
                    m_tupleInst,
                    m_forceEviction,
                    m_interferes);
            }

            virtual bool visitArgument()
            {
                return m_CE->EvictOrStop(
                    m_ccTuple,
                    m_index + m_offsetDiff,
                    m_tupleInst,
                    m_forceEviction,
                    m_interferes);
            }

            virtual bool visitAnchored()
            {
                return true;
            }

            virtual bool visitInterfering(llvm::Value* val, const bool evictFullCongruenceClass)
            {
                IGC_UNUSED(evictFullCongruenceClass);
                if (m_forceEviction) {

                    // HEURISTIC:
                    if (m_CE->DetermineWeight(val) < 2) {

                        m_CE->PrepareInsertionSlot(
                            m_ccTuple,
                            m_index + m_offsetDiff,
                            m_tupleInst,
                            false //evictFullCongruenceClass
                        );

                        m_valuesForIsolation.insert(val);
                    }
                    else
                    {
                        m_CE->PrepareInsertionSlot(
                            m_ccTuple,
                            m_index + m_offsetDiff,
                            m_tupleInst,
                            true //evictFullCongruenceClass
                        );

                    }
                    return true;
                }
                else {
                    m_interferes = true;
                    return false;
                }

                return true;
            }

            virtual bool visitPackedNonInterfering(llvm::Value* val)
            {
                if (m_CE->DetermineWeight(val) < 2) {
                    m_valuesForIsolation.insert(val);
                }

                return true;
            }
        };

        void ProcessElements(
            const uint numOperands,
            llvm::Instruction* tupleInst,
            const int offsetDiff,
            CCTuple* ccTuple,
            ElementFunctor* functor);

    public:

        uint GetNumPayloadElements(llvm::Instruction* inst)
        {
            if (currentPart_ == 0)
            {
                auto iter = splitPoint_.find(inst);
                if (iter == splitPoint_.end())
                {
                    //means we have no split point, can
                    return m_PayloadMapping.GetNumPayloadElements(inst);
                }
                else
                {
                    IGC_ASSERT((*iter).second > 0);
                    return (*iter).second;
                }
                //return splitPoint_
            }
            else
            {
                IGC_ASSERT(currentPart_ == 1);
                auto iter = splitPoint_.find(inst);
                IGC_ASSERT(iter != splitPoint_.end());
                return m_PayloadMapping.GetNumPayloadElements(inst) - (*iter).second;
            }
        }
        //uint GetNonAdjustedNumPayloadElements_Sample(const SampleIntrinsic *inst)
        //{
        //    return m_PayloadMapping.GetNonAdjustedNumPayloadElements_Sample(inst);
        //}

        int GetNumPayloadElements_Sample(const llvm::SampleIntrinsic* inst)
        {
            return m_PayloadMapping.GetNumPayloadElements_Sample(inst);
        }

        /// Get the mapping from the payload element (at position index)
        /// to intrinsic argument value. Indexing is zero based.
        llvm::Value* GetPayloadElementToValueMapping(const llvm::Instruction* inst, uint index)
        {
            return m_PayloadMapping.GetPayloadElementToValueMapping(inst, currentLowBound_ + index);
        }
        llvm::Value* GetPayloadElementToValueMapping_sample(const llvm::SampleIntrinsic* inst, const uint index)
        {
            return m_PayloadMapping.GetPayloadElementToValueMapping_sample(inst, index);
        }
        llvm::Value* GetNonAdjustedPayloadElementToValueMapping_sample(const llvm::SampleIntrinsic* inst, const uint index)
        {
            return m_PayloadMapping.GetNonAdjustedPayloadElementToValueMapping_sample(inst, index);
        }

        bool HasNonHomogeneousPayloadElements(const llvm::Instruction* inst)
        {
            return m_PayloadMapping.HasNonHomogeneousPayloadElements(inst);
        }
        int GetLeftReservedOffset(const llvm::Instruction* inst, SIMDMode simdMode)
        {
            return m_PayloadMapping.GetLeftReservedOffset(inst, simdMode);
        }

        int GetRightReservedOffset(const llvm::Instruction* inst, SIMDMode simdMode)
        {
            return m_PayloadMapping.GetRightReservedOffset(inst, simdMode);
        }
        const llvm::Instruction* GetSupremumOfNonHomogeneousPart(
            const llvm::Instruction* inst1,
            const llvm::Instruction* inst2)
        {
            return m_PayloadMapping.GetSupremumOfNonHomogeneousPart(inst1, inst2);
        }

        uint GetNumSplitParts(llvm::Instruction* inst)
        {
            auto iter = splitPoint_.find(inst);
            if (iter != splitPoint_.end())
            {
                uint splitIndex = (*iter).second;
                return splitIndex > 0 ? 2 : 1;
            }
            else
            {
                return 1;
            }
        }

        void SetCurrentPart(llvm::Instruction* inst, unsigned int partNum)
        {
            if (partNum == 0)
            {
                currentLowBound_ = 0;
                currentPart_ = partNum;
                //            currentUpperBound_ = splitPoint_[inst];
            }
            else
            {
                IGC_ASSERT(partNum == 1);
                currentLowBound_ = splitPoint_[inst];
                IGC_ASSERT(currentLowBound_ > 0);
                currentPart_ = partNum;
            }
        }

    private:

        CPlatform m_Platform;
        PayloadMapping m_PayloadMapping;
        std::vector<CCTuple*> m_CCTupleList;
        llvm::DominatorTree* DT;
        LiveVars* LV;
        WIAnalysis* WIA;
        DeSSA* m_DeSSA;
        ResourceLoopAnalysis* RLA;
        CodeGenPatternMatch* CG;
        llvm::DenseMap<llvm::Value*, ElementNode*> ValueNodeMap;
        llvm::DenseMap<ElementNode*, CCTuple*> NodeCCTupleMap;
        //Mapping root element node to its offset in cc tuple:
        llvm::DenseMap<ElementNode*, int> NodeOffsetMap;
        llvm::DenseMap<llvm::Value*, uint> ValueWeightMap;
        ModuleMetaData* m_ModuleMetadata;
        CodeGenContext* m_CodeGenContext;
        //Maps a basic block to a list of instruction defs to be processed for coalescing (in dominance order)
        llvm::DenseMap<llvm::BasicBlock*, std::vector<llvm::Instruction*> > BBProcessingDefs;


        /* Taken from strong DE SSA */
        // Perform a depth-first traversal of the dominator tree, splitting
        // interferences amongst PHI-congruence classes.

        llvm::BumpPtrAllocator Allocator;

        llvm::DenseMap<llvm::Value*, llvm::Value*> CurrentDominatingParent;
        llvm::DenseMap<llvm::Value*, llvm::Value*> ImmediateDominatingParent;

        llvm::DenseMap<llvm::Instruction*, uint> splitPoint_;
        unsigned currentLowBound_;
        //unsigned currentUpperBound_;
        unsigned currentPart_;

        /// Get the union-root of a PHI. The root of a PHI is 0 if the PHI has been
        /// isolated. Otherwise, it is the original root of its destination and
        /// all of its operands (before they were isolated, if they were).
        llvm::Value* getPHIRoot(llvm::Instruction*) const;

        void unionRegs(llvm::Value*, llvm::Value*);

        bool isUniform(llvm::Value* v) const {
            return (WIA->isUniform(v));
        }

        // Isolate a register.
        void isolateReg(llvm::Value* Val) {
            ElementNode* Node = ValueNodeMap[Val];
            Node->parent.setInt(Node->parent.getInt() | ElementNode::kRegisterIsolatedFlag);
        }
        /* Taken from strong DE SSA */



        struct MIIndexCompare {
            MIIndexCompare(LiveVars* _lv) : LV(_lv) { }

            bool operator()(const llvm::Instruction* LHS, const llvm::Instruction* RHS) const {
                return LV->getDistance(LHS) < LV->getDistance(RHS);
            }

            LiveVars* LV;
        };

        bool isCoalescedByDeSSA(llvm::Value* V) const;
    };

} //namespace IGC
