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

• Show log

  Commit

• Hash : 25390156
  Author :
  Date : 2025-08-21T00:13:19
  

  Suppress unsafe buffers on a file-by-file basis in src/ [1 of N]
  
  In this CL, we suppress many files but stop short of actually
  enabling the warning by not removing the line from the
  unsafe_buffers_paths.txt file. That will happen in a follow-on
  CL, along with resolving any stragglers missed here.
  
  This is mostly a manual change so as to familiarize myself with
  the kinds of issues faced by the Angle codebase when applying buffer
  safety warnings.
  
  -- Re-generate affected hashes.
  -- Clang-format applied to all changed files.
  -- Add a few missing .reserve() calls to vectors as noticed.
  -- Fix some mismatches between file names and header comments.
  -- Be more consistent with header comment format (blank lines and
     trailing //-only lines when a filename comment adjoins license
     boilerplate).
  
  Bug: b/436880895
  Change-Id: I3bde5cc2059acbe8345057289214f1a26f1c34aa
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6869022
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/compiler/translator/Symbol.cpp

• //
  // Copyright 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.
  //
  
  #ifdef UNSAFE_BUFFERS_BUILD
  #    pragma allow_unsafe_buffers
  #endif
  
  #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");
  constexpr const ImmutableString kImageAtomicExchangeName("imageAtomicExchange");
  constexpr const ImmutableString kAtomicCounterName("atomicCounter");
  
  static const char kFunctionMangledNameSeparator = '(';
  
  }  // anonymous namespace
  
  TSymbol::TSymbol(TSymbolTable *symbolTable,
                   const ImmutableString &name,
                   SymbolType symbolType,
                   SymbolClass symbolClass,
                   TExtension extension)
      : mName(name),
        mUniqueId(symbolTable->nextUniqueId()),
        mExtensions(
            std::array<TExtension, 3u>{{extension, TExtension::UNDEFINED, TExtension::UNDEFINED}}),
        mSymbolType(symbolType),
        mSymbolClass(symbolClass)
  {
      ASSERT(mSymbolType == SymbolType::BuiltIn || extension == TExtension::UNDEFINED);
      ASSERT(mName != "" || mSymbolType == SymbolType::AngleInternal ||
             mSymbolType == SymbolType::Empty);
  }
  
  TSymbol::TSymbol(TSymbolTable *symbolTable,
                   const ImmutableString &name,
                   SymbolType symbolType,
                   SymbolClass symbolClass,
                   const std::array<TExtension, 3u> &extensions)
      : mName(name),
        mUniqueId(symbolTable->nextUniqueId()),
        mExtensions(extensions),
        mSymbolType(symbolType),
        mSymbolClass(symbolClass)
  {
      ASSERT(mSymbolType == SymbolType::BuiltIn || extensions[0] == TExtension::UNDEFINED);
      ASSERT(mName != "" || mSymbolType == SymbolType::AngleInternal ||
             mSymbolType == SymbolType::Empty);
  }
  
  ImmutableString TSymbol::name() const
  {
      if (!mName.empty())
      {
          return mName;
      }
      // This can be called for nameless function parameters in HLSL.
      ASSERT(mSymbolType == SymbolType::AngleInternal ||
             (mSymbolType == SymbolType::Empty && isVariable()));
      int uniqueId = mUniqueId.get();
      ImmutableStringBuilder symbolNameOut(sizeof(uniqueId) * 2u + 1u);
      symbolNameOut << 's';
      symbolNameOut.appendHex(mUniqueId.get());
      return symbolNameOut;
  }
  
  ImmutableString TSymbol::getMangledName() const
  {
      if (mSymbolClass == SymbolClass::Function)
      {
          // We do this instead of using proper virtual functions so that we can better support
          // constexpr symbols.
          return static_cast<const TFunction *>(this)->getFunctionMangledName();
      }
      ASSERT(mSymbolType != SymbolType::Empty);
      return name();
  }
  
  TVariable::TVariable(TSymbolTable *symbolTable,
                       const ImmutableString &name,
                       const TType *type,
                       SymbolType symbolType,
                       TExtension extension)
      : TSymbol(symbolTable, name, symbolType, SymbolClass::Variable, extension),
        mType(type),
        unionArray(nullptr)
  {
      ASSERT(mType);
      ASSERT(name.empty() || symbolType != SymbolType::Empty);
  }
  
  TVariable::TVariable(TSymbolTable *symbolTable,
                       const ImmutableString &name,
                       const TType *type,
                       SymbolType symbolType,
                       const std::array<TExtension, 3u> &extensions)
      : TSymbol(symbolTable, name, symbolType, SymbolClass::Variable, extensions),
        mType(type),
        unionArray(nullptr)
  {
      ASSERT(mType);
      ASSERT(name.empty() || symbolType != SymbolType::Empty);
  }
  
  TStructure::TStructure(TSymbolTable *symbolTable,
                         const ImmutableString &name,
                         const TFieldList *fields,
                         SymbolType symbolType)
      : TSymbol(symbolTable, name, symbolType, SymbolClass::Struct), 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 = sh::InitializeStream<std::stringstream>();
              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, SymbolClass::InterfaceBlock, extension),
        TFieldListCollection(fields),
        mBlockStorage(layoutQualifier.blockStorage),
        mBinding(layoutQualifier.binding),
        mIsDefaultUniformBlock(false)
  {
      ASSERT(name != nullptr);
  }
  
  TInterfaceBlock::TInterfaceBlock(TSymbolTable *symbolTable,
                                   const ImmutableString &name,
                                   const TFieldList *fields,
                                   const TLayoutQualifier &layoutQualifier,
                                   SymbolType symbolType,
                                   const std::array<TExtension, 3u> &extensions)
      : TSymbol(symbolTable, name, symbolType, SymbolClass::InterfaceBlock, extensions),
        TFieldListCollection(fields),
        mBlockStorage(layoutQualifier.blockStorage),
        mBinding(layoutQualifier.binding),
        mIsDefaultUniformBlock(false)
  {
      ASSERT(name != nullptr);
  }
  
  TFunction::TFunction(TSymbolTable *symbolTable,
                       const ImmutableString &name,
                       SymbolType symbolType,
                       const TType *retType,
                       bool knownToNotHaveSideEffects)
      : TSymbol(symbolTable, name, symbolType, SymbolClass::Function, TExtension::UNDEFINED),
        mParametersVector(new TParamVector()),
        mParameters(nullptr),
        returnType(retType),
        mMangledName(""),
        mParamCount(0u),
        mOp(EOpNull),
        defined(false),
        mHasPrototypeDeclaration(false),
        mKnownToNotHaveSideEffects(knownToNotHaveSideEffects),
        mHasVoidParameter(false)
  {
      // Functions with an empty name are not allowed.
      ASSERT(symbolType != SymbolType::Empty);
      ASSERT(name != nullptr || symbolType == SymbolType::AngleInternal);
  }
  
  void TFunction::addParameter(const TVariable *p)
  {
      ASSERT(mParametersVector);
      mParametersVector->push_back(p);
      mParameters  = mParametersVector->data();
      mParamCount  = mParametersVector->size();
      mMangledName = kEmptyImmutableString;
  }
  
  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
  {
      ImmutableString name = this->name();
      std::string newName(name.data(), name.length());
      newName += kFunctionMangledNameSeparator;
  
      for (size_t i = 0u; i < mParamCount; ++i)
      {
          newName += mParameters[i]->getType().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 ||
              name() == kImageAtomicExchangeName);
  }
  
  bool TFunction::isAtomicCounterFunction() const
  {
      return SymbolType() == SymbolType::BuiltIn && name().beginsWith(kAtomicCounterName);
  }
  }  // namespace sh
  

Download