| // |
| // Copyright (c) 2002-2014 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 "compiler/translator/Intermediate.h" |
| #include "compiler/translator/SymbolTable.h" |
| |
| namespace |
| { |
| |
| void OutputFunction(TInfoSinkBase &out, const char *str, TFunctionSymbolInfo *info) |
| { |
| const char *internal = info->getNameObj().isInternal() ? " (internal function)" : ""; |
| out << str << internal << ": " << info->getNameObj().getString() << " (symbol id " |
| << info->getId() << ")"; |
| } |
| |
| // |
| // Two purposes: |
| // 1. Show an example of how to iterate tree. Functions can |
| // also directly call Traverse() on children themselves to |
| // have finer grained control over the process than shown here. |
| // See the last function for how to get started. |
| // 2. Print out a text based description of the tree. |
| // |
| |
| // |
| // Use this class to carry along data from node to node in |
| // the traversal |
| // |
| class TOutputTraverser : public TIntermTraverser |
| { |
| public: |
| TOutputTraverser(TInfoSinkBase &i) |
| : TIntermTraverser(true, false, false), |
| sink(i) |
| { |
| } |
| TInfoSinkBase& sink; |
| |
| protected: |
| void visitSymbol(TIntermSymbol *) override; |
| void visitConstantUnion(TIntermConstantUnion *) override; |
| bool visitSwizzle(Visit visit, TIntermSwizzle *node) override; |
| bool visitBinary(Visit visit, TIntermBinary *) override; |
| bool visitUnary(Visit visit, TIntermUnary *) override; |
| bool visitTernary(Visit visit, TIntermTernary *node) override; |
| bool visitIfElse(Visit visit, TIntermIfElse *node) override; |
| bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override; |
| bool visitAggregate(Visit visit, TIntermAggregate *) override; |
| bool visitBlock(Visit visit, TIntermBlock *) override; |
| bool visitLoop(Visit visit, TIntermLoop *) override; |
| bool visitBranch(Visit visit, TIntermBranch *) override; |
| // TODO: Add missing visit functions |
| }; |
| |
| // |
| // Helper functions for printing, not part of traversing. |
| // |
| void OutputTreeText(TInfoSinkBase &sink, TIntermNode *node, const int depth) |
| { |
| int i; |
| |
| sink.location(node->getLine()); |
| |
| for (i = 0; i < depth; ++i) |
| sink << " "; |
| } |
| |
| } // namespace anonymous |
| |
| // |
| // The rest of the file are the traversal functions. The last one |
| // is the one that starts the traversal. |
| // |
| // Return true from interior nodes to have the external traversal |
| // continue on to children. If you process children yourself, |
| // return false. |
| // |
| |
| void TOutputTraverser::visitSymbol(TIntermSymbol *node) |
| { |
| OutputTreeText(sink, node, mDepth); |
| |
| sink << "'" << node->getSymbol() << "' "; |
| sink << "(" << node->getCompleteString() << ")\n"; |
| } |
| |
| bool TOutputTraverser::visitSwizzle(Visit visit, TIntermSwizzle *node) |
| { |
| TInfoSinkBase &out = sink; |
| OutputTreeText(out, node, mDepth); |
| out << "vector swizzle"; |
| return true; |
| } |
| |
| bool TOutputTraverser::visitBinary(Visit visit, TIntermBinary *node) |
| { |
| TInfoSinkBase& out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| |
| switch (node->getOp()) |
| { |
| case EOpAssign: |
| out << "move second child to first child"; |
| break; |
| case EOpInitialize: |
| out << "initialize first child with second child"; |
| break; |
| case EOpAddAssign: |
| out << "add second child into first child"; |
| break; |
| case EOpSubAssign: |
| out << "subtract second child into first child"; |
| break; |
| case EOpMulAssign: |
| out << "multiply second child into first child"; |
| break; |
| case EOpVectorTimesMatrixAssign: |
| out << "matrix mult second child into first child"; |
| break; |
| case EOpVectorTimesScalarAssign: |
| out << "vector scale second child into first child"; |
| break; |
| case EOpMatrixTimesScalarAssign: |
| out << "matrix scale second child into first child"; |
| break; |
| case EOpMatrixTimesMatrixAssign: |
| out << "matrix mult second child into first child"; |
| break; |
| case EOpDivAssign: |
| out << "divide second child into first child"; |
| break; |
| case EOpIModAssign: |
| out << "modulo second child into first child"; |
| break; |
| case EOpBitShiftLeftAssign: |
| out << "bit-wise shift first child left by second child"; |
| break; |
| case EOpBitShiftRightAssign: |
| out << "bit-wise shift first child right by second child"; |
| break; |
| case EOpBitwiseAndAssign: |
| out << "bit-wise and second child into first child"; |
| break; |
| case EOpBitwiseXorAssign: |
| out << "bit-wise xor second child into first child"; |
| break; |
| case EOpBitwiseOrAssign: |
| out << "bit-wise or second child into first child"; |
| break; |
| |
| case EOpIndexDirect: |
| out << "direct index"; |
| break; |
| case EOpIndexIndirect: |
| out << "indirect index"; |
| break; |
| case EOpIndexDirectStruct: |
| out << "direct index for structure"; |
| break; |
| case EOpIndexDirectInterfaceBlock: |
| out << "direct index for interface block"; |
| break; |
| |
| case EOpAdd: |
| out << "add"; |
| break; |
| case EOpSub: |
| out << "subtract"; |
| break; |
| case EOpMul: |
| out << "component-wise multiply"; |
| break; |
| case EOpDiv: |
| out << "divide"; |
| break; |
| case EOpIMod: |
| out << "modulo"; |
| break; |
| case EOpBitShiftLeft: |
| out << "bit-wise shift left"; |
| break; |
| case EOpBitShiftRight: |
| out << "bit-wise shift right"; |
| break; |
| case EOpBitwiseAnd: |
| out << "bit-wise and"; |
| break; |
| case EOpBitwiseXor: |
| out << "bit-wise xor"; |
| break; |
| case EOpBitwiseOr: |
| out << "bit-wise or"; |
| break; |
| |
| case EOpEqual: |
| out << "Compare Equal"; |
| break; |
| case EOpNotEqual: |
| out << "Compare Not Equal"; |
| break; |
| case EOpLessThan: |
| out << "Compare Less Than"; |
| break; |
| case EOpGreaterThan: |
| out << "Compare Greater Than"; |
| break; |
| case EOpLessThanEqual: |
| out << "Compare Less Than or Equal"; |
| break; |
| case EOpGreaterThanEqual: |
| out << "Compare Greater Than or Equal"; |
| break; |
| |
| case EOpVectorTimesScalar: |
| out << "vector-scale"; |
| break; |
| case EOpVectorTimesMatrix: |
| out << "vector-times-matrix"; |
| break; |
| case EOpMatrixTimesVector: |
| out << "matrix-times-vector"; |
| break; |
| case EOpMatrixTimesScalar: |
| out << "matrix-scale"; |
| break; |
| case EOpMatrixTimesMatrix: |
| out << "matrix-multiply"; |
| break; |
| |
| case EOpLogicalOr: |
| out << "logical-or"; |
| break; |
| case EOpLogicalXor: |
| out << "logical-xor"; |
| break; |
| case EOpLogicalAnd: |
| out << "logical-and"; |
| break; |
| default: |
| out << "<unknown op>"; |
| } |
| |
| out << " (" << node->getCompleteString() << ")"; |
| |
| out << "\n"; |
| |
| // Special handling for direct indexes. Because constant |
| // unions are not aware they are struct indexes, treat them |
| // here where we have that contextual knowledge. |
| if (node->getOp() == EOpIndexDirectStruct || |
| node->getOp() == EOpIndexDirectInterfaceBlock) |
| { |
| mDepth++; |
| node->getLeft()->traverse(this); |
| mDepth--; |
| |
| TIntermConstantUnion *intermConstantUnion = node->getRight()->getAsConstantUnion(); |
| ASSERT(intermConstantUnion); |
| |
| OutputTreeText(out, intermConstantUnion, mDepth + 1); |
| |
| // The following code finds the field name from the constant union |
| const TConstantUnion *constantUnion = intermConstantUnion->getUnionArrayPointer(); |
| const TStructure *structure = node->getLeft()->getType().getStruct(); |
| const TInterfaceBlock *interfaceBlock = node->getLeft()->getType().getInterfaceBlock(); |
| ASSERT(structure || interfaceBlock); |
| |
| const TFieldList &fields = structure ? structure->fields() : interfaceBlock->fields(); |
| |
| const TField *field = fields[constantUnion->getIConst()]; |
| |
| out << constantUnion->getIConst() << " (field '" << field->name() << "')"; |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool TOutputTraverser::visitUnary(Visit visit, TIntermUnary *node) |
| { |
| TInfoSinkBase& out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| |
| switch (node->getOp()) |
| { |
| case EOpNegative: out << "Negate value"; break; |
| case EOpPositive: out << "Positive sign"; break; |
| case EOpVectorLogicalNot: |
| case EOpLogicalNot: out << "Negate conditional"; break; |
| case EOpBitwiseNot: out << "bit-wise not"; break; |
| |
| case EOpPostIncrement: out << "Post-Increment"; break; |
| case EOpPostDecrement: out << "Post-Decrement"; break; |
| case EOpPreIncrement: out << "Pre-Increment"; break; |
| case EOpPreDecrement: out << "Pre-Decrement"; break; |
| |
| case EOpRadians: out << "radians"; break; |
| case EOpDegrees: out << "degrees"; break; |
| case EOpSin: out << "sine"; break; |
| case EOpCos: out << "cosine"; break; |
| case EOpTan: out << "tangent"; break; |
| case EOpAsin: out << "arc sine"; break; |
| case EOpAcos: out << "arc cosine"; break; |
| case EOpAtan: out << "arc tangent"; break; |
| |
| case EOpSinh: out << "hyperbolic sine"; break; |
| case EOpCosh: out << "hyperbolic cosine"; break; |
| case EOpTanh: out << "hyperbolic tangent"; break; |
| case EOpAsinh: out << "arc hyperbolic sine"; break; |
| case EOpAcosh: out << "arc hyperbolic cosine"; break; |
| case EOpAtanh: out << "arc hyperbolic tangent"; break; |
| |
| case EOpExp: out << "exp"; break; |
| case EOpLog: out << "log"; break; |
| case EOpExp2: out << "exp2"; break; |
| case EOpLog2: out << "log2"; break; |
| case EOpSqrt: out << "sqrt"; break; |
| case EOpInverseSqrt: out << "inverse sqrt"; break; |
| |
| case EOpAbs: out << "Absolute value"; break; |
| case EOpSign: out << "Sign"; break; |
| case EOpFloor: out << "Floor"; break; |
| case EOpTrunc: out << "Truncate"; break; |
| case EOpRound: out << "Round"; break; |
| case EOpRoundEven: out << "Round half even"; break; |
| case EOpCeil: out << "Ceiling"; break; |
| case EOpFract: out << "Fraction"; break; |
| case EOpIsNan: out << "Is not a number"; break; |
| case EOpIsInf: out << "Is infinity"; break; |
| |
| case EOpFloatBitsToInt: out << "float bits to int"; break; |
| case EOpFloatBitsToUint: out << "float bits to uint"; break; |
| case EOpIntBitsToFloat: out << "int bits to float"; break; |
| case EOpUintBitsToFloat: out << "uint bits to float"; break; |
| |
| case EOpPackSnorm2x16: out << "pack Snorm 2x16"; break; |
| case EOpPackUnorm2x16: out << "pack Unorm 2x16"; break; |
| case EOpPackHalf2x16: out << "pack half 2x16"; break; |
| |
| case EOpUnpackSnorm2x16: out << "unpack Snorm 2x16"; break; |
| case EOpUnpackUnorm2x16: out << "unpack Unorm 2x16"; break; |
| case EOpUnpackHalf2x16: out << "unpack half 2x16"; break; |
| |
| case EOpLength: out << "length"; break; |
| case EOpNormalize: out << "normalize"; break; |
| // case EOpDPdx: out << "dPdx"; break; |
| // case EOpDPdy: out << "dPdy"; break; |
| // case EOpFwidth: out << "fwidth"; break; |
| |
| case EOpDeterminant: out << "determinant"; break; |
| case EOpTranspose: out << "transpose"; break; |
| case EOpInverse: out << "inverse"; break; |
| |
| case EOpAny: out << "any"; break; |
| case EOpAll: out << "all"; break; |
| |
| default: |
| out.prefix(EPrefixError); |
| out << "Bad unary op"; |
| } |
| |
| out << " (" << node->getCompleteString() << ")"; |
| |
| out << "\n"; |
| |
| return true; |
| } |
| |
| bool TOutputTraverser::visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) |
| { |
| TInfoSinkBase &out = sink; |
| OutputTreeText(out, node, mDepth); |
| OutputFunction(out, "Function Definition", node->getFunctionSymbolInfo()); |
| out << "\n"; |
| return true; |
| } |
| |
| bool TOutputTraverser::visitAggregate(Visit visit, TIntermAggregate *node) |
| { |
| TInfoSinkBase &out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| |
| if (node->getOp() == EOpNull) |
| { |
| out.prefix(EPrefixError); |
| out << "node is still EOpNull!\n"; |
| return true; |
| } |
| |
| |
| switch (node->getOp()) |
| { |
| case EOpComma: out << "Comma\n"; return true; |
| case EOpFunctionCall: |
| OutputFunction(out, "Function Call", node->getFunctionSymbolInfo()); |
| break; |
| case EOpParameters: out << "Function Parameters: "; break; |
| case EOpPrototype: |
| OutputFunction(out, "Function Prototype", node->getFunctionSymbolInfo()); |
| break; |
| |
| case EOpConstructFloat: out << "Construct float"; break; |
| case EOpConstructVec2: out << "Construct vec2"; break; |
| case EOpConstructVec3: out << "Construct vec3"; break; |
| case EOpConstructVec4: out << "Construct vec4"; break; |
| case EOpConstructBool: out << "Construct bool"; break; |
| case EOpConstructBVec2: out << "Construct bvec2"; break; |
| case EOpConstructBVec3: out << "Construct bvec3"; break; |
| case EOpConstructBVec4: out << "Construct bvec4"; break; |
| case EOpConstructInt: out << "Construct int"; break; |
| case EOpConstructIVec2: out << "Construct ivec2"; break; |
| case EOpConstructIVec3: out << "Construct ivec3"; break; |
| case EOpConstructIVec4: out << "Construct ivec4"; break; |
| case EOpConstructUInt: out << "Construct uint"; break; |
| case EOpConstructUVec2: out << "Construct uvec2"; break; |
| case EOpConstructUVec3: out << "Construct uvec3"; break; |
| case EOpConstructUVec4: out << "Construct uvec4"; break; |
| case EOpConstructMat2: out << "Construct mat2"; break; |
| case EOpConstructMat2x3: out << "Construct mat2x3"; break; |
| case EOpConstructMat2x4: out << "Construct mat2x4"; break; |
| case EOpConstructMat3x2: out << "Construct mat3x2"; break; |
| case EOpConstructMat3: out << "Construct mat3"; break; |
| case EOpConstructMat3x4: out << "Construct mat3x4"; break; |
| case EOpConstructMat4x2: out << "Construct mat4x2"; break; |
| case EOpConstructMat4x3: out << "Construct mat4x3"; break; |
| case EOpConstructMat4: out << "Construct mat4"; break; |
| case EOpConstructStruct: out << "Construct structure"; break; |
| |
| case EOpLessThan: out << "Compare Less Than"; break; |
| case EOpGreaterThan: out << "Compare Greater Than"; break; |
| case EOpLessThanEqual: out << "Compare Less Than or Equal"; break; |
| case EOpGreaterThanEqual: out << "Compare Greater Than or Equal"; break; |
| case EOpVectorEqual: out << "Equal"; break; |
| case EOpVectorNotEqual: out << "NotEqual"; break; |
| |
| case EOpMod: out << "mod"; break; |
| case EOpModf: out << "modf"; break; |
| case EOpPow: out << "pow"; break; |
| |
| case EOpAtan: out << "arc tangent"; break; |
| |
| case EOpMin: out << "min"; break; |
| case EOpMax: out << "max"; break; |
| case EOpClamp: out << "clamp"; break; |
| case EOpMix: out << "mix"; break; |
| case EOpStep: out << "step"; break; |
| case EOpSmoothStep: out << "smoothstep"; break; |
| |
| case EOpDistance: out << "distance"; break; |
| case EOpDot: out << "dot-product"; break; |
| case EOpCross: out << "cross-product"; break; |
| case EOpFaceForward: out << "face-forward"; break; |
| case EOpReflect: out << "reflect"; break; |
| case EOpRefract: out << "refract"; break; |
| case EOpMul: out << "component-wise multiply"; break; |
| |
| case EOpOuterProduct: out << "outer product"; break; |
| |
| case EOpDeclaration: out << "Declaration: "; break; |
| case EOpInvariantDeclaration: out << "Invariant Declaration: "; break; |
| |
| default: |
| out.prefix(EPrefixError); |
| out << "Bad aggregation op"; |
| } |
| |
| if (node->getOp() != EOpParameters) |
| out << " (" << node->getCompleteString() << ")"; |
| |
| out << "\n"; |
| |
| return true; |
| } |
| |
| bool TOutputTraverser::visitBlock(Visit visit, TIntermBlock *node) |
| { |
| TInfoSinkBase &out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| out << "Code block\n"; |
| |
| return true; |
| } |
| |
| bool TOutputTraverser::visitTernary(Visit visit, TIntermTernary *node) |
| { |
| TInfoSinkBase &out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| |
| out << "Ternary selection"; |
| out << " (" << node->getCompleteString() << ")\n"; |
| |
| ++mDepth; |
| |
| OutputTreeText(sink, node, mDepth); |
| out << "Condition\n"; |
| node->getCondition()->traverse(this); |
| |
| OutputTreeText(sink, node, mDepth); |
| if (node->getTrueExpression()) |
| { |
| out << "true case\n"; |
| node->getTrueExpression()->traverse(this); |
| } |
| if (node->getFalseExpression()) |
| { |
| OutputTreeText(sink, node, mDepth); |
| out << "false case\n"; |
| node->getFalseExpression()->traverse(this); |
| } |
| |
| --mDepth; |
| |
| return false; |
| } |
| |
| bool TOutputTraverser::visitIfElse(Visit visit, TIntermIfElse *node) |
| { |
| TInfoSinkBase &out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| |
| out << "If test\n"; |
| |
| ++mDepth; |
| |
| OutputTreeText(sink, node, mDepth); |
| out << "Condition\n"; |
| node->getCondition()->traverse(this); |
| |
| OutputTreeText(sink, node, mDepth); |
| if (node->getTrueBlock()) |
| { |
| out << "true case\n"; |
| node->getTrueBlock()->traverse(this); |
| } |
| else |
| { |
| out << "true case is null\n"; |
| } |
| |
| if (node->getFalseBlock()) |
| { |
| OutputTreeText(sink, node, mDepth); |
| out << "false case\n"; |
| node->getFalseBlock()->traverse(this); |
| } |
| |
| --mDepth; |
| |
| return false; |
| } |
| |
| void TOutputTraverser::visitConstantUnion(TIntermConstantUnion *node) |
| { |
| TInfoSinkBase &out = sink; |
| |
| size_t size = node->getType().getObjectSize(); |
| |
| for (size_t i = 0; i < size; i++) |
| { |
| OutputTreeText(out, node, mDepth); |
| switch (node->getUnionArrayPointer()[i].getType()) |
| { |
| case EbtBool: |
| if (node->getUnionArrayPointer()[i].getBConst()) |
| out << "true"; |
| else |
| out << "false"; |
| |
| out << " (" << "const bool" << ")"; |
| out << "\n"; |
| break; |
| case EbtFloat: |
| out << node->getUnionArrayPointer()[i].getFConst(); |
| out << " (const float)\n"; |
| break; |
| case EbtInt: |
| out << node->getUnionArrayPointer()[i].getIConst(); |
| out << " (const int)\n"; |
| break; |
| case EbtUInt: |
| out << node->getUnionArrayPointer()[i].getUConst(); |
| out << " (const uint)\n"; |
| break; |
| default: |
| out.message(EPrefixInternalError, node->getLine(), "Unknown constant"); |
| break; |
| } |
| } |
| } |
| |
| bool TOutputTraverser::visitLoop(Visit visit, TIntermLoop *node) |
| { |
| TInfoSinkBase &out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| |
| out << "Loop with condition "; |
| if (node->getType() == ELoopDoWhile) |
| out << "not "; |
| out << "tested first\n"; |
| |
| ++mDepth; |
| |
| OutputTreeText(sink, node, mDepth); |
| if (node->getCondition()) |
| { |
| out << "Loop Condition\n"; |
| node->getCondition()->traverse(this); |
| } |
| else |
| { |
| out << "No loop condition\n"; |
| } |
| |
| OutputTreeText(sink, node, mDepth); |
| if (node->getBody()) |
| { |
| out << "Loop Body\n"; |
| node->getBody()->traverse(this); |
| } |
| else |
| { |
| out << "No loop body\n"; |
| } |
| |
| if (node->getExpression()) |
| { |
| OutputTreeText(sink, node, mDepth); |
| out << "Loop Terminal Expression\n"; |
| node->getExpression()->traverse(this); |
| } |
| |
| --mDepth; |
| |
| return false; |
| } |
| |
| bool TOutputTraverser::visitBranch(Visit visit, TIntermBranch *node) |
| { |
| TInfoSinkBase &out = sink; |
| |
| OutputTreeText(out, node, mDepth); |
| |
| switch (node->getFlowOp()) |
| { |
| case EOpKill: out << "Branch: Kill"; break; |
| case EOpBreak: out << "Branch: Break"; break; |
| case EOpContinue: out << "Branch: Continue"; break; |
| case EOpReturn: out << "Branch: Return"; break; |
| default: out << "Branch: Unknown Branch"; break; |
| } |
| |
| if (node->getExpression()) |
| { |
| out << " with expression\n"; |
| ++mDepth; |
| node->getExpression()->traverse(this); |
| --mDepth; |
| } |
| else |
| { |
| out << "\n"; |
| } |
| |
| return false; |
| } |
| |
| // |
| // This function is the one to call externally to start the traversal. |
| // Individual functions can be initialized to 0 to skip processing of that |
| // type of node. Its children will still be processed. |
| // |
| void TIntermediate::outputTree(TIntermNode *root, TInfoSinkBase &infoSink) |
| { |
| TOutputTraverser it(infoSink); |
| |
| ASSERT(root); |
| |
| root->traverse(&it); |
| } |
