tor-browser

SeparateDeclarations.cpp (7628B)

---

//
// Copyright 2002 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.
//
// The SeparateDeclarations function processes declarations, so that in the end each declaration
// contains only one declarator.
// This is useful as an intermediate step when initialization needs to be separated from
// declaration, or when things need to be unfolded out of the initializer.
// Example:
//     int a[1] = int[1](1), b[1] = int[1](2);
// gets transformed when run through this class into the AST equivalent of:
//     int a[1] = int[1](1);
//     int b[1] = int[1](2);

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

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

namespace sh
{

namespace
{

class SeparateDeclarationsTraverser : private TIntermTraverser
{
 public:
   [[nodiscard]] static bool apply(TCompiler *compiler,
                                   TIntermNode *root,
                                   TSymbolTable *symbolTable);

 private:
   SeparateDeclarationsTraverser(TSymbolTable *symbolTable);
   bool visitDeclaration(Visit, TIntermDeclaration *node) override;
   void visitSymbol(TIntermSymbol *symbol) override;

   void separateDeclarator(TIntermSequence *sequence,
                           size_t index,
                           TIntermSequence *replacementDeclarations,
                           const TStructure **replacementStructure);

   VariableReplacementMap mVariableMap;
};

bool SeparateDeclarationsTraverser::apply(TCompiler *compiler,
                                         TIntermNode *root,
                                         TSymbolTable *symbolTable)
{
   SeparateDeclarationsTraverser separateDecl(symbolTable);
   root->traverse(&separateDecl);
   return separateDecl.updateTree(compiler, root);
}

SeparateDeclarationsTraverser::SeparateDeclarationsTraverser(TSymbolTable *symbolTable)
   : TIntermTraverser(true, false, false, symbolTable)
{}

bool SeparateDeclarationsTraverser::visitDeclaration(Visit, TIntermDeclaration *node)
{
   TIntermSequence *sequence = node->getSequence();
   if (sequence->size() <= 1)
   {
       return true;
   }

   TIntermBlock *parentBlock = getParentNode()->getAsBlock();
   ASSERT(parentBlock != nullptr);

   TIntermSequence replacementDeclarations;
   const TStructure *replacementStructure = nullptr;
   for (size_t ii = 0; ii < sequence->size(); ++ii)
   {
       separateDeclarator(sequence, ii, &replacementDeclarations, &replacementStructure);
   }

   mMultiReplacements.emplace_back(parentBlock, node, std::move(replacementDeclarations));
   return false;
}

void SeparateDeclarationsTraverser::visitSymbol(TIntermSymbol *symbol)
{
   const TVariable *variable = &symbol->variable();
   if (mVariableMap.count(variable) > 0)
   {
       queueAccessChainReplacement(mVariableMap[variable]->deepCopy());
   }
}

void SeparateDeclarationsTraverser::separateDeclarator(TIntermSequence *sequence,
                                                      size_t index,
                                                      TIntermSequence *replacementDeclarations,
                                                      const TStructure **replacementStructure)
{
   TIntermTyped *declarator    = sequence->at(index)->getAsTyped();
   const TType &declaratorType = declarator->getType();

   // If the declaration is not simultaneously declaring a struct, can use the same declarator.
   // Otherwise, the first declarator is taken as-is if the struct has a name.
   const TStructure *structure  = declaratorType.getStruct();
   const bool isStructSpecifier = declaratorType.isStructSpecifier();
   if (!isStructSpecifier || (index == 0 && structure->symbolType() != SymbolType::Empty))
   {
       TIntermDeclaration *replacementDeclaration = new TIntermDeclaration;

       // Make sure to update the declarator's initializers if any.
       declarator->traverse(this);

       replacementDeclaration->appendDeclarator(declarator);
       replacementDeclaration->setLine(declarator->getLine());
       replacementDeclarations->push_back(replacementDeclaration);
       return;
   }

   // If the struct is nameless, split it out first.
   if (structure->symbolType() == SymbolType::Empty)
   {
       if (*replacementStructure == nullptr)
       {
           TStructure *newStructure =
               new TStructure(mSymbolTable, kEmptyImmutableString, &structure->fields(),
                              SymbolType::AngleInternal);
           newStructure->setAtGlobalScope(structure->atGlobalScope());
           *replacementStructure = structure = newStructure;

           TType *namedType = new TType(structure, true);
           namedType->setQualifier(EvqGlobal);

           TVariable *structVariable =
               new TVariable(mSymbolTable, kEmptyImmutableString, namedType, SymbolType::Empty);

           TIntermDeclaration *structDeclaration = new TIntermDeclaration;
           structDeclaration->appendDeclarator(new TIntermSymbol(structVariable));
           structDeclaration->setLine(declarator->getLine());
           replacementDeclarations->push_back(structDeclaration);
       }
       else
       {
           structure = *replacementStructure;
       }
   }

   // Redeclare the declarator but not as a struct specifier.
   TIntermSymbol *asSymbol   = declarator->getAsSymbolNode();
   TIntermTyped *initializer = nullptr;
   if (asSymbol == nullptr)
   {
       TIntermBinary *asBinary = declarator->getAsBinaryNode();
       ASSERT(asBinary->getOp() == EOpInitialize);
       asSymbol    = asBinary->getLeft()->getAsSymbolNode();
       initializer = asBinary->getRight();

       // Make sure the initializer itself has its variables replaced if necessary.
       if (initializer->getAsSymbolNode())
       {
           const TVariable *initializerVariable = &initializer->getAsSymbolNode()->variable();
           if (mVariableMap.count(initializerVariable) > 0)
           {
               initializer = mVariableMap[initializerVariable]->deepCopy();
           }
       }
       else
       {
           initializer->traverse(this);
       }
   }

   ASSERT(asSymbol && asSymbol->variable().symbolType() != SymbolType::Empty);

   TType *newType = new TType(structure, false);
   newType->setQualifier(asSymbol->getType().getQualifier());
   newType->makeArrays(asSymbol->getType().getArraySizes());

   TVariable *replacementVar        = new TVariable(mSymbolTable, asSymbol->getName(), newType,
                                                    asSymbol->variable().symbolType());
   TIntermSymbol *replacementSymbol = new TIntermSymbol(replacementVar);
   TIntermTyped *replacement        = replacementSymbol;
   if (initializer)
   {
       replacement = new TIntermBinary(EOpInitialize, replacement, initializer);
   }

   TIntermDeclaration *replacementDeclaration = new TIntermDeclaration;
   replacementDeclaration->appendDeclarator(replacement);
   replacementDeclaration->setLine(declarator->getLine());
   replacementDeclarations->push_back(replacementDeclaration);

   mVariableMap[&asSymbol->variable()] = replacementSymbol;
}
}  // namespace

bool SeparateDeclarations(TCompiler *compiler, TIntermNode *root, TSymbolTable *symbolTable)
{
   return SeparateDeclarationsTraverser::apply(compiler, root, symbolTable);
}

}  // namespace sh