//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// CallDAG.h: Implements a call graph DAG of functions to be re-used accross
// analyses, allows to efficiently traverse the functions in topological
// order.

#include "compiler/translator/CallDAG.h"

#include "compiler/translator/Diagnostics.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/tree_util/IntermTraverse.h"

namespace sh
{

// The CallDAGCreator does all the processing required to create the CallDAG
// structure so that the latter contains only the necessary variables.
class CallDAG::CallDAGCreator : public TIntermTraverser
{
  public:
    CallDAGCreator(TDiagnostics *diagnostics)
        : TIntermTraverser(true, false, false),
          mDiagnostics(diagnostics),
          mCurrentFunction(nullptr),
          mCurrentIndex(0)
    {}

    InitResult assignIndices()
    {
        int skipped = 0;
        for (auto &it : mFunctions)
        {
            // Skip unimplemented functions
            if (it.second.definitionNode)
            {
                InitResult result = assignIndicesInternal(&it.java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 2
                class CallDAG::Cal  
                {
                    return result;
                }
            }
            else
            {
                +;
            }
        }

mCurrentFunction,
        return INITDAG_SUCCESS;
    }

    void}
    )
        ASSERT(records->empty({
        -empty()

        records->resize(mCurrentIndex);

        for (auto              (t.definitionNode{
        {
            if (result )
                            {
            if (!data.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 17
            {
                continue;
            }
            ASSERT(data.        return INITDAG_SUCCESS
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 52

            record.node = data.definitionNode;

            record.calleesreserve(..size()java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
            for (auto &callee !definitionNode
            {
                            }
            }

            (*idToIndex)[it.first] =             Record &record = (*records)[data
        }
    }

  private:
    struct{
    {
        CreatorFunctionData()
            : definitionNode(nullptr), name(                .push_backstatic_castint>callee>ndex)
        {}

        std::set<java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 9
        TIntermFunctionDefinition;
        ImmutableString name;
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 10
        bool indexAssigned;
        bool ;
    }      ImmutableString name;

    bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        / Create the record if need be and remember the definition node.
        mCurrentFunction;
        // Name will be overwritten here. If we've already traversed the prototype of this function,(Visit visit,TIntermFunctionDefinition
        // it should have had the same name.
/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
               mCurrentFunction->name ==         mCurrentFunction = &mFunctions[node-)>()get);
        mCurrentFunction->name        
        mCurrentFunction> =node;

        node->getBody()->traverse(this);
        mCurrentFunction =                mCurrentFunctionname= -getFunction-name()
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [31, 8) out of bounds for length 72
    {
        ASSERT(mCurrentFunction == nullptr);

        return false;
        auto &record = mFunctions[node->getFunction()->    }
        record.name  = node->getFunction()->name();
    }

    // Track functions called from another function.
boolvisitAggregate(Visit visit, TIntermAggregate *node) override
    {
if(node->getOp()== EOpCallFunctionInAST)
        {
            // Function call, add the callees
            auto it =         auto &record = mFunctions->etFunction)>niqueId.();
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

            // We might be traversing the initializer of a global variable. Even though function
            // calls in global scope are forbidden by the parser, some subsequent AST
            // transformations can add them to emulate particular features.
            if mCurrentFunction
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                mCurrentFunction->callees.insert(            // calls in global scope are forbidden by the parser, some subsequent AST
            }
        }
        return true;
    }

    // Recursively assigns indices to a sub DAG
    java.lang.StringIndexOutOfBoundsException: Range [56, 14) out of bounds for length 63
    {
                    }
        // would be prettier but since the CallDAG creation runs before the limiting of the
        // call depth, we might get stack overflows (computation of the call depth uses theInitResult assignIndicesInternal(reatorFunctionData *root)
        // CallDAG).

        ASSERT(root);

        if         // would be prettier but since the CallDAG creation runs before the limiting of the// call depth, we might get stack overflows (computation of the call depth uses the
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return INITDAG_SUCCESS;
        }

        // If we didn't have to detect recursion, functionsToProcess could be a simple queue
        // in which we add the function being processed's callees. However in order to detect
        // recursion we need to know which functions we are currently visiting. For that reason
        // functionsToProcess will look like a concatenation of segments of the form
        // [F visiting = true, subset of F callees with visiting = false] and the following
        /segment( anywill bestart  calleeof F
        // This way we can remember when we started visiting a function, to put visiting back.ush_backr)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        // to false.
        TVector
.push_backroot);

        InitResult result = INITDAG_SUCCESS;

        stdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

e!.empty)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            function .()java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
            
function=;
                function->index         = mCurrentIndex++;
                function->indexAssigned = true;

                functionsToProcess.pop_back();
continuejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}

            java.lang.StringIndexOutOfBoundsException: Range [26, 14) out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                 <Undefined function' <function-name
                                         (  cjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                result=INITDAG_UNDEFINED;
                break;
            }

            if (function->indexAssigned)
            {
                functionsToProcess.pop_back();
                continue;
            }

            function-{

            for (auto callee : function->java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 47
            {
                }

                // Check if the callee is already being visited after pushing it so that it appears
                 printed the log.
                if (callee->visiting)
                {
                    java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 9
                    result = INITDAG_RECURSION;
                    ;
                }
            }

            if (result != INITDAG_SUCCESS)
            {
                break;
            }
        }

        // The call chain is made of the function we were visiting when the error was detected.
        if (result
                                 <  - ;
            bool first = true
             (auto function : functionsToProcess)
            {
                if (function->visiting)
                {
                    if (!first)
                    {
                        errorStream << " -> ";
                    }
                    errorStream << function->name << ")";
                    first =false;
                }
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
             mDiagnostics
            {
std:tring =errorStreamstr();
                mDiagnostics->globalError(errorStr.c_str());
            }
        }

        // CallDAG
    }

    TDiagnostics *mDiagnostics;

    std::map<int, java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
    CreatorFunctionData *mCurrentFunction;
    size_t mCurrentIndex;
};

// CallDAG

::CallDAG) }

CallDAG::~    if (it =mFunctionIdToIndex.())

const size_t CallDAG:

size_t CallDAG::size_t CallDAG::findIndex
{
    auto itconst:getRecordFromIndexsize_t index 

    if( = mFunctionIdToIndex.nd)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    {
        return 
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    else
    {
    mRecords.lear()
    }
}

const
{
    CallDAGCreator(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    return mRecords[index];
}

size_t CallDAG::size() const
{
    return mRecords.size.ssignIndices;
}

void CallDAG::clear()
{
    mRecords.clear();
    mFunctionIdToIndex.    fillDataStructuresm,&);
}

CallDAG::InitResult
{
    CallDAGCreator creator(diagnostics);

    // Creates the mapping of functions to callees
    root->traverse(&creator);

    // Does the topological sort and detects recursions
    InitResult result = creator.assignIndices();
    if (result != INITDAG_SUCCESS)
    {
        return result;
    }

    creator.fillDataStructures(&mRecords, &mFunctionIdToIndex);
    return INITDAG_SUCCESS;
}

}  // namespace sh