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

• Show log

  Commit

• Hash : e600c0aa
  Author :
  Date : 2018-03-02T11:23:29
  

  Use non-human-readable mangled names for types
  
  The new mangled name format is as follows:
  
  The first character is a hex digit from 0 to F that encodes vector or
  matrix size. For scalars, structs etc. the character is 0.
  
  Then, if it's a struct, the mangled name continues with "{s", followed
  by mangled names of fields, and ends with "}".
  
  If it's an interface block, the mangled name continues with "{i",
  followed by mangled names of fields, and ends with "}".
  
  If it's anything else, the second alphabetic character encodes the
  basic type. Characters are assigned to basic types in the enumeration
  order.
  
  If it's an array, the mangled name has a suffix [array_size].
  
  This saves a few kilobytes from the binary size. The effect on symbol
  lookup speed seems mostly marginal.
  
  BUG=angleproject:2267
  TEST=angle_unittests
  
  Change-Id: I26e65dcb48c3478df9a719ffff9c15f2fd12e293
  Reviewed-on: https://chromium-review.googlesource.com/945910
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/compiler/translator/SymbolTable.cpp

• //
  // Copyright (c) 2002-2013 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.
  //
  // Symbol table for parsing. The design principles and most of the functionality are documented in
  // the header file.
  //
  
  #if defined(_MSC_VER)
  #pragma warning(disable : 4718)
  #endif
  
  #include "compiler/translator/SymbolTable.h"
  
  #include <algorithm>
  #include <set>
  
  #include "angle_gl.h"
  #include "compiler/translator/BuiltIn_autogen.h"
  #include "compiler/translator/ImmutableString.h"
  #include "compiler/translator/IntermNode.h"
  #include "compiler/translator/StaticType.h"
  
  namespace sh
  {
  
  class TSymbolTable::TSymbolTableLevel
  {
    public:
      TSymbolTableLevel() : mGlobalInvariant(false) {}
  
      bool insert(TSymbol *symbol);
  
      // Insert a function using its unmangled name as the key.
      void insertUnmangled(TFunction *function);
  
      TSymbol *find(const ImmutableString &name) const;
  
      void addInvariantVarying(const ImmutableString &name) { mInvariantVaryings.insert(name); }
  
      bool isVaryingInvariant(const ImmutableString &name)
      {
          return (mGlobalInvariant || mInvariantVaryings.count(name) > 0);
      }
  
      void setGlobalInvariant(bool invariant) { mGlobalInvariant = invariant; }
  
    private:
      using tLevel        = TUnorderedMap<ImmutableString,
                                   TSymbol *,
                                   ImmutableString::FowlerNollVoHash<sizeof(size_t)>>;
      using tLevelPair    = const tLevel::value_type;
      using tInsertResult = std::pair<tLevel::iterator, bool>;
  
      tLevel level;
  
      std::set<ImmutableString> mInvariantVaryings;
      bool mGlobalInvariant;
  };
  
  class TSymbolTable::TSymbolTableBuiltInLevel
  {
    public:
      TSymbolTableBuiltInLevel() = default;
  
      void insert(const TSymbol *symbol);
      const TSymbol *find(const ImmutableString &name) const;
  
    private:
      using tLevel        = TUnorderedMap<ImmutableString,
                                   const TSymbol *,
                                   ImmutableString::FowlerNollVoHash<sizeof(size_t)>>;
      using tLevelPair    = const tLevel::value_type;
      tLevel mLevel;
  };
  
  bool TSymbolTable::TSymbolTableLevel::insert(TSymbol *symbol)
  {
      // returning true means symbol was added to the table
      tInsertResult result = level.insert(tLevelPair(symbol->getMangledName(), symbol));
      return result.second;
  }
  
  void TSymbolTable::TSymbolTableLevel::insertUnmangled(TFunction *function)
  {
      level.insert(tLevelPair(function->name(), function));
  }
  
  TSymbol *TSymbolTable::TSymbolTableLevel::find(const ImmutableString &name) const
  {
      tLevel::const_iterator it = level.find(name);
      if (it == level.end())
          return nullptr;
      else
          return (*it).second;
  }
  
  void TSymbolTable::TSymbolTableBuiltInLevel::insert(const TSymbol *symbol)
  {
      mLevel.insert(tLevelPair(symbol->getMangledName(), symbol));
  }
  
  const TSymbol *TSymbolTable::TSymbolTableBuiltInLevel::find(const ImmutableString &name) const
  {
      tLevel::const_iterator it = mLevel.find(name);
      if (it == mLevel.end())
          return nullptr;
      else
          return (*it).second;
  }
  
  TSymbolTable::TSymbolTable() : mUniqueIdCounter(0), mShaderType(GL_FRAGMENT_SHADER)
  {
  }
  
  TSymbolTable::~TSymbolTable() = default;
  
  bool TSymbolTable::isEmpty() const
  {
      return mTable.empty();
  }
  
  bool TSymbolTable::atGlobalLevel() const
  {
      return mTable.size() == 1u;
  }
  
  void TSymbolTable::pushBuiltInLevel()
  {
      mBuiltInTable.push_back(
          std::unique_ptr<TSymbolTableBuiltInLevel>(new TSymbolTableBuiltInLevel));
  }
  
  void TSymbolTable::push()
  {
      mTable.push_back(std::unique_ptr<TSymbolTableLevel>(new TSymbolTableLevel));
      mPrecisionStack.push_back(std::unique_ptr<PrecisionStackLevel>(new PrecisionStackLevel));
  }
  
  void TSymbolTable::pop()
  {
      mTable.pop_back();
      mPrecisionStack.pop_back();
  }
  
  const TFunction *TSymbolTable::markFunctionHasPrototypeDeclaration(
      const ImmutableString &mangledName,
      bool *hadPrototypeDeclarationOut)
  {
      TFunction *function         = findUserDefinedFunction(mangledName);
      *hadPrototypeDeclarationOut = function->hasPrototypeDeclaration();
      function->setHasPrototypeDeclaration();
      return function;
  }
  
  const TFunction *TSymbolTable::setFunctionParameterNamesFromDefinition(const TFunction *function,
                                                                         bool *wasDefinedOut)
  {
      TFunction *firstDeclaration = findUserDefinedFunction(function->getMangledName());
      ASSERT(firstDeclaration);
      // Note: 'firstDeclaration' could be 'function' if this is the first time we've seen function as
      // it would have just been put in the symbol table. Otherwise, we're looking up an earlier
      // occurance.
      if (function != firstDeclaration)
      {
          // The previous declaration should have the same parameters as the function definition
          // (parameter names may differ).
          firstDeclaration->shareParameters(*function);
      }
  
      *wasDefinedOut = firstDeclaration->isDefined();
      firstDeclaration->setDefined();
      return firstDeclaration;
  }
  
  const TSymbol *TSymbolTable::find(const ImmutableString &name, int shaderVersion) const
  {
      int userDefinedLevel = static_cast<int>(mTable.size()) - 1;
      while (userDefinedLevel >= 0)
      {
          const TSymbol *symbol = mTable[userDefinedLevel]->find(name);
          if (symbol)
          {
              return symbol;
          }
          userDefinedLevel--;
      }
  
      return findBuiltIn(name, shaderVersion, false);
  }
  
  TFunction *TSymbolTable::findUserDefinedFunction(const ImmutableString &name) const
  {
      // User-defined functions are always declared at the global level.
      ASSERT(!mTable.empty());
      return static_cast<TFunction *>(mTable[0]->find(name));
  }
  
  const TSymbol *TSymbolTable::findGlobal(const ImmutableString &name) const
  {
      ASSERT(!mTable.empty());
      return mTable[0]->find(name);
  }
  
  const TSymbol *TSymbolTable::findBuiltIn(const ImmutableString &name, int shaderVersion) const
  {
      return findBuiltIn(name, shaderVersion, false);
  }
  
  const TSymbol *TSymbolTable::findBuiltIn(const ImmutableString &name,
                                           int shaderVersion,
                                           bool includeGLSLBuiltins) const
  {
      for (int level = LAST_BUILTIN_LEVEL; level >= 0; level--)
      {
          if (level == GLSL_BUILTINS && !includeGLSLBuiltins)
              level--;
          if (level == ESSL3_1_BUILTINS && shaderVersion != 310)
              level--;
          if (level == ESSL3_BUILTINS && shaderVersion < 300)
              level--;
          if (level == ESSL1_BUILTINS && shaderVersion != 100)
              level--;
  
          const TSymbol *symbol = mBuiltInTable[level]->find(name);
  
          if (symbol)
              return symbol;
      }
  
      return nullptr;
  }
  
  
  bool TSymbolTable::declare(TSymbol *symbol)
  {
      ASSERT(!mTable.empty());
      ASSERT(symbol->symbolType() == SymbolType::UserDefined);
      ASSERT(!symbol->isFunction());
      return mTable.back()->insert(symbol);
  }
  
  void TSymbolTable::declareUserDefinedFunction(TFunction *function, bool insertUnmangledName)
  {
      ASSERT(!mTable.empty());
      if (insertUnmangledName)
      {
          // Insert the unmangled name to detect potential future redefinition as a variable.
          mTable[0]->insertUnmangled(function);
      }
      mTable[0]->insert(function);
  }
  
  void TSymbolTable::insertBuiltIn(ESymbolLevel level, const TSymbol *symbol)
  {
      ASSERT(symbol);
      ASSERT(level <= LAST_BUILTIN_LEVEL);
  
      mBuiltInTable[level]->insert(symbol);
  }
  
  void TSymbolTable::setDefaultPrecision(TBasicType type, TPrecision prec)
  {
      int indexOfLastElement = static_cast<int>(mPrecisionStack.size()) - 1;
      // Uses map operator [], overwrites the current value
      (*mPrecisionStack[indexOfLastElement])[type] = prec;
  }
  
  TPrecision TSymbolTable::getDefaultPrecision(TBasicType type) const
  {
      if (!SupportsPrecision(type))
          return EbpUndefined;
  
      // unsigned integers use the same precision as signed
      TBasicType baseType = (type == EbtUInt) ? EbtInt : type;
  
      int level = static_cast<int>(mPrecisionStack.size()) - 1;
      ASSERT(level >= 0);  // Just to be safe. Should not happen.
      // If we dont find anything we return this. Some types don't have predefined default precision.
      TPrecision prec = EbpUndefined;
      while (level >= 0)
      {
          PrecisionStackLevel::iterator it = mPrecisionStack[level]->find(baseType);
          if (it != mPrecisionStack[level]->end())
          {
              prec = (*it).second;
              break;
          }
          level--;
      }
      return prec;
  }
  
  void TSymbolTable::addInvariantVarying(const ImmutableString &originalName)
  {
      ASSERT(atGlobalLevel());
      mTable.back()->addInvariantVarying(originalName);
  }
  
  bool TSymbolTable::isVaryingInvariant(const ImmutableString &originalName) const
  {
      ASSERT(atGlobalLevel());
      return mTable.back()->isVaryingInvariant(originalName);
  }
  
  void TSymbolTable::setGlobalInvariant(bool invariant)
  {
      ASSERT(atGlobalLevel());
      mTable.back()->setGlobalInvariant(invariant);
  }
  
  void TSymbolTable::clearCompilationResults()
  {
      mUniqueIdCounter = kLastBuiltInId + 1;
  
      // User-defined scopes should have already been cleared when the compilation finished.
      ASSERT(mTable.size() == 0u);
  }
  
  int TSymbolTable::nextUniqueIdValue()
  {
      ASSERT(mUniqueIdCounter < std::numeric_limits<int>::max());
      return ++mUniqueIdCounter;
  }
  
  void TSymbolTable::initializeBuiltIns(sh::GLenum type,
                                        ShShaderSpec spec,
                                        const ShBuiltInResources &resources)
  {
      mShaderType = type;
  
      ASSERT(isEmpty());
      pushBuiltInLevel();  // COMMON_BUILTINS
      pushBuiltInLevel();  // ESSL1_BUILTINS
      pushBuiltInLevel();  // ESSL3_BUILTINS
      pushBuiltInLevel();  // ESSL3_1_BUILTINS
      pushBuiltInLevel();  // GLSL_BUILTINS
  
      // We need just one precision stack level for predefined precisions.
      mPrecisionStack.push_back(std::unique_ptr<PrecisionStackLevel>(new PrecisionStackLevel));
  
      switch (type)
      {
          case GL_FRAGMENT_SHADER:
              setDefaultPrecision(EbtInt, EbpMedium);
              break;
          case GL_VERTEX_SHADER:
          case GL_COMPUTE_SHADER:
          case GL_GEOMETRY_SHADER_EXT:
              setDefaultPrecision(EbtInt, EbpHigh);
              setDefaultPrecision(EbtFloat, EbpHigh);
              break;
          default:
              UNREACHABLE();
      }
      // Set defaults for sampler types that have default precision, even those that are
      // only available if an extension exists.
      // New sampler types in ESSL3 don't have default precision. ESSL1 types do.
      initSamplerDefaultPrecision(EbtSampler2D);
      initSamplerDefaultPrecision(EbtSamplerCube);
      // SamplerExternalOES is specified in the extension to have default precision.
      initSamplerDefaultPrecision(EbtSamplerExternalOES);
      // SamplerExternal2DY2YEXT is specified in the extension to have default precision.
      initSamplerDefaultPrecision(EbtSamplerExternal2DY2YEXT);
      // It isn't specified whether Sampler2DRect has default precision.
      initSamplerDefaultPrecision(EbtSampler2DRect);
  
      setDefaultPrecision(EbtAtomicCounter, EbpHigh);
  
      insertBuiltInFunctions(type);
      insertBuiltInVariables(type, spec, resources);
      mUniqueIdCounter = kLastBuiltInId + 1;
  }
  
  void TSymbolTable::initSamplerDefaultPrecision(TBasicType samplerType)
  {
      ASSERT(samplerType >= EbtGuardSamplerBegin && samplerType <= EbtGuardSamplerEnd);
      setDefaultPrecision(samplerType, EbpLow);
  }
  
  }  // namespace sh
  

Download