Source code
Revision control
Copy as Markdown
Other Tools
//
// 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/tree_util/AsNode.h"
#include "compiler/translator/tree_util/IntermRebuild.h"
#define GUARD2(cond, failVal) \
do \
{ \
if (!(cond)) \
{ \
return failVal; \
} \
} while (false)
#define GUARD(cond) GUARD2(cond, nullptr)
namespace sh
{
template <typename T, typename U>
ANGLE_INLINE bool AllBits(T haystack, U needle)
{
return (haystack & needle) == needle;
}
template <typename T, typename U>
ANGLE_INLINE bool AnyBits(T haystack, U needle)
{
return (haystack & needle) != 0;
}
////////////////////////////////////////////////////////////////////////////////
TIntermRebuild::BaseResult::BaseResult(BaseResult &other)
: mAction(other.mAction),
mVisit(other.mVisit),
mSingle(other.mSingle),
mMulti(std::move(other.mMulti))
{}
TIntermRebuild::BaseResult::BaseResult(TIntermNode &node, VisitBits visit)
: mAction(Action::ReplaceSingle), mVisit(visit), mSingle(&node)
{}
TIntermRebuild::BaseResult::BaseResult(TIntermNode *node, VisitBits visit)
: mAction(node ? Action::ReplaceSingle : Action::Drop),
mVisit(node ? visit : VisitBits::Neither),
mSingle(node)
{}
TIntermRebuild::BaseResult::BaseResult(std::nullptr_t)
: mAction(Action::Drop), mVisit(VisitBits::Neither), mSingle(nullptr)
{}
TIntermRebuild::BaseResult::BaseResult(Fail)
: mAction(Action::Fail), mVisit(VisitBits::Neither), mSingle(nullptr)
{}
TIntermRebuild::BaseResult::BaseResult(std::vector<TIntermNode *> &&nodes)
: mAction(Action::ReplaceMulti),
mVisit(VisitBits::Neither),
mSingle(nullptr),
mMulti(std::move(nodes))
{}
void TIntermRebuild::BaseResult::moveAssignImpl(BaseResult &other)
{
mAction = other.mAction;
mVisit = other.mVisit;
mSingle = other.mSingle;
mMulti = std::move(other.mMulti);
}
TIntermRebuild::BaseResult TIntermRebuild::BaseResult::Multi(std::vector<TIntermNode *> &&nodes)
{
auto it = std::remove(nodes.begin(), nodes.end(), nullptr);
nodes.erase(it, nodes.end());
return std::move(nodes);
}
bool TIntermRebuild::BaseResult::isFail() const
{
return mAction == Action::Fail;
}
bool TIntermRebuild::BaseResult::isDrop() const
{
return mAction == Action::Drop;
}
TIntermNode *TIntermRebuild::BaseResult::single() const
{
return mSingle;
}
const std::vector<TIntermNode *> *TIntermRebuild::BaseResult::multi() const
{
if (mAction == Action::ReplaceMulti)
{
return &mMulti;
}
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////
using PreResult = TIntermRebuild::PreResult;
PreResult::PreResult(TIntermNode &node, VisitBits visit) : BaseResult(node, visit) {}
PreResult::PreResult(TIntermNode *node, VisitBits visit) : BaseResult(node, visit) {}
PreResult::PreResult(std::nullptr_t) : BaseResult(nullptr) {}
PreResult::PreResult(Fail) : BaseResult(Fail()) {}
PreResult::PreResult(BaseResult &&other) : BaseResult(other) {}
PreResult::PreResult(PreResult &&other) : BaseResult(other) {}
void PreResult::operator=(PreResult &&other)
{
moveAssignImpl(other);
}
////////////////////////////////////////////////////////////////////////////////
using PostResult = TIntermRebuild::PostResult;
PostResult::PostResult(TIntermNode &node) : BaseResult(node, VisitBits::Neither) {}
PostResult::PostResult(TIntermNode *node) : BaseResult(node, VisitBits::Neither) {}
PostResult::PostResult(std::nullptr_t) : BaseResult(nullptr) {}
PostResult::PostResult(Fail) : BaseResult(Fail()) {}
PostResult::PostResult(PostResult &&other) : BaseResult(other) {}
PostResult::PostResult(BaseResult &&other) : BaseResult(other) {}
void PostResult::operator=(PostResult &&other)
{
moveAssignImpl(other);
}
////////////////////////////////////////////////////////////////////////////////
TIntermRebuild::TIntermRebuild(TCompiler &compiler, bool preVisit, bool postVisit)
: mCompiler(compiler),
mSymbolTable(compiler.getSymbolTable()),
mPreVisit(preVisit),
mPostVisit(postVisit)
{
ASSERT(preVisit || postVisit);
}
TIntermRebuild::~TIntermRebuild()
{
ASSERT(!mNodeStack.value);
ASSERT(!mNodeStack.tail);
}
const TFunction *TIntermRebuild::getParentFunction() const
{
return mParentFunc;
}
TIntermNode *TIntermRebuild::getParentNode(size_t offset) const
{
ASSERT(mNodeStack.tail);
auto parent = *mNodeStack.tail;
while (offset > 0)
{
--offset;
ASSERT(parent.tail);
parent = *parent.tail;
}
return parent.value;
}
bool TIntermRebuild::rebuildRoot(TIntermBlock &root)
{
if (!rebuildInPlace(root))
{
return false;
}
return mCompiler.validateAST(&root);
}
bool TIntermRebuild::rebuildInPlace(TIntermAggregate &node)
{
return rebuildInPlaceImpl(node);
}
bool TIntermRebuild::rebuildInPlace(TIntermBlock &node)
{
return rebuildInPlaceImpl(node);
}
bool TIntermRebuild::rebuildInPlace(TIntermDeclaration &node)
{
return rebuildInPlaceImpl(node);
}
template <typename Node>
bool TIntermRebuild::rebuildInPlaceImpl(Node &node)
{
auto *newNode = traverseAnyAs<Node>(node);
if (!newNode)
{
return false;
}
if (newNode != &node)
{
*node.getSequence() = std::move(*newNode->getSequence());
}
return true;
}
PostResult TIntermRebuild::rebuild(TIntermNode &node)
{
return traverseAny(node);
}
////////////////////////////////////////////////////////////////////////////////
template <typename Node>
Node *TIntermRebuild::traverseAnyAs(TIntermNode &node)
{
PostResult result(traverseAny(node));
if (result.mAction == Action::Fail || !result.mSingle)
{
return nullptr;
}
return asNode<Node>(result.mSingle);
}
template <typename Node>
bool TIntermRebuild::traverseAnyAs(TIntermNode &node, Node *&out)
{
PostResult result(traverseAny(node));
if (result.mAction == Action::Fail || result.mAction == Action::ReplaceMulti)
{
return false;
}
if (!result.mSingle)
{
return true;
}
out = asNode<Node>(result.mSingle);
return out != nullptr;
}
bool TIntermRebuild::traverseAggregateBaseChildren(TIntermAggregateBase &node)
{
auto *const children = node.getSequence();
ASSERT(children);
TIntermSequence newChildren;
for (TIntermNode *child : *children)
{
ASSERT(child);
PostResult result(traverseAny(*child));
switch (result.mAction)
{
case Action::ReplaceSingle:
newChildren.push_back(result.mSingle);
break;
case Action::ReplaceMulti:
for (TIntermNode *newNode : result.mMulti)
{
if (newNode)
{
newChildren.push_back(newNode);
}
}
break;
case Action::Drop:
break;
case Action::Fail:
return false;
default:
ASSERT(false);
return false;
}
}
*children = std::move(newChildren);
return true;
}
////////////////////////////////////////////////////////////////////////////////
struct TIntermRebuild::NodeStackGuard
{
ConsList<TIntermNode *> oldNodeStack;
ConsList<TIntermNode *> &nodeStack;
NodeStackGuard(ConsList<TIntermNode *> &nodeStack, TIntermNode *node)
: oldNodeStack(nodeStack), nodeStack(nodeStack)
{
nodeStack = {node, &oldNodeStack};
}
~NodeStackGuard() { nodeStack = oldNodeStack; }
};
PostResult TIntermRebuild::traverseAny(TIntermNode &originalNode)
{
PreResult preResult = traversePre(originalNode);
if (!preResult.mSingle)
{
ASSERT(preResult.mVisit == VisitBits::Neither);
return std::move(preResult);
}
TIntermNode *currNode = preResult.mSingle;
const VisitBits visit = preResult.mVisit;
const NodeType currNodeType = getNodeType(*currNode);
currNode = traverseChildren(currNodeType, originalNode, *currNode, visit);
if (!currNode)
{
return Fail();
}
return traversePost(currNodeType, originalNode, *currNode, visit);
}
PreResult TIntermRebuild::traversePre(TIntermNode &originalNode)
{
if (!mPreVisit)
{
return {originalNode, VisitBits::Both};
}
NodeStackGuard guard(mNodeStack, &originalNode);
const NodeType originalNodeType = getNodeType(originalNode);
switch (originalNodeType)
{
case NodeType::Unknown:
ASSERT(false);
return Fail();
case NodeType::Symbol:
return visitSymbolPre(*originalNode.getAsSymbolNode());
case NodeType::ConstantUnion:
return visitConstantUnionPre(*originalNode.getAsConstantUnion());
case NodeType::FunctionPrototype:
return visitFunctionPrototypePre(*originalNode.getAsFunctionPrototypeNode());
case NodeType::PreprocessorDirective:
return visitPreprocessorDirectivePre(*originalNode.getAsPreprocessorDirective());
case NodeType::Unary:
return visitUnaryPre(*originalNode.getAsUnaryNode());
case NodeType::Binary:
return visitBinaryPre(*originalNode.getAsBinaryNode());
case NodeType::Ternary:
return visitTernaryPre(*originalNode.getAsTernaryNode());
case NodeType::Swizzle:
return visitSwizzlePre(*originalNode.getAsSwizzleNode());
case NodeType::IfElse:
return visitIfElsePre(*originalNode.getAsIfElseNode());
case NodeType::Switch:
return visitSwitchPre(*originalNode.getAsSwitchNode());
case NodeType::Case:
return visitCasePre(*originalNode.getAsCaseNode());
case NodeType::FunctionDefinition:
return visitFunctionDefinitionPre(*originalNode.getAsFunctionDefinition());
case NodeType::Aggregate:
return visitAggregatePre(*originalNode.getAsAggregate());
case NodeType::Block:
return visitBlockPre(*originalNode.getAsBlock());
case NodeType::GlobalQualifierDeclaration:
return visitGlobalQualifierDeclarationPre(
*originalNode.getAsGlobalQualifierDeclarationNode());
case NodeType::Declaration:
return visitDeclarationPre(*originalNode.getAsDeclarationNode());
case NodeType::Loop:
return visitLoopPre(*originalNode.getAsLoopNode());
case NodeType::Branch:
return visitBranchPre(*originalNode.getAsBranchNode());
default:
ASSERT(false);
return Fail();
}
}
TIntermNode *TIntermRebuild::traverseChildren(NodeType currNodeType,
const TIntermNode &originalNode,
TIntermNode &currNode,
VisitBits visit)
{
if (!AnyBits(visit, VisitBits::Children))
{
return &currNode;
}
if (AnyBits(visit, VisitBits::ChildrenRequiresSame) && &originalNode != &currNode)
{
return &currNode;
}
NodeStackGuard guard(mNodeStack, &currNode);
switch (currNodeType)
{
case NodeType::Unknown:
ASSERT(false);
return nullptr;
case NodeType::Symbol:
return &currNode;
case NodeType::ConstantUnion:
return &currNode;
case NodeType::FunctionPrototype:
return &currNode;
case NodeType::PreprocessorDirective:
return &currNode;
case NodeType::Unary:
return traverseUnaryChildren(*currNode.getAsUnaryNode());
case NodeType::Binary:
return traverseBinaryChildren(*currNode.getAsBinaryNode());
case NodeType::Ternary:
return traverseTernaryChildren(*currNode.getAsTernaryNode());
case NodeType::Swizzle:
return traverseSwizzleChildren(*currNode.getAsSwizzleNode());
case NodeType::IfElse:
return traverseIfElseChildren(*currNode.getAsIfElseNode());
case NodeType::Switch:
return traverseSwitchChildren(*currNode.getAsSwitchNode());
case NodeType::Case:
return traverseCaseChildren(*currNode.getAsCaseNode());
case NodeType::FunctionDefinition:
return traverseFunctionDefinitionChildren(*currNode.getAsFunctionDefinition());
case NodeType::Aggregate:
return traverseAggregateChildren(*currNode.getAsAggregate());
case NodeType::Block:
return traverseBlockChildren(*currNode.getAsBlock());
case NodeType::GlobalQualifierDeclaration:
return traverseGlobalQualifierDeclarationChildren(
*currNode.getAsGlobalQualifierDeclarationNode());
case NodeType::Declaration:
return traverseDeclarationChildren(*currNode.getAsDeclarationNode());
case NodeType::Loop:
return traverseLoopChildren(*currNode.getAsLoopNode());
case NodeType::Branch:
return traverseBranchChildren(*currNode.getAsBranchNode());
default:
ASSERT(false);
return nullptr;
}
}
PostResult TIntermRebuild::traversePost(NodeType currNodeType,
const TIntermNode &originalNode,
TIntermNode &currNode,
VisitBits visit)
{
if (!mPostVisit)
{
return currNode;
}
if (!AnyBits(visit, VisitBits::Post))
{
return currNode;
}
if (AnyBits(visit, VisitBits::PostRequiresSame) && &originalNode != &currNode)
{
return currNode;
}
NodeStackGuard guard(mNodeStack, &currNode);
switch (currNodeType)
{
case NodeType::Unknown:
ASSERT(false);
return Fail();
case NodeType::Symbol:
return visitSymbolPost(*currNode.getAsSymbolNode());
case NodeType::ConstantUnion:
return visitConstantUnionPost(*currNode.getAsConstantUnion());
case NodeType::FunctionPrototype:
return visitFunctionPrototypePost(*currNode.getAsFunctionPrototypeNode());
case NodeType::PreprocessorDirective:
return visitPreprocessorDirectivePost(*currNode.getAsPreprocessorDirective());
case NodeType::Unary:
return visitUnaryPost(*currNode.getAsUnaryNode());
case NodeType::Binary:
return visitBinaryPost(*currNode.getAsBinaryNode());
case NodeType::Ternary:
return visitTernaryPost(*currNode.getAsTernaryNode());
case NodeType::Swizzle:
return visitSwizzlePost(*currNode.getAsSwizzleNode());
case NodeType::IfElse:
return visitIfElsePost(*currNode.getAsIfElseNode());
case NodeType::Switch:
return visitSwitchPost(*currNode.getAsSwitchNode());
case NodeType::Case:
return visitCasePost(*currNode.getAsCaseNode());
case NodeType::FunctionDefinition:
return visitFunctionDefinitionPost(*currNode.getAsFunctionDefinition());
case NodeType::Aggregate:
return visitAggregatePost(*currNode.getAsAggregate());
case NodeType::Block:
return visitBlockPost(*currNode.getAsBlock());
case NodeType::GlobalQualifierDeclaration:
return visitGlobalQualifierDeclarationPost(
*currNode.getAsGlobalQualifierDeclarationNode());
case NodeType::Declaration:
return visitDeclarationPost(*currNode.getAsDeclarationNode());
case NodeType::Loop:
return visitLoopPost(*currNode.getAsLoopNode());
case NodeType::Branch:
return visitBranchPost(*currNode.getAsBranchNode());
default:
ASSERT(false);
return Fail();
}
}
////////////////////////////////////////////////////////////////////////////////
TIntermNode *TIntermRebuild::traverseAggregateChildren(TIntermAggregate &node)
{
if (traverseAggregateBaseChildren(node))
{
return &node;
}
return nullptr;
}
TIntermNode *TIntermRebuild::traverseBlockChildren(TIntermBlock &node)
{
if (traverseAggregateBaseChildren(node))
{
return &node;
}
return nullptr;
}
TIntermNode *TIntermRebuild::traverseDeclarationChildren(TIntermDeclaration &node)
{
if (traverseAggregateBaseChildren(node))
{
return &node;
}
return nullptr;
}
TIntermNode *TIntermRebuild::traverseSwizzleChildren(TIntermSwizzle &node)
{
auto *const operand = node.getOperand();
ASSERT(operand);
auto *newOperand = traverseAnyAs<TIntermTyped>(*operand);
GUARD(newOperand);
if (newOperand != operand)
{
return new TIntermSwizzle(newOperand, node.getSwizzleOffsets());
}
return &node;
}
TIntermNode *TIntermRebuild::traverseBinaryChildren(TIntermBinary &node)
{
auto *const left = node.getLeft();
ASSERT(left);
auto *const right = node.getRight();
ASSERT(right);
auto *const newLeft = traverseAnyAs<TIntermTyped>(*left);
GUARD(newLeft);
auto *const newRight = traverseAnyAs<TIntermTyped>(*right);
GUARD(newRight);
if (newLeft != left || newRight != right)
{
TOperator op = node.getOp();
switch (op)
{
case TOperator::EOpIndexDirectStruct:
{
if (newLeft->getType().getInterfaceBlock())
{
op = TOperator::EOpIndexDirectInterfaceBlock;
}
}
break;
case TOperator::EOpIndexDirectInterfaceBlock:
{
if (newLeft->getType().getStruct())
{
op = TOperator::EOpIndexDirectStruct;
}
}
break;
case TOperator::EOpComma:
return TIntermBinary::CreateComma(newLeft, newRight, mCompiler.getShaderVersion());
default:
break;
}
return new TIntermBinary(op, newLeft, newRight);
}
return &node;
}
TIntermNode *TIntermRebuild::traverseUnaryChildren(TIntermUnary &node)
{
auto *const operand = node.getOperand();
ASSERT(operand);
auto *const newOperand = traverseAnyAs<TIntermTyped>(*operand);
GUARD(newOperand);
if (newOperand != operand)
{
return new TIntermUnary(node.getOp(), newOperand, node.getFunction());
}
return &node;
}
TIntermNode *TIntermRebuild::traverseTernaryChildren(TIntermTernary &node)
{
auto *const cond = node.getCondition();
ASSERT(cond);
auto *const true_ = node.getTrueExpression();
ASSERT(true_);
auto *const false_ = node.getFalseExpression();
ASSERT(false_);
auto *const newCond = traverseAnyAs<TIntermTyped>(*cond);
GUARD(newCond);
auto *const newTrue = traverseAnyAs<TIntermTyped>(*true_);
GUARD(newTrue);
auto *const newFalse = traverseAnyAs<TIntermTyped>(*false_);
GUARD(newFalse);
if (newCond != cond || newTrue != true_ || newFalse != false_)
{
return new TIntermTernary(newCond, newTrue, newFalse);
}
return &node;
}
TIntermNode *TIntermRebuild::traverseIfElseChildren(TIntermIfElse &node)
{
auto *const cond = node.getCondition();
ASSERT(cond);
auto *const true_ = node.getTrueBlock();
auto *const false_ = node.getFalseBlock();
auto *const newCond = traverseAnyAs<TIntermTyped>(*cond);
GUARD(newCond);
TIntermBlock *newTrue = nullptr;
if (true_)
{
GUARD(traverseAnyAs(*true_, newTrue));
}
TIntermBlock *newFalse = nullptr;
if (false_)
{
GUARD(traverseAnyAs(*false_, newFalse));
}
if (newCond != cond || newTrue != true_ || newFalse != false_)
{
return new TIntermIfElse(newCond, newTrue, newFalse);
}
return &node;
}
TIntermNode *TIntermRebuild::traverseSwitchChildren(TIntermSwitch &node)
{
auto *const init = node.getInit();
ASSERT(init);
auto *const stmts = node.getStatementList();
ASSERT(stmts);
auto *const newInit = traverseAnyAs<TIntermTyped>(*init);
GUARD(newInit);
auto *const newStmts = traverseAnyAs<TIntermBlock>(*stmts);
GUARD(newStmts);
if (newInit != init || newStmts != stmts)
{
return new TIntermSwitch(newInit, newStmts);
}
return &node;
}
TIntermNode *TIntermRebuild::traverseCaseChildren(TIntermCase &node)
{
auto *const cond = node.getCondition();
TIntermTyped *newCond = nullptr;
if (cond)
{
GUARD(traverseAnyAs(*cond, newCond));
}
if (newCond != cond)
{
return new TIntermCase(newCond);
}
return &node;
}
TIntermNode *TIntermRebuild::traverseFunctionDefinitionChildren(TIntermFunctionDefinition &node)
{
GUARD(!mParentFunc); // Function definitions cannot be nested.
mParentFunc = node.getFunction();
struct OnExit
{
const TFunction *&parentFunc;
OnExit(const TFunction *&parentFunc) : parentFunc(parentFunc) {}
~OnExit() { parentFunc = nullptr; }
} onExit(mParentFunc);
auto *const proto = node.getFunctionPrototype();
ASSERT(proto);
auto *const body = node.getBody();
ASSERT(body);
auto *const newProto = traverseAnyAs<TIntermFunctionPrototype>(*proto);
GUARD(newProto);
auto *const newBody = traverseAnyAs<TIntermBlock>(*body);
GUARD(newBody);
if (newProto != proto || newBody != body)
{
return new TIntermFunctionDefinition(newProto, newBody);
}
return &node;
}
TIntermNode *TIntermRebuild::traverseGlobalQualifierDeclarationChildren(
TIntermGlobalQualifierDeclaration &node)
{
auto *const symbol = node.getSymbol();
ASSERT(symbol);
auto *const newSymbol = traverseAnyAs<TIntermSymbol>(*symbol);
GUARD(newSymbol);
if (newSymbol != symbol)
{
return new TIntermGlobalQualifierDeclaration(newSymbol, node.isPrecise(), node.getLine());
}
return &node;
}
TIntermNode *TIntermRebuild::traverseLoopChildren(TIntermLoop &node)
{
const TLoopType loopType = node.getType();
auto *const init = node.getInit();
auto *const cond = node.getCondition();
auto *const expr = node.getExpression();
auto *const body = node.getBody();
ASSERT(body);
#if defined(ANGLE_ENABLE_ASSERTS)
switch (loopType)
{
case TLoopType::ELoopFor:
break;
case TLoopType::ELoopWhile:
case TLoopType::ELoopDoWhile:
ASSERT(cond);
ASSERT(!init && !expr);
break;
default:
ASSERT(false);
break;
}
#endif
auto *const newBody = traverseAnyAs<TIntermBlock>(*body);
GUARD(newBody);
TIntermNode *newInit = nullptr;
if (init)
{
GUARD(traverseAnyAs(*init, newInit));
}
TIntermTyped *newCond = nullptr;
if (cond)
{
GUARD(traverseAnyAs(*cond, newCond));
}
TIntermTyped *newExpr = nullptr;
if (expr)
{
GUARD(traverseAnyAs(*expr, newExpr));
}
if (newInit != init || newCond != cond || newExpr != expr || newBody != body)
{
switch (loopType)
{
case TLoopType::ELoopFor:
GUARD(newBody);
break;
case TLoopType::ELoopWhile:
case TLoopType::ELoopDoWhile:
GUARD(newCond && newBody);
GUARD(!newInit && !newExpr);
break;
default:
ASSERT(false);
break;
}
return new TIntermLoop(loopType, newInit, newCond, newExpr, newBody);
}
return &node;
}
TIntermNode *TIntermRebuild::traverseBranchChildren(TIntermBranch &node)
{
auto *const expr = node.getExpression();
TIntermTyped *newExpr = nullptr;
if (expr)
{
GUARD(traverseAnyAs<TIntermTyped>(*expr, newExpr));
}
if (newExpr != expr)
{
return new TIntermBranch(node.getFlowOp(), newExpr);
}
return &node;
}
////////////////////////////////////////////////////////////////////////////////
PreResult TIntermRebuild::visitSymbolPre(TIntermSymbol &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitConstantUnionPre(TIntermConstantUnion &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitFunctionPrototypePre(TIntermFunctionPrototype &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitPreprocessorDirectivePre(TIntermPreprocessorDirective &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitUnaryPre(TIntermUnary &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitBinaryPre(TIntermBinary &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitTernaryPre(TIntermTernary &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitSwizzlePre(TIntermSwizzle &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitIfElsePre(TIntermIfElse &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitSwitchPre(TIntermSwitch &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitCasePre(TIntermCase &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitLoopPre(TIntermLoop &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitBranchPre(TIntermBranch &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitDeclarationPre(TIntermDeclaration &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitBlockPre(TIntermBlock &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitAggregatePre(TIntermAggregate &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitFunctionDefinitionPre(TIntermFunctionDefinition &node)
{
return {node, VisitBits::Both};
}
PreResult TIntermRebuild::visitGlobalQualifierDeclarationPre(
TIntermGlobalQualifierDeclaration &node)
{
return {node, VisitBits::Both};
}
////////////////////////////////////////////////////////////////////////////////
PostResult TIntermRebuild::visitSymbolPost(TIntermSymbol &node)
{
return node;
}
PostResult TIntermRebuild::visitConstantUnionPost(TIntermConstantUnion &node)
{
return node;
}
PostResult TIntermRebuild::visitFunctionPrototypePost(TIntermFunctionPrototype &node)
{
return node;
}
PostResult TIntermRebuild::visitPreprocessorDirectivePost(TIntermPreprocessorDirective &node)
{
return node;
}
PostResult TIntermRebuild::visitUnaryPost(TIntermUnary &node)
{
return node;
}
PostResult TIntermRebuild::visitBinaryPost(TIntermBinary &node)
{
return node;
}
PostResult TIntermRebuild::visitTernaryPost(TIntermTernary &node)
{
return node;
}
PostResult TIntermRebuild::visitSwizzlePost(TIntermSwizzle &node)
{
return node;
}
PostResult TIntermRebuild::visitIfElsePost(TIntermIfElse &node)
{
return node;
}
PostResult TIntermRebuild::visitSwitchPost(TIntermSwitch &node)
{
return node;
}
PostResult TIntermRebuild::visitCasePost(TIntermCase &node)
{
return node;
}
PostResult TIntermRebuild::visitLoopPost(TIntermLoop &node)
{
return node;
}
PostResult TIntermRebuild::visitBranchPost(TIntermBranch &node)
{
return node;
}
PostResult TIntermRebuild::visitDeclarationPost(TIntermDeclaration &node)
{
return node;
}
PostResult TIntermRebuild::visitBlockPost(TIntermBlock &node)
{
return node;
}
PostResult TIntermRebuild::visitAggregatePost(TIntermAggregate &node)
{
return node;
}
PostResult TIntermRebuild::visitFunctionDefinitionPost(TIntermFunctionDefinition &node)
{
return node;
}
PostResult TIntermRebuild::visitGlobalQualifierDeclarationPost(
TIntermGlobalQualifierDeclaration &node)
{
return node;
}
} // namespace sh