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

• Show log

  Commit

• Hash : 711db275
  Author :
  Date : 2023-08-23T11:06:42
  

  Translator: remove usage of contains()
  
  It's not available pre-C++20
  
  Bug: angleproject:8311
  Change-Id: I41940b5f8e6a90bc0224852aefe54643f2be9cb5
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4806924
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

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

• //
  // Copyright 2023 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 <set>
  
  #include "compiler/translator/tree_ops/RescopeGlobalVariables.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  #include "compiler/translator/tree_util/ReplaceVariable.h"
  #include "compiler/translator/util.h"
  
  namespace sh
  {
  
  ////////////////////////////////////////////////////////////////////////////////
  
  namespace
  {
  
  class Rescoper : public TIntermTraverser
  {
    public:
      struct VariableInfo
      {
          std::set<TIntermFunctionDefinition *> functions;
          TIntermDeclaration *declaration;
      };
  
      Rescoper(TSymbolTable *symbolTable) : TIntermTraverser(true, false, true, symbolTable) {}
  
      bool rescope(TCompiler *compiler, TIntermBlock &root)
      {
          if (mGlobalVarsNeedRescope.empty())
          {
              return true;
          }
  
          // Insert the declarations into the first block in the function body and keep track of which
          // ones have been moved, as well as the variables to replace.
          VariableReplacementMap replacementMap;
          std::set<TIntermDeclaration *> movedDeclarations;
          for (auto &pair : mGlobalVarsNeedRescope)
          {
              if (pair.second.functions.size() == 1)
              {
                  TIntermFunctionDefinition *func = *pair.second.functions.begin();
                  TIntermSequence *funcSequence   = func->getBody()->getSequence();
                  funcSequence->insert(funcSequence->begin(), pair.second.declaration);
  
                  TType *newType = new TType(pair.first->getType());
                  newType->setQualifier(TQualifier::EvqTemporary);
                  const TVariable *newVar =
                      new TVariable(&compiler->getSymbolTable(), pair.first->name(), newType,
                                    pair.first->symbolType(), pair.first->extensions());
                  replacementMap[pair.first] = new TIntermSymbol(newVar);
  
                  movedDeclarations.insert(pair.second.declaration);
              }
          }
  
          // Remove the global declarations that have been moved from the root block.
          TIntermSequence *rootOriginal = root.getSequence();
          TIntermSequence rootReplacement;
          for (TIntermNode *node : *rootOriginal)
          {
              if (movedDeclarations.find(node->getAsDeclarationNode()) == movedDeclarations.end())
              {
                  rootReplacement.push_back(node);
              }
          }
          *rootOriginal = std::move(rootReplacement);
          return ReplaceVariables(compiler, &root, replacementMap);
      }
  
    protected:
      void visitSymbol(TIntermSymbol *node) override
      {
          const TVariable &var = node->variable();
          if (mCurrentFunction && mGlobalVarsNeedRescope.find(&var) != mGlobalVarsNeedRescope.end())
          {
              std::set<TIntermFunctionDefinition *> &set = mGlobalVarsNeedRescope.at(&var).functions;
              if (set.find(mCurrentFunction) == set.end())
              {
                  set.emplace(mCurrentFunction);
              }
          }
      }
  
      bool visitDeclaration(Visit visit, TIntermDeclaration *node) override
      {
          if (visit == Visit::PreVisit)
          {
              Declaration decl           = ViewDeclaration(*node);
              const TVariable &var       = decl.symbol.variable();
              const TType &nodeType      = var.getType();
              const TQualifier qualifier = nodeType.getQualifier();
              if (qualifier == TQualifier::EvqGlobal && !nodeType.isStructSpecifier())
              {
                  mGlobalVarsNeedRescope.emplace(&var, VariableInfo());
                  mGlobalVarsNeedRescope.at(&var).declaration = node;
              }
          }
          return true;
      }
  
      bool visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node) override
      {
          if (visit == Visit::PreVisit)
          {
              TIntermFunctionDefinition *func = node->getAsFunctionDefinition();
              if (func)
              {
                  mCurrentFunction = func;
              }
          }
          else if (visit == Visit::PostVisit)
          {
              if (mCurrentFunction && mCurrentFunction == node->getAsFunctionDefinition())
              {
                  mCurrentFunction = nullptr;
              }
          }
          return true;
      }
  
    private:
      TUnorderedMap<const TVariable *, VariableInfo> mGlobalVarsNeedRescope;
      TIntermFunctionDefinition *mCurrentFunction = nullptr;
  };
  
  }  // anonymous namespace
  
  ////////////////////////////////////////////////////////////////////////////////
  
  bool RescopeGlobalVariables(TCompiler &compiler, TIntermBlock &root)
  {
      TSymbolTable &symbolTable = compiler.getSymbolTable();
      Rescoper rescoper(&symbolTable);
      root.traverse(&rescoper);
      return rescoper.rescope(&compiler, root);
  }
  
  }  // namespace sh
  

Download