RemoveArrayLengthMethod.cpp

Enable keyboard shortcuts

//

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

//

// RemoveArrayLengthMethod.cpp:

//   Fold array length expressions, including cases where the "this" node has side effects.

//   Example:

//     int i = (a = b).length();

//     int j = (func()).length();

//   becomes:

//     (a = b);

//     int i = <constant array length>;

//     func();

//     int j = <constant array length>;

//

//   Must be run after SplitSequenceOperator, SimplifyLoopConditions and SeparateDeclarations steps

//   have been done to expressions containing calls of the array length method.

//

//   Does nothing to length method calls done on runtime-sized arrays.

#include "compiler/translator/tree_ops/RemoveArrayLengthMethod.h"

#include "compiler/translator/IntermNode.h"

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

namespace sh

namespace

class RemoveArrayLengthTraverser : public TIntermTraverser

  public:

    RemoveArrayLengthTraverser() : TIntermTraverser(true, false, false), mFoundArrayLength(false) {}

    bool visitUnary(Visit visit, TIntermUnary *node) override;

    void nextIteration() { mFoundArrayLength = false; }

    bool foundArrayLength() const { return mFoundArrayLength; }

  private:

    void insertSideEffectsInParentBlock(TIntermTyped *node);

    bool mFoundArrayLength;

};

bool RemoveArrayLengthTraverser::visitUnary(Visit visit, TIntermUnary *node)

    // The only case where we leave array length() in place is for runtime-sized arrays.

    if (node->getOp() == EOpArrayLength && !node->getOperand()->getType().isUnsizedArray())

        mFoundArrayLength = true;

        insertSideEffectsInParentBlock(node->getOperand());

        TConstantUnion *constArray = new TConstantUnion[1];

        constArray->setIConst(node->getOperand()->getOutermostArraySize());

        queueReplacement(new TIntermConstantUnion(constArray, node->getType()),

                         OriginalNode::IS_DROPPED);

        return false;

    return true;

void RemoveArrayLengthTraverser::insertSideEffectsInParentBlock(TIntermTyped *node)

    // If the node is an index type, traverse it and add the indices as side effects.  If at the end

    // an expression without side effect is encountered, such as an opaque uniform or a lone symbol,

    // don't generate a statement for it.

    if (!node->hasSideEffects())

        return;

    TIntermBinary *asBinary = node->getAsBinaryNode();

    if (asBinary && !asBinary->isAssignment())

        insertSideEffectsInParentBlock(asBinary->getLeft());

        insertSideEffectsInParentBlock(asBinary->getRight());

    else

        insertStatementInParentBlock(node);

}  // anonymous namespace

bool RemoveArrayLengthMethod(TCompiler *compiler, TIntermBlock *root)

    RemoveArrayLengthTraverser traverser;

do

        traverser.nextIteration();

        root->traverse(&traverser);

        if (traverser.foundArrayLength())

            if (!traverser.updateTree(compiler, root))

                return false;

    } while (traverser.foundArrayLength());

    return true;

}  // namespace sh