kc3-lang/angle/src/compiler/translator/tree_ops/SeparateDeclarations.cpp

• Show log

  Commit

• Hash : 03c75d35
  Author :
  Date : 2024-11-14T14:24:44
  

  Remove SeparateStructFromFunctionDeclarations
  
  Move SeparateStructFromFunctionDeclarations to SeparateDeclarations
  It is logical part of the separate declarations step.
  
  Bug: angleproject:378966971
  Change-Id: Ie102a1d936f7b444f5f9f2ac2fe8dc6c10027782
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6022857
  Auto-Submit: Kimmo Kinnunen <kkinnunen@apple.com>
  Commit-Queue: Kimmo Kinnunen <kkinnunen@apple.com>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/compiler/translator/tree_ops/SeparateDeclarations.cpp

• //
  // 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.
  //
  #include "compiler/translator/tree_ops/SeparateDeclarations.h"
  
  #include "common/hash_containers.h"
  #include "compiler/translator/IntermRebuild.h"
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/util.h"
  
  namespace sh
  {
  namespace
  {
  
  class Separator final : private TIntermRebuild
  {
    public:
      Separator(TCompiler &compiler, bool separateCompoundStructDeclarations)
          : TIntermRebuild(compiler, true, true),
            mSeparateCompoundStructDeclarations(separateCompoundStructDeclarations)
      {}
      using TIntermRebuild::rebuildRoot;
  
    private:
      void recordModifiedStructVariables(TIntermDeclaration &node)
      {
          ASSERT(!mNewStructure);  // No nested struct declarations.
          TIntermSequence &sequence = *node.getSequence();
          if (sequence.size() <= 1 && !mSeparateCompoundStructDeclarations)
          {
              return;
          }
          TIntermTyped *declarator    = sequence.at(0)->getAsTyped();
          const TType &declaratorType = declarator->getType();
          const TStructure *structure = declaratorType.getStruct();
          // Rewrite variable declarations that specify structs AND variable(s) at the same
          // time.
          if (!structure || !declaratorType.isStructSpecifier())
          {
              return;
          }
          if (mSeparateCompoundStructDeclarations && sequence.size() == 1)
          {
              if (TIntermSymbol *symbol = declarator->getAsSymbolNode(); symbol != nullptr)
              {
                  if (symbol->variable().symbolType() == SymbolType::Empty)
                  {
                      return;
                  }
              }
          }
          // By default, struct specifier changes for all variables except the first one.
          uint32_t index = 1;
          if (structure->symbolType() == SymbolType::Empty)
          {
              TStructure *newStructure =
                  new TStructure(&mSymbolTable, kEmptyImmutableString, &structure->fields(),
                                 SymbolType::AngleInternal);
              newStructure->setAtGlobalScope(structure->atGlobalScope());
              structure     = newStructure;
              // Adding name causes the struct type to change, so also the first variable variable
              // needs rewriting.
              index = 0;
          }
          if (mSeparateCompoundStructDeclarations)
          {
              mNewStructure = structure;
              // Separating struct and variable declaration causes the variable type to change
              // from specifying to not-specifying, so also the first variable needs rewriting.
              index = 0;
          }
  
          for (; index < sequence.size(); ++index)
          {
              Declaration decl              = ViewDeclaration(node, index);
              const TVariable &var          = decl.symbol.variable();
              const TType &varType          = var.getType();
              const bool newTypeIsSpecifier = index == 0 && !mSeparateCompoundStructDeclarations;
              TType *newType                = new TType(structure, newTypeIsSpecifier);
              newType->setQualifier(varType.getQualifier());
              newType->makeArrays(varType.getArraySizes());
              TVariable *newVar = new TVariable(&mSymbolTable, var.name(), newType, var.symbolType());
              mStructVariables.insert(std::make_pair(&var, newVar));
          }
      }
  
      PreResult visitDeclarationPre(TIntermDeclaration &node) override
      {
          recordModifiedStructVariables(node);
          return node;
      }
  
      PostResult visitDeclarationPost(TIntermDeclaration &node) override
      {
          TIntermSequence &sequence = *node.getSequence();
          if (sequence.size() <= 1 && !mNewStructure)
          {
              return node;
          }
          std::vector<TIntermNode *> replacements;
          if (mNewStructure)
          {
              TType *newType = new TType(mNewStructure, true);
              if (mNewStructure->atGlobalScope())
              {
                  newType->setQualifier(EvqGlobal);
              }
              TVariable *structVar =
                  new TVariable(&mSymbolTable, kEmptyImmutableString, newType, SymbolType::Empty);
              TIntermDeclaration *replacement = new TIntermDeclaration({structVar});
              replacement->setLine(node.getLine());
              replacements.push_back(replacement);
              mNewStructure = nullptr;
          }
          for (uint32_t index = 0; index < sequence.size(); ++index)
          {
              TIntermTyped *declarator        = sequence.at(index)->getAsTyped();
              TIntermDeclaration *replacement = new TIntermDeclaration({declarator});
              replacement->setLine(declarator->getLine());
              replacements.push_back(replacement);
          }
          return PostResult::Multi(std::move(replacements));
      }
  
      PreResult visitSymbolPre(TIntermSymbol &symbolNode) override
      {
          auto it = mStructVariables.find(&symbolNode.variable());
          if (it == mStructVariables.end())
          {
              return symbolNode;
          }
          return *new TIntermSymbol(it->second);
      }
  
      PreResult visitFunctionPrototypePre(TIntermFunctionPrototype &node) override
      {
          const TFunction *function = node.getFunction();
          auto it                   = mFunctionsToReplace.find(function);
          if (it != mFunctionsToReplace.end())
          {
              TIntermFunctionPrototype *newFuncProto = new TIntermFunctionPrototype(it->second);
              return newFuncProto;
          }
          else if (node.getType().isStructSpecifier())
          {
              const TType &oldType        = node.getType();
              const TStructure *structure = oldType.getStruct();
              // Name unnamed inline structs
              if (structure->symbolType() == SymbolType::Empty)
              {
                  TStructure *newStructure =
                      new TStructure(&mSymbolTable, kEmptyImmutableString, &structure->fields(),
                                     SymbolType::AngleInternal);
                  newStructure->setAtGlobalScope(structure->atGlobalScope());
                  structure = newStructure;
              }
              TType *newType = new TType(structure, true);
              if (structure->atGlobalScope())
              {
                  newType->setQualifier(EvqGlobal);
              }
              TVariable *structVar =
                  new TVariable(&mSymbolTable, ImmutableString(""), newType, SymbolType::Empty);
              TType *returnType = new TType(structure, false);
              if (oldType.isArray())
              {
                  returnType->makeArrays(oldType.getArraySizes());
              }
              returnType->setQualifier(oldType.getQualifier());
  
              const TFunction *oldFunc = function;
              ASSERT(oldFunc->symbolType() == SymbolType::UserDefined);
  
              const TFunction *newFunc     = cloneFunctionAndChangeReturnType(oldFunc, returnType);
              mFunctionsToReplace[oldFunc] = newFunc;
              if (getParentNode()->getAsFunctionDefinition() != nullptr)
              {
                  mNewFunctionReturnStructDeclaration = new TIntermDeclaration({structVar});
                  return new TIntermFunctionPrototype(newFunc);
              }
              return PreResult::Multi(
                  {new TIntermDeclaration({structVar}), new TIntermFunctionPrototype(newFunc)});
          }
  
          return node;
      }
  
      PostResult visitFunctionDefinitionPost(TIntermFunctionDefinition &node) override
      {
          if (mNewFunctionReturnStructDeclaration)
          {
              return PostResult::Multi(
                  {std::exchange(mNewFunctionReturnStructDeclaration, nullptr), &node});
          }
          return node;
      }
  
      PreResult visitAggregatePre(TIntermAggregate &node) override
      {
          const TFunction *function = node.getFunction();
          auto it                   = mFunctionsToReplace.find(function);
          if (it != mFunctionsToReplace.end())
          {
              TIntermAggregate *replacementNode =
                  TIntermAggregate::CreateFunctionCall(*it->second, node.getSequence());
  
              return PreResult(replacementNode, VisitBits::Children);
          }
  
          return node;
      }
  
    private:
      const TFunction *cloneFunctionAndChangeReturnType(const TFunction *oldFunc,
                                                        const TType *newReturnType)
  
      {
          ASSERT(oldFunc->symbolType() == SymbolType::UserDefined);
  
          TFunction *newFunc = new TFunction(&mSymbolTable, oldFunc->name(), oldFunc->symbolType(),
                                             newReturnType, oldFunc->isKnownToNotHaveSideEffects());
  
          if (oldFunc->isDefined())
          {
              newFunc->setDefined();
          }
  
          if (oldFunc->hasPrototypeDeclaration())
          {
              newFunc->setHasPrototypeDeclaration();
          }
  
          const size_t paramCount = oldFunc->getParamCount();
          for (size_t i = 0; i < paramCount; ++i)
          {
              const TVariable *var = oldFunc->getParam(i);
              newFunc->addParameter(var);
          }
  
          return newFunc;
      }
  
      angle::HashMap<const TFunction *, const TFunction *> mFunctionsToReplace;
      // New structure separated from function declaration.
      TIntermDeclaration *mNewFunctionReturnStructDeclaration = nullptr;
  
      // New structure from compound declaration.
      const TStructure *mNewStructure = nullptr;
      // Old struct variable to new struct variable mapping.
      angle::HashMap<const TVariable *, TVariable *> mStructVariables;
      const bool mSeparateCompoundStructDeclarations;
  };
  
  }  // namespace
  
  bool SeparateDeclarations(TCompiler &compiler,
                            TIntermBlock &root,
                            bool separateCompoundStructDeclarations)
  {
      Separator separator(compiler, separateCompoundStructDeclarations);
      return separator.rebuildRoot(root);
  }
  
  }  // namespace sh
  

Download