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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Olli Etuaho
  Date : 2018-02-16 11:50:54
  Hash : 697bf65c
  Message : Avoid redundant symbol lookup when parsing functions The lexical phase looks up symbols when it encounters an identifier. Instead of duplicating this work when parsing non-constructor functions, we now store the symbol looked up in the lexical phase in TFunctionLookup. This improves scores of the real world shader compiler perf test by 1-2%. BUG=angleproject:2267 TEST=angle_unittests Change-Id: Idc99776571313d8b654910f9daaf9bf34a048228 Reviewed-on: https://chromium-review.googlesource.com/923725 Commit-Queue: Olli Etuaho <oetuaho@nvidia.com> Reviewed-by: Jamie Madill <jmadill@chromium.org>

• src/compiler/translator/FunctionLookup.cpp

• //
  // Copyright (c) 2018 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.
  //
  // FunctionLookup.cpp: Used for storing function calls that have not yet been resolved during
  // parsing.
  //
  
  #include "compiler/translator/FunctionLookup.h"
  
  namespace sh
  {
  
  namespace
  {
  
  const char kFunctionMangledNameSeparator = '(';
  
  constexpr const ImmutableString kEmptyName("");
  
  }  // anonymous namespace
  
  TFunctionLookup::TFunctionLookup(const ImmutableString &name,
                                   const TType *constructorType,
                                   const TSymbol *symbol)
      : mName(name), mConstructorType(constructorType), mThisNode(nullptr), mSymbol(symbol)
  {
  }
  
  // static
  TFunctionLookup *TFunctionLookup::CreateConstructor(const TType *type)
  {
      ASSERT(type != nullptr);
      return new TFunctionLookup(kEmptyName, type, nullptr);
  }
  
  // static
  TFunctionLookup *TFunctionLookup::CreateFunctionCall(const ImmutableString &name,
                                                       const TSymbol *symbol)
  {
      ASSERT(name != "");
      return new TFunctionLookup(name, nullptr, symbol);
  }
  
  const ImmutableString &TFunctionLookup::name() const
  {
      return mName;
  }
  
  ImmutableString TFunctionLookup::getMangledName() const
  {
      return GetMangledName(mName.data(), mArguments);
  }
  
  ImmutableString TFunctionLookup::GetMangledName(const char *functionName,
                                                  const TIntermSequence &arguments)
  {
      std::string newName(functionName);
      newName += kFunctionMangledNameSeparator;
  
      for (TIntermNode *argument : arguments)
      {
          newName += argument->getAsTyped()->getType().getMangledName();
      }
      return ImmutableString(newName);
  }
  
  bool TFunctionLookup::isConstructor() const
  {
      return mConstructorType != nullptr;
  }
  
  const TType &TFunctionLookup::constructorType() const
  {
      return *mConstructorType;
  }
  
  void TFunctionLookup::setThisNode(TIntermTyped *thisNode)
  {
      mThisNode = thisNode;
  }
  
  TIntermTyped *TFunctionLookup::thisNode() const
  {
      return mThisNode;
  }
  
  void TFunctionLookup::addArgument(TIntermTyped *argument)
  {
      mArguments.push_back(argument);
  }
  
  TIntermSequence &TFunctionLookup::arguments()
  {
      return mArguments;
  }
  
  const TSymbol *TFunctionLookup::symbol() const
  {
      return mSymbol;
  }
  
  }  // namespace sh