[Clang] Improve EmitClangAttrSpellingListIndex

EmitClangAttrSpellingListIndex() performs a lot of
unnecessary string comparisons which is wasteful in time and space. This
commit attempts to refactor this method to be more performant.

Author: chinmaydd

clang/include/clang/Basic/AttributeCommonInfo.h

@@ -67,6 +67,16 @@ class AttributeCommonInfo {
     IgnoredAttribute,
     UnknownAttribute,
   };
+  enum Scope {
+    SC_NONE,
+    SC_CLANG,
+    SC_GNU,
+    SC_MSVC,
+    SC_OMP,
+    SC_HLSL,
+    SC_GSL,
+    SC_RISCV
+  };
 
 private:
   const IdentifierInfo *AttrName = nullptr;

clang/lib/Basic/Attributes.cpp

@@ -16,6 +16,7 @@
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ParsedAttrInfo.h"
 #include "clang/Basic/TargetInfo.h"
+#include "llvm/ADT/StringMap.h"
 
 using namespace clang;
 
@@ -153,12 +154,35 @@ std::string AttributeCommonInfo::getNormalizedFullName() const {
       normalizeName(getAttrName(), getScopeName(), getSyntax()));
 }
 
+static const llvm::StringMap<AttributeCommonInfo::Scope> ScopeMap = {
+    {"", AttributeCommonInfo::SC_NONE},
+    {"clang", AttributeCommonInfo::SC_CLANG},
+    {"gnu", AttributeCommonInfo::SC_GNU},
+    {"msvc", AttributeCommonInfo::SC_MSVC},
+    {"omp", AttributeCommonInfo::SC_OMP},
+    {"hlsl", AttributeCommonInfo::SC_HLSL},
+    {"gsl", AttributeCommonInfo::SC_GSL},
+    {"riscv", AttributeCommonInfo::SC_RISCV}};
+
+AttributeCommonInfo::Scope
+getScopeFromNormalizedScopeName(const StringRef ScopeName) {
+  auto It = ScopeMap.find(ScopeName);
+  if (It == ScopeMap.end()) {
+    llvm_unreachable("Unknown normalized scope name. Shouldn't get here");
+  }
+
+  return It->second;
+}
+
 unsigned AttributeCommonInfo::calculateAttributeSpellingListIndex() const {
   // Both variables will be used in tablegen generated
   // attribute spell list index matching code.
   auto Syntax = static_cast<AttributeCommonInfo::Syntax>(getSyntax());
-  StringRef Scope = normalizeAttrScopeName(getScopeName(), Syntax);
-  StringRef Name = normalizeAttrName(getAttrName(), Scope, Syntax);
+  StringRef ScopeName = normalizeAttrScopeName(getScopeName(), Syntax);
+  StringRef Name = normalizeAttrName(getAttrName(), ScopeName, Syntax);
+
+  AttributeCommonInfo::Scope ComputedScope =
+      getScopeFromNormalizedScopeName(ScopeName);
 
 #include "clang/Sema/AttrSpellingListIndex.inc"
 }

clang/utils/TableGen/ClangAttrEmitter.cpp

@@ -20,6 +20,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -3843,11 +3844,95 @@ void EmitClangAttrSpellingListIndex(const RecordKeeper &Records,
     const Record &R = *I.second;
     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
     OS << "  case AT_" << I.first << ": {\n";
-    for (unsigned I = 0; I < Spellings.size(); ++ I) {
-      OS << "    if (Name == \"" << Spellings[I].name() << "\" && "
-         << "getSyntax() == AttributeCommonInfo::AS_" << Spellings[I].variety()
-         << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
-         << "        return " << I << ";\n";
+
+    // If there are none or one spelling to check, resort to the default
+    // behavior of returning index as 0.
+    if (Spellings.size() <= 1) {
+      OS << "    return 0;\n";
+      OS << "    break;\n";
+      OS << "  }\n";
+      continue;
+    }
+
+    bool HasSingleUniqueSpellingName = true;
+    StringMap<std::vector<const FlattenedSpelling *>> SpellingMap;
+
+    StringRef FirstName = Spellings.front().name();
+    for (const auto &S : Spellings) {
+      StringRef Name = S.name();
+      if (Name != FirstName)
+        HasSingleUniqueSpellingName = false;
+      SpellingMap[Name].push_back(&S);
+    }
+
+    // If parsed attribute has only one possible spelling name, only compare
+    // syntax and scope.
+    if (HasSingleUniqueSpellingName) {
+      for (const auto &[Idx, S] : enumerate(SpellingMap[FirstName])) {
+        OS << "    if (getSyntax() == AttributeCommonInfo::AS_" << S->variety();
+
+        std::string ScopeStr = "AttributeCommonInfo::SC_";
+        if (S->nameSpace() == "")
+          ScopeStr += "NONE";
+        else
+          ScopeStr += S->nameSpace().upper();
+
+        OS << " && ComputedScope == " << ScopeStr << ")\n"
+           << "      return " << Idx << ";\n";
+      }
+    } else {
+      size_t Idx = 0;
+      for (const auto &MapEntry : SpellingMap) {
+        StringRef Name = MapEntry.first();
+        const std::vector<const FlattenedSpelling *> &Cases = SpellingMap[Name];
+
+        if (Cases.size() > 1) {
+          // For names with multiple possible cases, emit an enclosing if such
+          // that the name is compared against only once. Eg:
+          //
+          // if (Name == "always_inline") {
+          //   if (getSyntax() == AttributeCommonInfo::AS_GNU &&
+          //       ComputedScope == AttributeCommonInfo::SC_None)
+          //     return 0;
+          //   ...
+          // }
+          OS << "    if (Name == \"" << Name << "\") {\n";
+          for (const auto &S : SpellingMap[Name]) {
+            OS << "      if (getSyntax() == AttributeCommonInfo::AS_"
+               << S->variety();
+            std::string ScopeStr = "AttributeCommonInfo::SC_";
+            if (S->nameSpace() == "")
+              ScopeStr += "NONE";
+            else
+              ScopeStr += S->nameSpace().upper();
+
+            OS << " && ComputedScope == " << ScopeStr << ")\n"
+               << "        return " << Idx << ";\n";
+            Idx++;
+          }
+          OS << "    }\n";
+        } else {
+          // If there is only possible case for the spelling name, no need of
+          // enclosing if. Eg.
+          //
+          // if (Name == "__forceinline" &&
+          //     getSyntax() == AttributeCommonInfo::AS_Keyword
+          //     && ComputedScope == AttributeCommonInfo::SC_NONE)
+          //   return 5;
+          const FlattenedSpelling *S = Cases.front();
+          OS << "    if (Name == \"" << Name << "\"";
+          OS << " && getSyntax() == AttributeCommonInfo::AS_" << S->variety();
+          std::string ScopeStr = "AttributeCommonInfo::SC_";
+          if (S->nameSpace() == "")
+            ScopeStr += "NONE";
+          else
+            ScopeStr += S->nameSpace().upper();
+
+          OS << " && ComputedScope == " << ScopeStr << ")\n"
+             << "        return " << Idx << ";\n";
+          Idx++;
+        }
+      }
     }
 
     OS << "    break;\n";