Implement discontinuous loops AST analysis

src/compiler/translator/ASTMetadataHLSL.cpp

@@ -138,6 +138,201 @@ class PullGradient : public TIntermTraverser
     std::vector<TIntermNode*> mParents;
 };
 
+// Traverses the AST of a function definition, assuming it has already been used to
+// traverse the callees of that function; computes the discontinuous loops and the if
+// statements that contain a discontinuous loop in their call graph.
+class PullComputeDiscontinuousLoops : public TIntermTraverser
+{
+  public:
+    PullComputeDiscontinuousLoops(MetadataList *metadataList, size_t index, const CallDAG &dag)
+        : TIntermTraverser(true, false, true),
+          mMetadataList(metadataList),
+          mMetadata(&(*metadataList)[index]),
+          mIndex(index),
+          mDag(dag)
+    {
+    }
+
+    void traverse(TIntermAggregate *node)
+    {
+        node->traverse(this);
+        ASSERT(mLoops.empty());
+        ASSERT(mIfs.empty());
+    }
+
+    // Called when a discontinuous loop or a call to a function with a discontinuous loop
+    // in its call graph is found.
+    void onDiscontinuousLoop()
+    {
+        mMetadata->mHasDiscontinuousLoopInCallGraph = true;
+        // Mark the latest if as using a discontinuous loop.
+        if (!mIfs.empty())
+        {
+            mMetadata->mIfsContainingDiscontinuousLoop.insert(mIfs.back());
+        }
+    }
+
+    bool visitLoop(Visit visit, TIntermLoop *loop)
+    {
+        if (visit == PreVisit)
+        {
+            mLoops.push_back(loop);
+        }
+        else if (visit == PostVisit)
+        {
+            ASSERT(mLoops.back() == loop);
+            mLoops.pop_back();
+        }
+
+        return true;
+    }
+
+    bool visitSelection(Visit visit, TIntermSelection *node)
+    {
+        if (visit == PreVisit)
+        {
+            mIfs.push_back(node);
+        }
+        else if (visit == PostVisit)
+        {
+            ASSERT(mIfs.back() == node);
+            mIfs.pop_back();
+            // An if using a discontinuous loop means its parents ifs are also discontinuous.
+            if (mMetadata->mIfsContainingDiscontinuousLoop.count(node) > 0 && !mIfs.empty())
+            {
+                mMetadata->mIfsContainingDiscontinuousLoop.insert(mIfs.back());
+            }
+        }
+
+        return true;
+    }
+
+    bool visitBranch(Visit visit, TIntermBranch *node)
+    {
+        if (visit == PreVisit)
+        {
+            switch (node->getFlowOp())
+            {
+              case EOpKill:
+                break;
+              case EOpBreak:
+              case EOpContinue:
+                ASSERT(!mLoops.empty());
+                mMetadata->mDiscontinuousLoops.insert(mLoops.back());
+                onDiscontinuousLoop();
+                break;
+              case EOpReturn:
+                // A return jumps out of all the enclosing loops
+                if (!mLoops.empty())
+                {
+                    for (TIntermLoop* loop : mLoops)
+                    {
+                        mMetadata->mDiscontinuousLoops.insert(loop);
+                    }
+                    onDiscontinuousLoop();
+                }
+                break;
+              default:
+                UNREACHABLE();
+            }
+        }
+
+        return true;
+    }
+
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override
+    {
+        if (visit == PreVisit && node->getOp() == EOpFunctionCall)
+        {
+            if (node->isUserDefined())
+            {
+                size_t calleeIndex = mDag.findIndex(node);
+                ASSERT(calleeIndex != CallDAG::InvalidIndex && calleeIndex < mIndex);
+
+                if ((*mMetadataList)[calleeIndex].mHasDiscontinuousLoopInCallGraph)
+                {
+                    onDiscontinuousLoop();
+                }
+            }
+        }
+
+        return true;
+    }
+
+  private:
+    MetadataList *mMetadataList;
+    ASTMetadataHLSL *mMetadata;
+    size_t mIndex;
+    const CallDAG &mDag;
+
+    std::vector<TIntermLoop*> mLoops;
+    std::vector<TIntermSelection*> mIfs;
+};
+
+// Tags all the functions called in a discontinuous loop
+class PushDiscontinuousLoops : public TIntermTraverser
+{
+  public:
+    PushDiscontinuousLoops(MetadataList *metadataList, size_t index, const CallDAG &dag)
+        : TIntermTraverser(true, true, true),
+          mMetadataList(metadataList),
+          mMetadata(&(*metadataList)[index]),
+          mIndex(index),
+          mDag(dag),
+          mNestedDiscont(mMetadata->mCalledInDiscontinuousLoop ? 1 : 0)
+    {
+    }
+
+    void traverse(TIntermAggregate *node)
+    {
+        node->traverse(this);
+        ASSERT(mNestedDiscont == (mMetadata->mCalledInDiscontinuousLoop ? 1 : 0));
+    }
+
+    bool visitLoop(Visit visit, TIntermLoop *loop)
+    {
+        bool isDiscontinuous = mMetadata->mDiscontinuousLoops.count(loop) > 0;
+
+        if (visit == PreVisit && isDiscontinuous)
+        {
+            mNestedDiscont++;
+        }
+        else if (visit == PostVisit && isDiscontinuous)
+        {
+            mNestedDiscont--;
+        }
+
+        return true;
+    }
+
+    bool visitAggregate(Visit visit, TIntermAggregate *node) override
+    {
+        switch (node->getOp())
+        {
+          case EOpFunctionCall:
+            if (visit == PreVisit && node->isUserDefined() && mNestedDiscont > 0)
+            {
+                size_t calleeIndex = mDag.findIndex(node);
+                ASSERT(calleeIndex != CallDAG::InvalidIndex && calleeIndex < mIndex);
+
+                (*mMetadataList)[calleeIndex].mCalledInDiscontinuousLoop = true;
+            }
+            break;
+          default:
+            break;
+        }
+        return true;
+    }
+
+  private:
+    MetadataList *mMetadataList;
+    ASTMetadataHLSL *mMetadata;
+    size_t mIndex;
+    const CallDAG &mDag;
+
+    int mNestedDiscont;
+};
+
 }
 
 bool ASTMetadataHLSL::hasGradientInCallGraph(TIntermSelection *node)
