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

• Show log

  Commit

• Hash : 8e9dc1a6
  Author :
  Date : 2024-11-19T11:08:31
  

  Validate anonymous struct names with namespace
  
  Consider GLSL:
      struct { vec4 e; } g;
      struct sbbf { vec4 f; };
  
  The struct name validation would fail if user chosen struct name would
  clash with a symbol name that ANGLE internally gave to an anonymous
  struct.
  
  Fix by importing Name abstraction from MSL backend. A symbol name is
  a pair (namespace, string).
  
  Move  operator<<(std::ostream &os, const ImmutableString &str)
  to sh namespace because that is more natural for operator overloading
  name resolution. MSVC works with this.
  
  Bug: angleproject:379758201
  Change-Id: Icc9b02aa8cb532e1d925e2fba4c45468f01b9144
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6035029
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Auto-Submit: Kimmo Kinnunen <kkinnunen@apple.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Kimmo Kinnunen <kkinnunen@apple.com>
  

Download

• src/compiler/translator/Name.cpp

• //
  // Copyright 2020 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 "compiler/translator/Name.h"
  #include "common/debug.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  namespace sh
  {
  ////////////////////////////////////////////////////////////////////////////////
  
  template <typename T>
  static ImmutableString GetName(T const &object)
  {
      if (object.symbolType() == SymbolType::Empty)
      {
          return kEmptyImmutableString;
      }
      return object.name();
  }
  
  Name::Name(const TField &field) : Name(GetName(field), field.symbolType()) {}
  
  Name::Name(const TSymbol &symbol) : Name(GetName(symbol), symbol.symbolType()) {}
  
  bool Name::operator==(const Name &other) const
  {
      return mRawName == other.mRawName && mSymbolType == other.mSymbolType;
  }
  
  bool Name::operator!=(const Name &other) const
  {
      return !(*this == other);
  }
  
  bool Name::operator<(const Name &other) const
  {
      if (mRawName < other.mRawName)
      {
          return true;
      }
      if (other.mRawName < mRawName)
      {
          return false;
      }
      return mSymbolType < other.mSymbolType;
  }
  
  bool Name::empty() const
  {
      return mSymbolType == SymbolType::Empty;
  }
  
  bool Name::beginsWith(const Name &prefix) const
  {
      if (mSymbolType != prefix.mSymbolType)
      {
          return false;
      }
      return mRawName.beginsWith(prefix.mRawName);
  }
  
  void Name::emit(TInfoSinkBase &out) const
  {
      emitImpl(out);
  }
  
  template <typename T>
  void Name::emitImpl(T &out) const
  {
      switch (mSymbolType)
      {
          case SymbolType::BuiltIn:
              ASSERT(!mRawName.empty());
              out << mRawName;
              break;
  
          case SymbolType::UserDefined:
              ASSERT(!mRawName.empty());
              if (mRawName != "main")
              {
                  out << kUserDefinedNamePrefix << mRawName;
              }
              else
              {
                  out << mRawName;
              }
              break;
  
          case SymbolType::AngleInternal:
              ASSERT(!mRawName.empty());
              if (mRawName.beginsWith(kAngleInternalPrefix))
              {
                  out << mRawName;
              }
              else
              {
                  out << kAngleInternalPrefix << '_' << mRawName;
              }
              break;
  
          case SymbolType::Empty:
              UNREACHABLE();
              break;
      }
  }
  
  std::ostream &operator<<(std::ostream &out, const Name &name)
  {
      name.emitImpl(out);
      return out;
  }
  
  ////////////////////////////////////////////////////////////////////////////////
  
  namespace
  {
  
  // NOTE: This matches more things than FindSymbolNode.
  class ExpressionContainsNameVisitor : public TIntermTraverser
  {
      Name mName;
      bool mFoundName = false;
  
    public:
      ExpressionContainsNameVisitor(const Name &name)
          : TIntermTraverser(true, false, false), mName(name)
      {}
  
      bool foundName() const { return mFoundName; }
  
      void visitSymbol(TIntermSymbol *node) override
      {
          if (Name(node->variable()) == mName)
          {
              mFoundName = true;
          }
      }
  
      bool visitSwizzle(Visit, TIntermSwizzle *) override { return !mFoundName; }
  
      bool visitBinary(Visit visit, TIntermBinary *node) override { return !mFoundName; }
  
      bool visitUnary(Visit visit, TIntermUnary *node) override { return !mFoundName; }
  
      bool visitTernary(Visit visit, TIntermTernary *node) override { return !mFoundName; }
  
      bool visitAggregate(Visit visit, TIntermAggregate *node) override
      {
          if (node->isConstructor())
          {
              const TType &type           = node->getType();
              const TStructure *structure = type.getStruct();
              if (structure && Name(*structure) == mName)
              {
                  mFoundName = true;
              }
          }
          else
          {
              const TFunction *func = node->getFunction();
              if (func && Name(*func) == mName)
              {
                  mFoundName = true;
              }
          }
          return !mFoundName;
      }
  
      bool visitIfElse(Visit visit, TIntermIfElse *node) override
      {
          UNREACHABLE();
          return false;
      }
  
      bool visitSwitch(Visit, TIntermSwitch *) override
      {
          UNREACHABLE();
          return false;
      }
      bool visitCase(Visit, TIntermCase *) override
      {
          UNREACHABLE();
          return false;
      }
  
      void visitFunctionPrototype(TIntermFunctionPrototype *) override { UNREACHABLE(); }
  
      bool visitFunctionDefinition(Visit, TIntermFunctionDefinition *) override
      {
          UNREACHABLE();
          return false;
      }
  
      bool visitBlock(Visit, TIntermBlock *) override
      {
          UNREACHABLE();
          return false;
      }
  
      bool visitGlobalQualifierDeclaration(Visit, TIntermGlobalQualifierDeclaration *) override
      {
          UNREACHABLE();
          return false;
      }
  
      bool visitDeclaration(Visit, TIntermDeclaration *) override
      {
          UNREACHABLE();
          return false;
      }
  
      bool visitLoop(Visit, TIntermLoop *) override
      {
          UNREACHABLE();
          return false;
      }
  
      bool visitBranch(Visit, TIntermBranch *) override
      {
          UNREACHABLE();
          return false;
      }
  
      void visitPreprocessorDirective(TIntermPreprocessorDirective *) override { UNREACHABLE(); }
  };
  
  }  // anonymous namespace
  
  bool ExpressionContainsName(const Name &name, TIntermTyped &node)
  {
      ExpressionContainsNameVisitor visitor(name);
      node.traverse(&visitor);
      return visitor.foundName();
  }
  
  }  // namespace sh
  

Download