Minor fixes.

Author: pratikashar

visa/LoopAnalysis.cpp

@@ -426,8 +426,8 @@ bool Dominator::dominates(G4_BB* bb1, G4_BB* bb2)
 {
     recomputeIfStale();
 
-    auto& dom = getDom(bb1);
-    if (dom.find(bb2) != dom.end())
+    auto& dom = getDom(bb2);
+    if (dom.find(bb1) != dom.end())
         return true;
 
     return false;
@@ -663,6 +663,32 @@ std::vector<Loop*> vISA::LoopDetection::getTopLoops()
     return topLoops;
 }
 
+Loop* Loop::getInnerMostLoop(const G4_BB* bb)
+{
+    // if current loop contains bb, recurse loop tree and return
+    // most nested loop containing it.
+    // if current loop doesnt contain bb then return nullptr.
+    if (!contains(bb))
+        return nullptr;
+
+    for (auto& nested : immNested)
+        if(auto innerMost = nested->getInnerMostLoop(bb))
+            return innerMost;
+
+    return this;
+}
+
+Loop* LoopDetection::getInnerMostLoop(const G4_BB* bb)
+{
+    recomputeIfStale();
+
+    for (auto& loop : topLoops)
+        if (auto innerMost = loop->getInnerMostLoop(bb))
+            return innerMost;
+
+    return nullptr;
+}
+
 void LoopDetection::reset()
 {
     allLoops.clear();
@@ -1016,7 +1042,126 @@ void Loop::dump(std::ostream& os)
     }
 }
 
-bool vISA::Loop::contains(const G4_BB* bb)
+bool Loop::contains(const G4_BB* bb)
 {
     return BBsLookup.find(bb) != BBsLookup.end();
 }
+
+bool VarReferences::isUniqueDef(G4_DstRegRegion* dst)
+{
+    recomputeIfStale();
+
+    auto dcl = dst->getTopDcl();
+
+    // return true if spilled variable has a single static def
+    // and it is not live-in to current bb (eg, loop, sub).
+    if (getDefCount(dcl) != 1)
+    {
+        // check whether multiple defs exist in program for current
+        // lb, rb
+        auto lb = dst->getLeftBound();
+        auto rb = dst->getRightBound();
+
+        unsigned int count = 0;
+        const auto& defs = getDefs(dcl);
+        for (auto& def : *defs)
+        {
+            if (std::get<2>(def) <= rb &&
+                std::get<3>(def) >= lb)
+                ++count;
+        }
+
+        if (count > 1)
+            return false;
+    }
+
+    return true;
+}
+
+unsigned int VarReferences::getDefCount(G4_Declare* dcl)
+{
+    auto defs = getDefs(dcl);
+    if (defs)
+        return defs->size();
+    return 0;
+}
+
+const VarReferences::Defs* VarReferences::getDefs(G4_Declare* dcl)
+{
+    recomputeIfStale();
+
+    auto it = VarRefs.find(dcl);
+    if (it != VarRefs.end())
+        return &(it->second.first);
+
+    return nullptr;
+}
+
+const VarReferences::Uses* VarReferences::getUses(G4_Declare* dcl)
+{
+    recomputeIfStale();
+
+    auto it = VarRefs.find(dcl);
+    if (it != VarRefs.end())
+        return &(it->second.second);
+
+    return nullptr;
+}
+
+void VarReferences::reset()
+{
+    VarRefs.clear();
+
+    setStale();
+}
+
+void VarReferences::run()
+{
+    for (auto bb : kernel.fg)
+    {
+        for (auto inst : *bb)
+        {
+            if (inst->isPseudoKill())
+                continue;
+
+            auto dst = inst->getDst();
+
+            if (dst && !dst->isNullReg())
+            {
+                auto topdcl = dst->getTopDcl();
+
+                if (topdcl)
+                {
+                    auto lb = dst->getLeftBound();
+                    auto rb = dst->getRightBound();
+                    auto& Defs = VarRefs[topdcl].first;
+                    Defs.push_back(std::make_tuple(inst, bb, lb, rb));
+                }
+            }
+
+            for (unsigned int i = 0; i != inst->getNumSrc(); ++i)
+            {
+                auto src = inst->getSrc(i);
+                if (src && src->isSrcRegRegion())
+                {
+                    auto topdcl = src->asSrcRegRegion()->getTopDcl();
+                    if (topdcl)
+                    {
+                        auto& Uses = VarRefs[topdcl].second;
+                        Uses.push_back(std::make_tuple(inst, bb));
+                    }
+                }
+            }
+        }
+    }
+
+    setValid();
+}
+
+void VarReferences::dump(std::ostream& os)
+{
+    if (isStale())
+        os << "Data is stale.\n";
+
+    os << "#Dcls with defs/uses: " << VarRefs.size();
+}

visa/LoopAnalysis.h

@@ -100,6 +100,36 @@ namespace vISA
         void dump(std::ostream& os = std::cerr) override { dumpImmDom(os); }
     };
 
+    // Computes and stores direct references of variables.
+    // Indirects references are not computed here.
+    // Doesnt include predicates/condition modifiers.
+    class VarReferences : public Analysis
+    {
+    public:
+        VarReferences(G4_Kernel& k) : kernel(k) {}
+
+        // Defs -> vector[tuple<inst, bb, lb, rb>]
+        // Uses -> vector[tuple<inst, bb>]
+        using Defs = std::vector<std::tuple<G4_INST*, G4_BB*, unsigned int, unsigned int>>;
+        using Uses = std::vector<std::tuple<G4_INST*, G4_BB*>>;
+
+        bool isUniqueDef(G4_DstRegRegion* dst);
+        unsigned int getDefCount(G4_Declare* dcl);
+        const Defs* getDefs(G4_Declare* dcl);
+        const Uses* getUses(G4_Declare* dcl);
+
+    private:
+        // Dcl -> vector[<inst, bb, lb, rb>]
+        // this data structure helps check whether a definition or part of it
+        // has multiple definitions in the program.
+        std::unordered_map<G4_Declare*, std::pair<Defs, Uses>> VarRefs;
+        G4_Kernel& kernel;
+
+        void reset() override;
+        void run() override;
+        void dump(std::ostream& os = std::cerr) override;
+    };
+
     using BackEdge = std::pair<G4_BB*, G4_BB*>;
     using BackEdges = std::vector<BackEdge>;
 
@@ -134,6 +164,8 @@ namespace vISA
         bool fullSubset(Loop* other);
         bool fullSuperset(Loop* other);
 
+        Loop* getInnerMostLoop(const G4_BB* bb);
+
     private:
         std::vector<G4_BB*> BBs;
         std::unordered_set<const G4_BB*> BBsLookup;
@@ -148,6 +180,7 @@ namespace vISA
         LoopDetection(G4_Kernel&);
 
         std::vector<Loop*> getTopLoops();
+        Loop* getInnerMostLoop(const G4_BB*);
 
     private:
         std::vector<Loop*> topLoops;