NameNamelessUniformBuffers.cpp

Enable keyboard shortcuts

//

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

//

// NameNamelessUniformBuffers: Gives nameless uniform buffer variables internal names.

//

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

#include "compiler/translator/SymbolTable.h"

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

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

namespace sh

namespace

// Traverse uniform buffer declarations and give name to nameless declarations.  Keeps track of

// the interface fields which will be used in the source without the interface block variable name

// and replaces them with name.field.

class NameUniformBufferVariablesTraverser : public TIntermTraverser

  public:

    explicit NameUniformBufferVariablesTraverser(TSymbolTable *symbolTable)

        : TIntermTraverser(true, false, false, symbolTable)

{}

    bool visitDeclaration(Visit visit, TIntermDeclaration *decl) override

        ASSERT(visit == PreVisit);

        const TIntermSequence &sequence = *(decl->getSequence());

        TIntermTyped *variableNode = sequence.front()->getAsTyped();

        const TType &type          = variableNode->getType();

        // If it's an interface block, it may have to be converted if it contains any row-major

        // fields.

        if (!type.isInterfaceBlock())

            return true;

        // Multi declaration statements are already separated, so there can only be one variable

        // here.

        ASSERT(sequence.size() == 1);

        const TVariable *variable = &variableNode->getAsSymbolNode()->variable();

        if (variable->symbolType() != SymbolType::Empty)

            return false;

        TIntermDeclaration *newDeclaration = new TIntermDeclaration;

        TVariable *newVariable = new TVariable(mSymbolTable, kEmptyImmutableString, &type,

                                               SymbolType::AngleInternal, variable->extensions());

        newDeclaration->appendDeclarator(new TIntermSymbol(newVariable));

        queueReplacement(newDeclaration, OriginalNode::IS_DROPPED);

        // It's safe to key the map with the interface block, as there couldn't have been multiple

        // declarations with this interface block (as the variable is nameless), so for nameless

        // uniform buffers, the interface block is unique.

        mNamelessUniformBuffersMap[type.getInterfaceBlock()] = newVariable;

        return false;

    void visitSymbol(TIntermSymbol *symbol) override

        const TType &type = symbol->getType();

        // The symbols we are looking for have the interface block pointer set, but are not

        // interface blocks.  These are references to fields of nameless uniform buffers.

        if (type.isInterfaceBlock() || type.getInterfaceBlock() == nullptr)

            return;

        const TInterfaceBlock *block = type.getInterfaceBlock();

        // If block variable is not nameless, there's nothing to do.

        if (mNamelessUniformBuffersMap.count(block) == 0)

            return;

        const ImmutableString symbolName = symbol->getName();

        // Find which field it is

        const TVector<TField *> fields = block->fields();

        for (size_t fieldIndex = 0; fieldIndex < fields.size(); ++fieldIndex)

            const TField *field = fields[fieldIndex];

            if (field->name() != symbolName)

                continue;

            // Replace this node with a binary node that indexes the named uniform buffer.

            TIntermSymbol *namedUniformBuffer =

                new TIntermSymbol(mNamelessUniformBuffersMap[block]);

            TIntermBinary *replacement =

                new TIntermBinary(EOpIndexDirectInterfaceBlock, namedUniformBuffer,

                                  CreateIndexNode(static_cast<uint32_t>(fieldIndex)));

            queueReplacement(replacement, OriginalNode::IS_DROPPED);

            return;

        UNREACHABLE();

  private:

    // A map from nameless uniform buffers to their named replacements.

    std::unordered_map<const TInterfaceBlock *, const TVariable *> mNamelessUniformBuffersMap;

};

}  // anonymous namespace

bool NameNamelessUniformBuffers(TCompiler *compiler, TIntermBlock *root, TSymbolTable *symbolTable)

    NameUniformBufferVariablesTraverser nameUniformBufferVariables(symbolTable);

    root->traverse(&nameUniformBufferVariables);

    return nameUniformBufferVariables.updateTree(compiler, root);

}  // namespace sh