kc3-lang/angle/src/compiler/translator/RegenerateStructNames.cpp

• Show log

  Commit

• Hash : 2c9cc8b6
  Author :
  Date : 2018-01-09T16:13:02
  

  Don't duplicate symbol type information in AST nodes
  
  Function prototype nodes and symbol nodes already refer to symbols
  that have type information, so the type doesn't need to be copied to
  the TInterm* AST node classes. Now type is only stored in those AST
  node classes that represent other types of expressions. They use
  a new TIntermExpression base class for this.
  
  Since now we may use the TType from builtin symbols directly instead
  of copying it, building the mangled names of types in the correct
  memory pool is also required. The code now realizes the types of
  built-in variables when they get added to the symbol table.
  
  BUG=angleproject:2267
  TEST=angle_unittests
  
  Change-Id: Ic8d7fc912937cb8abb1e306e58c63bb9c146aae9
  Reviewed-on: https://chromium-review.googlesource.com/857005
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/compiler/translator/RegenerateStructNames.cpp

• //
  // Copyright (c) 2002-2014 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 "common/debug.h"
  #include "compiler/translator/RegenerateStructNames.h"
  
  namespace sh
  {
  
  void RegenerateStructNames::visitSymbol(TIntermSymbol *symbol)
  {
      ASSERT(symbol);
      const TType &type          = symbol->getType();
      const TStructure *userType = type.getStruct();
      if (!userType)
          return;
  
      if (userType->symbolType() == SymbolType::BuiltIn ||
          userType->symbolType() == SymbolType::Empty)
      {
          // Built-in struct or nameless struct, do not touch it.
          return;
      }
  
      int uniqueId = userType->uniqueId().get();
  
      ASSERT(mScopeDepth > 0);
      if (mScopeDepth == 1)
      {
          // If a struct is defined at global scope, we don't map its name.
          // This is because at global level, the struct might be used to
          // declare a uniform, so the same name needs to stay the same for
          // vertex/fragment shaders. However, our mapping uses internal ID,
          // which will be different for the same struct in vertex/fragment
          // shaders.
          // This is OK because names for any structs defined in other scopes
          // will begin with "_webgl", which is reserved. So there will be
          // no conflicts among unmapped struct names from global scope and
          // mapped struct names from other scopes.
          // However, we need to keep track of these global structs, so if a
          // variable is used in a local scope, we don't try to modify the
          // struct name through that variable.
          mDeclaredGlobalStructs.insert(uniqueId);
          return;
      }
      if (mDeclaredGlobalStructs.count(uniqueId) > 0)
          return;
      // Map {name} to _webgl_struct_{uniqueId}_{name}.
      const char kPrefix[] = "_webgl_struct_";
      if (userType->name().find(kPrefix) == 0)
      {
          // The name has already been regenerated.
          return;
      }
      std::string id = Str(uniqueId);
      TString tmp    = kPrefix + TString(id.c_str());
      tmp += "_" + userType->name();
  
      // TODO(oetuaho): Add another mechanism to change symbol names so that the const_cast is not
      // needed.
      const_cast<TStructure *>(userType)->setName(tmp);
  }
  
  bool RegenerateStructNames::visitBlock(Visit, TIntermBlock *block)
  {
      ++mScopeDepth;
      TIntermSequence &sequence = *(block->getSequence());
      for (TIntermNode *node : sequence)
      {
          node->traverse(this);
      }
      --mScopeDepth;
      return false;
  }
  
  }  // namespace sh
  

Download