chromium/third_party/angle/src/compiler/translator/IntermRebuild.cpp

//
// Copyright 2020 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.
//

#include <algorithm>

#include "compiler/translator/Compiler.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/AsNode.h"
#include "compiler/translator/IntermRebuild.h"

#define GUARD2(cond, failVal) …

#define GUARD(cond) …

namespace sh
{

template <typename T, typename U>
ANGLE_INLINE bool AllBits(T haystack, U needle)
{ … }

template <typename T, typename U>
ANGLE_INLINE bool AnyBits(T haystack, U needle)
{ … }

////////////////////////////////////////////////////////////////////////////////

TIntermRebuild::BaseResult::BaseResult(BaseResult &other)
    : … { … }

TIntermRebuild::BaseResult::BaseResult(TIntermNode &node, VisitBits visit)
    : … { … }

TIntermRebuild::BaseResult::BaseResult(TIntermNode *node, VisitBits visit)
    : … { … }

TIntermRebuild::BaseResult::BaseResult(std::nullptr_t)
    : … { … }

TIntermRebuild::BaseResult::BaseResult(Fail)
    : … { … }

TIntermRebuild::BaseResult::BaseResult(std::vector<TIntermNode *> &&nodes)
    : … { … }

void TIntermRebuild::BaseResult::moveAssignImpl(BaseResult &other)
{ … }

TIntermRebuild::BaseResult TIntermRebuild::BaseResult::Multi(std::vector<TIntermNode *> &&nodes)
{ … }

bool TIntermRebuild::BaseResult::isFail() const
{ … }

bool TIntermRebuild::BaseResult::isDrop() const
{ … }

TIntermNode *TIntermRebuild::BaseResult::single() const
{ … }

const std::vector<TIntermNode *> *TIntermRebuild::BaseResult::multi() const
{ … }

////////////////////////////////////////////////////////////////////////////////

PreResult;

PreResult::PreResult(TIntermNode &node, VisitBits visit) : … { … }
PreResult::PreResult(TIntermNode *node, VisitBits visit) : … { … }
PreResult::PreResult(std::nullptr_t) : … { … }
PreResult::PreResult(Fail) : … { … }

PreResult::PreResult(BaseResult &&other) : … { … }
PreResult::PreResult(PreResult &&other) : … { … }

void PreResult::operator=(PreResult &&other)
{ … }

////////////////////////////////////////////////////////////////////////////////

PostResult;

PostResult::PostResult(TIntermNode &node) : … { … }
PostResult::PostResult(TIntermNode *node) : … { … }
PostResult::PostResult(std::nullptr_t) : … { … }
PostResult::PostResult(Fail) : … { … }

PostResult::PostResult(PostResult &&other) : … { … }
PostResult::PostResult(BaseResult &&other) : … { … }

void PostResult::operator=(PostResult &&other)
{ … }

////////////////////////////////////////////////////////////////////////////////

TIntermRebuild::TIntermRebuild(TCompiler &compiler, bool preVisit, bool postVisit)
    : … { … }

TIntermRebuild::~TIntermRebuild()
{ … }

const TFunction *TIntermRebuild::getParentFunction() const
{ … }

TIntermNode *TIntermRebuild::getParentNode(size_t offset) const
{ … }

bool TIntermRebuild::rebuildRoot(TIntermBlock &root)
{ … }

bool TIntermRebuild::rebuildInPlace(TIntermAggregate &node)
{ … }

bool TIntermRebuild::rebuildInPlace(TIntermBlock &node)
{ … }

bool TIntermRebuild::rebuildInPlace(TIntermDeclaration &node)
{ … }

template <typename Node>
bool TIntermRebuild::rebuildInPlaceImpl(Node &node)
{ … }

PostResult TIntermRebuild::rebuild(TIntermNode &node)
{ … }

////////////////////////////////////////////////////////////////////////////////

template <typename Node>
Node *TIntermRebuild::traverseAnyAs(TIntermNode &node)
{ … }

template <typename Node>
bool TIntermRebuild::traverseAnyAs(TIntermNode &node, Node *&out)
{ … }

bool TIntermRebuild::traverseAggregateBaseChildren(TIntermAggregateBase &node)
{ … }

////////////////////////////////////////////////////////////////////////////////

struct TIntermRebuild::NodeStackGuard
{ … };

PostResult TIntermRebuild::traverseAny(TIntermNode &originalNode)
{ … }

PreResult TIntermRebuild::traversePre(TIntermNode &originalNode)
{ … }

TIntermNode *TIntermRebuild::traverseChildren(NodeType currNodeType,
                                              const TIntermNode &originalNode,
                                              TIntermNode &currNode,
                                              VisitBits visit)
{ … }

PostResult TIntermRebuild::traversePost(NodeType currNodeType,
                                        const TIntermNode &originalNode,
                                        TIntermNode &currNode,
                                        VisitBits visit)
{ … }

////////////////////////////////////////////////////////////////////////////////

TIntermNode *TIntermRebuild::traverseAggregateChildren(TIntermAggregate &node)
{ … }

TIntermNode *TIntermRebuild::traverseBlockChildren(TIntermBlock &node)
{ … }

TIntermNode *TIntermRebuild::traverseDeclarationChildren(TIntermDeclaration &node)
{ … }

TIntermNode *TIntermRebuild::traverseSwizzleChildren(TIntermSwizzle &node)
{ … }

TIntermNode *TIntermRebuild::traverseBinaryChildren(TIntermBinary &node)
{ … }

TIntermNode *TIntermRebuild::traverseUnaryChildren(TIntermUnary &node)
{ … }

TIntermNode *TIntermRebuild::traverseTernaryChildren(TIntermTernary &node)
{ … }

TIntermNode *TIntermRebuild::traverseIfElseChildren(TIntermIfElse &node)
{ … }

TIntermNode *TIntermRebuild::traverseSwitchChildren(TIntermSwitch &node)
{ … }

TIntermNode *TIntermRebuild::traverseCaseChildren(TIntermCase &node)
{ … }

TIntermNode *TIntermRebuild::traverseFunctionDefinitionChildren(TIntermFunctionDefinition &node)
{ … }

TIntermNode *TIntermRebuild::traverseGlobalQualifierDeclarationChildren(
    TIntermGlobalQualifierDeclaration &node)
{ … }

TIntermNode *TIntermRebuild::traverseLoopChildren(TIntermLoop &node)
{ … }

TIntermNode *TIntermRebuild::traverseBranchChildren(TIntermBranch &node)
{ … }

////////////////////////////////////////////////////////////////////////////////

PreResult TIntermRebuild::visitSymbolPre(TIntermSymbol &node)
{ … }

PreResult TIntermRebuild::visitConstantUnionPre(TIntermConstantUnion &node)
{ … }

PreResult TIntermRebuild::visitFunctionPrototypePre(TIntermFunctionPrototype &node)
{ … }

PreResult TIntermRebuild::visitPreprocessorDirectivePre(TIntermPreprocessorDirective &node)
{ … }

PreResult TIntermRebuild::visitUnaryPre(TIntermUnary &node)
{ … }

PreResult TIntermRebuild::visitBinaryPre(TIntermBinary &node)
{ … }

PreResult TIntermRebuild::visitTernaryPre(TIntermTernary &node)
{ … }

PreResult TIntermRebuild::visitSwizzlePre(TIntermSwizzle &node)
{ … }

PreResult TIntermRebuild::visitIfElsePre(TIntermIfElse &node)
{ … }

PreResult TIntermRebuild::visitSwitchPre(TIntermSwitch &node)
{ … }

PreResult TIntermRebuild::visitCasePre(TIntermCase &node)
{ … }

PreResult TIntermRebuild::visitLoopPre(TIntermLoop &node)
{ … }

PreResult TIntermRebuild::visitBranchPre(TIntermBranch &node)
{ … }

PreResult TIntermRebuild::visitDeclarationPre(TIntermDeclaration &node)
{ … }

PreResult TIntermRebuild::visitBlockPre(TIntermBlock &node)
{ … }

PreResult TIntermRebuild::visitAggregatePre(TIntermAggregate &node)
{ … }

PreResult TIntermRebuild::visitFunctionDefinitionPre(TIntermFunctionDefinition &node)
{ … }

PreResult TIntermRebuild::visitGlobalQualifierDeclarationPre(
    TIntermGlobalQualifierDeclaration &node)
{ … }

////////////////////////////////////////////////////////////////////////////////

PostResult TIntermRebuild::visitSymbolPost(TIntermSymbol &node)
{ … }

PostResult TIntermRebuild::visitConstantUnionPost(TIntermConstantUnion &node)
{ … }

PostResult TIntermRebuild::visitFunctionPrototypePost(TIntermFunctionPrototype &node)
{ … }

PostResult TIntermRebuild::visitPreprocessorDirectivePost(TIntermPreprocessorDirective &node)
{ … }

PostResult TIntermRebuild::visitUnaryPost(TIntermUnary &node)
{ … }

PostResult TIntermRebuild::visitBinaryPost(TIntermBinary &node)
{ … }

PostResult TIntermRebuild::visitTernaryPost(TIntermTernary &node)
{ … }

PostResult TIntermRebuild::visitSwizzlePost(TIntermSwizzle &node)
{ … }

PostResult TIntermRebuild::visitIfElsePost(TIntermIfElse &node)
{ … }

PostResult TIntermRebuild::visitSwitchPost(TIntermSwitch &node)
{ … }

PostResult TIntermRebuild::visitCasePost(TIntermCase &node)
{ … }

PostResult TIntermRebuild::visitLoopPost(TIntermLoop &node)
{ … }

PostResult TIntermRebuild::visitBranchPost(TIntermBranch &node)
{ … }

PostResult TIntermRebuild::visitDeclarationPost(TIntermDeclaration &node)
{ … }

PostResult TIntermRebuild::visitBlockPost(TIntermBlock &node)
{ … }

PostResult TIntermRebuild::visitAggregatePost(TIntermAggregate &node)
{ … }

PostResult TIntermRebuild::visitFunctionDefinitionPost(TIntermFunctionDefinition &node)
{ … }

PostResult TIntermRebuild::visitGlobalQualifierDeclarationPost(
    TIntermGlobalQualifierDeclaration &node)
{ … }

}  // namespace sh