@@ -150,6 +345,11 @@ bool ASTMetadataHLSL::hasGradientInCallGraph(TIntermLoop *node)
     return mControlFlowsContainingGradient.count(node) > 0;
 }
 
+bool ASTMetadataHLSL::hasDiscontinuousLoop(TIntermSelection *node)
+{
+    return mIfsContainingDiscontinuousLoop.count(node) > 0;
+}
+
 MetadataList CreateASTMetadataHLSL(TIntermNode *root, const CallDAG &callDag)
 {
     MetadataList metadataList(callDag.size());
@@ -177,5 +377,35 @@ MetadataList CreateASTMetadataHLSL(TIntermNode *root, const CallDAG &callDag)
         pull.traverse(callDag.getRecordFromIndex(i).node);
     }
 
+    // Compute which loops are discontinuous and which function are called in
+    // these loops. The same way computing gradient usage is a "pull" process,
+    // computing "bing used in a discont. loop" is a push process. However we also
+    // need to know what ifs have a discontinuous loop inside so we do the same type
+    // of callgraph analysis as for the gradient.
+
+    // First compute which loops are discontinuous (no specific order) and pull
+    // the ifs and functions using a discontinuous loop.
+    for (size_t i = 0; i < callDag.size(); i++)
+    {
+        PullComputeDiscontinuousLoops pull(&metadataList, i, callDag);
+        pull.traverse(callDag.getRecordFromIndex(i).node);
+    }
+
+    // Then push the information to callees, either from the a local discontinuous
+    // loop or from the caller being called in a discontinuous loop already
+    for (size_t i = callDag.size(); i-- > 0;)
+    {
+        PushDiscontinuousLoops push(&metadataList, i, callDag);
+        push.traverse(callDag.getRecordFromIndex(i).node);
+    }
+
+    // We create "Lod0" version of functions with the gradient operations replaced
+    // by non-gradient operations so that the D3D compiler is happier with discont
+    // loops.
+    for (auto &metadata : metadataList)
+    {
+        metadata.mNeedsLod0 = metadata.mCalledInDiscontinuousLoop && metadata.mUsesGradient;
+    }
+
     return metadataList;
 }

src/compiler/translator/ASTMetadataHLSL.h

@@ -20,7 +20,10 @@ class TIntermLoop;
 struct ASTMetadataHLSL
 {
     ASTMetadataHLSL()
-        : mUsesGradient(false)
+        : mUsesGradient(false),
+          mCalledInDiscontinuousLoop(false),
+          mHasDiscontinuousLoopInCallGraph(false),
+          mNeedsLod0(false)
     {
     }
 
@@ -28,6 +31,7 @@ struct ASTMetadataHLSL
     // gradient operation, or a call to a function that uses a gradient.
     bool hasGradientInCallGraph(TIntermSelection *node);
     bool hasGradientInCallGraph(TIntermLoop *node);
+    bool hasDiscontinuousLoop(TIntermSelection *node);
 
     // Does the function use a gradient.
     bool mUsesGradient;
@@ -35,6 +39,16 @@ struct ASTMetadataHLSL
     // Even if usesGradient is true, some control flow might not use a gradient
     // so we store the set of all gradient-using control flows.
     std::set<TIntermNode*> mControlFlowsContainingGradient;
+
+    // Remember information about the discontinuous loops and which functions
+    // are called in such loops.
+    bool mCalledInDiscontinuousLoop;
+    bool mHasDiscontinuousLoopInCallGraph;
+    std::set<TIntermLoop*> mDiscontinuousLoops;
+    std::set<TIntermSelection*> mIfsContainingDiscontinuousLoop;
+
+    // Will we need to generate a Lod0 version of the function.
+    bool mNeedsLod0;
 };
 
 typedef std::vector<ASTMetadataHLSL> MetadataList;