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

• Show log

  Commit

• Hash : 391bda23
  Author :
  Date : 2018-02-23T11:43:14
  

  Generate code for initializing built-in variables
  
  gen_builtin_symbols.py now generates code for initializing built-in
  variable symbols as well. Some of the variable symbols are static, but
  some of them also get initialized dynamically based on values in
  ShBuiltInResources.
  
  The static symbols have get functions in a header file so they can be
  referenced from AST traversers as well without doing a lookup.
  
  BUG=angleproject:2267
  TEST=angle_unittests, angle_end2end_tests
  
  Change-Id: Ida7f3aeb06d2bce0f737f1483b1bd5833aeddd2e
  Reviewed-on: https://chromium-review.googlesource.com/911768
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/compiler/translator/Symbol.cpp

• //
  // Copyright (c) 2017 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.cpp: Symbols representing variables, functions, structures and interface blocks.
  //
  
  #if defined(_MSC_VER)
  #pragma warning(disable : 4718)
  #endif
  
  #include "compiler/translator/Symbol.h"
  
  #include "compiler/translator/ImmutableStringBuilder.h"
  #include "compiler/translator/SymbolTable.h"
  
  namespace sh
  {
  
  namespace
  {
  
  constexpr const ImmutableString kMainName("main");
  constexpr const ImmutableString kImageLoadName("imageLoad");
  constexpr const ImmutableString kImageStoreName("imageStore");
  constexpr const ImmutableString kImageSizeName("imageSize");
  
  static const char kFunctionMangledNameSeparator = '(';
  
  }  // anonymous namespace
  
  TSymbol::TSymbol(TSymbolTable *symbolTable,
                   const ImmutableString &name,
                   SymbolType symbolType,
                   TExtension extension)
      : mName(name),
        mUniqueId(symbolTable->nextUniqueId()),
        mSymbolType(symbolType),
        mExtension(extension)
  {
      ASSERT(mSymbolType == SymbolType::BuiltIn || mExtension == TExtension::UNDEFINED);
      ASSERT(mName != "" || mSymbolType == SymbolType::AngleInternal ||
             mSymbolType == SymbolType::Empty);
  }
  
  ImmutableString TSymbol::name() const
  {
      if (mName != "")
      {
          return mName;
      }
      ASSERT(mSymbolType == SymbolType::AngleInternal);
      int uniqueId = mUniqueId.get();
      ImmutableStringBuilder symbolNameOut(sizeof(uniqueId) * 2u + 1u);
      symbolNameOut << 's';
      symbolNameOut.appendHex(mUniqueId.get());
      return symbolNameOut;
  }
  
  ImmutableString TSymbol::getMangledName() const
  {
      ASSERT(mSymbolType != SymbolType::Empty);
      return name();
  }
  
  TVariable::TVariable(TSymbolTable *symbolTable,
                       const ImmutableString &name,
                       const TType *type,
                       SymbolType symbolType,
                       TExtension extension)
      : TSymbol(symbolTable, name, symbolType, extension), mType(type), unionArray(nullptr)
  {
      ASSERT(mType);
  }
  
  TStructure::TStructure(TSymbolTable *symbolTable,
                         const ImmutableString &name,
                         const TFieldList *fields,
                         SymbolType symbolType)
      : TSymbol(symbolTable, name, symbolType), TFieldListCollection(fields)
  {
  }
  
  TStructure::TStructure(const TSymbolUniqueId &id,
                         const ImmutableString &name,
                         TExtension extension,
                         const TFieldList *fields)
      : TSymbol(id, name, SymbolType::BuiltIn, extension), TFieldListCollection(fields)
  {
  }
  
  void TStructure::createSamplerSymbols(const char *namePrefix,
                                        const TString &apiNamePrefix,
                                        TVector<const TVariable *> *outputSymbols,
                                        TMap<const TVariable *, TString> *outputSymbolsToAPINames,
                                        TSymbolTable *symbolTable) const
  {
      ASSERT(containsSamplers());
      for (const auto *field : *mFields)
      {
          const TType *fieldType = field->type();
          if (IsSampler(fieldType->getBasicType()) || fieldType->isStructureContainingSamplers())
          {
              std::stringstream fieldName;
              fieldName << namePrefix << "_" << field->name();
              TString fieldApiName = apiNamePrefix + ".";
              fieldApiName += field->name().data();
              fieldType->createSamplerSymbols(ImmutableString(fieldName.str()), fieldApiName,
                                              outputSymbols, outputSymbolsToAPINames, symbolTable);
          }
      }
  }
  
  void TStructure::setName(const ImmutableString &name)
  {
      ImmutableString *mutableName = const_cast<ImmutableString *>(&mName);
      *mutableName         = name;
  }
  
  TInterfaceBlock::TInterfaceBlock(TSymbolTable *symbolTable,
                                   const ImmutableString &name,
                                   const TFieldList *fields,
                                   const TLayoutQualifier &layoutQualifier,
                                   SymbolType symbolType,
                                   TExtension extension)
      : TSymbol(symbolTable, name, symbolType, extension),
        TFieldListCollection(fields),
        mBlockStorage(layoutQualifier.blockStorage),
        mBinding(layoutQualifier.binding)
  {
      ASSERT(name != nullptr);
  }
  
  TInterfaceBlock::TInterfaceBlock(const TSymbolUniqueId &id,
                                   const ImmutableString &name,
                                   TExtension extension,
                                   const TFieldList *fields)
      : TSymbol(id, name, SymbolType::BuiltIn, extension),
        TFieldListCollection(fields),
        mBlockStorage(EbsUnspecified),
        mBinding(0)
  {
  }
  
  TFunction::TFunction(TSymbolTable *symbolTable,
                       const ImmutableString &name,
                       SymbolType symbolType,
                       const TType *retType,
                       bool knownToNotHaveSideEffects)
      : TSymbol(symbolTable, name, symbolType, TExtension::UNDEFINED),
        mParametersVector(new TParamVector()),
        mParameters(nullptr),
        mParamCount(0u),
        returnType(retType),
        mMangledName(""),
        mOp(EOpNull),
        defined(false),
        mHasPrototypeDeclaration(false),
        mKnownToNotHaveSideEffects(knownToNotHaveSideEffects)
  {
      // Functions with an empty name are not allowed.
      ASSERT(symbolType != SymbolType::Empty);
      ASSERT(name != nullptr || symbolType == SymbolType::AngleInternal);
  }
  
  void TFunction::addParameter(const TConstParameter &p)
  {
      ASSERT(mParametersVector);
      mParametersVector->push_back(p);
      mParameters  = mParametersVector->data();
      mParamCount  = mParametersVector->size();
      mMangledName = ImmutableString("");
  }
  
  void TFunction::shareParameters(const TFunction &parametersSource)
  {
      mParametersVector = nullptr;
      mParameters       = parametersSource.mParameters;
      mParamCount       = parametersSource.mParamCount;
      ASSERT(parametersSource.name() == name());
      mMangledName = parametersSource.mMangledName;
  }
  
  ImmutableString TFunction::buildMangledName() const
  {
      std::string newName(name().data(), name().length());
      newName += kFunctionMangledNameSeparator;
  
      for (size_t i = 0u; i < mParamCount; ++i)
      {
          newName += mParameters[i].type->getMangledName();
      }
      return ImmutableString(newName);
  }
  
  bool TFunction::isMain() const
  {
      return symbolType() == SymbolType::UserDefined && name() == kMainName;
  }
  
  bool TFunction::isImageFunction() const
  {
      return symbolType() == SymbolType::BuiltIn &&
             (name() == kImageSizeName || name() == kImageLoadName || name() == kImageStoreName);
  }
  
  }  // namespace sh
  

Download