[Attributes] Make intrinsic attribute generation more flexible (NFC)

[nikic]

Summary

Currently attributes for intrinsics are emitted using the ArrayRef<AttrKind> based constructor for AttributeLists. This works out fine for simple enum attributes, but doesn't really generalize to attributes that accept values. We're already doing something awkward for alignment attributes, and I'd like to have a cleaner solution to this with https://discourse.llvm.org/t/rfc-unify-memory-effect-attributes/65579 in mind.

The new generation approach is to instead directly construct Attributes, giving us access to the full generality of that interface. To avoid significantly increasing the size of the generated code, we now also deduplicate the attribute sets. The code generated per unique AttributeList looks like this:

case 204: {
  AS[0] = {1, getIntrinsicArgAttributeSet(C, 5)};
  AS[1] = {AttributeList::FunctionIndex, getIntrinsicFnAttributeSet(C, 10)};
  NumAttrs = 2;
  break;
}

and then the helper functions contain something like

case 5:
  return AttributeSet::get(C, {
    Attribute::get(C, Attribute::NoCapture),
  });

and

case 10:
  return AttributeSet::get(C, {
    Attribute::get(C, Attribute::NoUnwind),
    Attribute::get(C, Attribute::ArgMemOnly),
  });

A casualty of this change is the intrin-properties.td test, as I don't think that FileCheck allows matching this kind of output.

[aeubanks]

I measured building llvm-dis

perf stat:
before this patch: 1749B instructions
after this patch: 1752B instructions
(only generating the intrinsic files gives ~1B instruction increase)

llvm-dis size:
before this patch: 17860464 bytes
after this patch: 17877312 bytes

the compile time increase looks non-trivial but is probably ok

llvm/utils/TableGen/IntrinsicEmitter.cpp

883

I guess the alternative would be to have another hasAtLeastOneAttribute bool in the entries for UniqFnAttributes that's set when populating UniqFnAttributes, but that's not that much better

llvm/test/TableGen/intrin-properties.td

-// RUN: sed -e 's/<PROP>/ArgMemOnly/;s/<ATTR>/ArgMemOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/Cold/;s/<ATTR>/Cold/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/Convergent/;s/<ATTR>/Convergent/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/InaccessibleMemOnly/;s/<ATTR>/InaccessibleMemOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/InaccessibleMemOrArgMemOnly/;s/<ATTR>/InaccessibleMemOrArgMemOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/NoDuplicate/;s/<ATTR>/NoDuplicate/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/NoFree/;s/<ATTR>/NoFree/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/NoMem/;s/<ATTR>/ReadNone/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/NoMerge/;s/<ATTR>/NoMerge/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/NoReturn/;s/<ATTR>/NoReturn/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/NoSync/;s/<ATTR>/NoSync/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/ReadMem/;s/<ATTR>/ReadOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/Speculatable/;s/<ATTR>/Speculatable/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/WillReturn/;s/<ATTR>/WillReturn/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-// RUN: sed -e 's/<PROP>/WriteMem/;s/<ATTR>/WriteOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
-
-include "llvm/IR/Intrinsics.td"
-
-// CHECK: [[I:[0-9]+]], // llvm.tgtest.Intr<PROP>
-// CHECK: case [[I]]:
-// CHECK-NEXT: Atts[] = {{.*}}Attribute::<ATTR>
-def int_tgtest_Intr<PROP>:
-  Intrinsic<[llvm_i32_ty], [llvm_ptr_ty], [Intr<PROP>]>;
-

llvm/test/TableGen/intrin-side-effects.td

class Intrinsic<list<LLVMType> ret_types,
 
   bit isTarget = 0;
   bit DisableDefaultAttributes = disable_default_attributes;
 }
 
 // ... this intrinsic.
 def int_random_gen   : Intrinsic<[llvm_i32_ty], [], [IntrNoMem, IntrHasSideEffects]>;
 
+// CHECK: static AttributeSet getIntrinsicFnAttributeSet(
+// CHECK: case 0:
+// CHECK-NEXT: return AttributeSet::get(C, {
+// CHECK-NEXT: Attribute::get(C, Attribute::NoUnwind),
+// CHECK-NEXT: });
+
 // CHECK: 1, // llvm.random.gen
 // CHECK: case 1:
-// CHECK-NEXT: Atts[] = {Attribute::NoUnwind}
+// CHECK-NEXT: AS[0] = {AttributeList::FunctionIndex, getIntrinsicFnAttributeSet(C, 0)};

llvm/utils/TableGen/CodeGenIntrinsics.h

public:
   };
   std::vector<TargetSet> Targets;
 
   explicit CodeGenIntrinsicTable(const RecordKeeper &RC);
   CodeGenIntrinsicTable() = default;
 
   bool empty() const { return Intrinsics.empty(); }
   size_t size() const { return Intrinsics.size(); }
+  auto begin() const { return Intrinsics.begin(); }
+  auto end() const { return Intrinsics.end(); }
   CodeGenIntrinsic &operator[](size_t Pos) { return Intrinsics[Pos]; }
   const CodeGenIntrinsic &operator[](size_t Pos) const {
     return Intrinsics[Pos];
   }
 };
 }
 
 #endif

llvm/utils/TableGen/IntrinsicEmitter.cpp

 //===- IntrinsicEmitter.cpp - Generate intrinsic information --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This tablegen backend emits information about intrinsic functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenIntrinsics.h"
 #include "CodeGenTarget.h"
 #include "SequenceToOffsetTable.h"
 #include "TableGenBackends.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/StringToOffsetTable.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <algorithm>
 using namespace llvm;
void IntrinsicEmitter::EmitGenerator(const CodeGenIntrinsicTable &Ints,
   if (!LongEncodingTable.empty())
     LongEncodingTable.emit(OS, printIITEntry);
   OS << "  255\n};\n\n";
 
   OS << "#endif\n\n";  // End of GET_INTRINSIC_GENERATOR_GLOBAL
 }
 
 namespace {
-struct AttributeComparator {
-  bool operator()(const CodeGenIntrinsic *L, const CodeGenIntrinsic *R) const {
-    // Sort throwing intrinsics after non-throwing intrinsics.
-    if (L->canThrow != R->canThrow)
-      return R->canThrow;
+Optional<bool> compareFnAttributes(const CodeGenIntrinsic *L,
+                                   const CodeGenIntrinsic *R) {
 
-    if (L->isNoDuplicate != R->isNoDuplicate)
-      return R->isNoDuplicate;
 
-    if (L->isNoMerge != R->isNoMerge)
-      return R->isNoMerge;
 
-    if (L->isNoReturn != R->isNoReturn)
-      return R->isNoReturn;
 
-    if (L->isNoCallback != R->isNoCallback)
-      return R->isNoCallback;
 
-    if (L->isNoSync != R->isNoSync)
-      return R->isNoSync;
 
-    if (L->isNoFree != R->isNoFree)
-      return R->isNoFree;
 
-    if (L->isWillReturn != R->isWillReturn)
-      return R->isWillReturn;
 
-    if (L->isCold != R->isCold)
-      return R->isCold;
 
-    if (L->isConvergent != R->isConvergent)
-      return R->isConvergent;
 
-    if (L->isSpeculatable != R->isSpeculatable)
-      return R->isSpeculatable;
 
-    if (L->hasSideEffects != R->hasSideEffects)
-      return R->hasSideEffects;
 
-    // Try to order by readonly/readnone attribute.
-    CodeGenIntrinsic::ModRefBehavior LK = L->ModRef;
-    CodeGenIntrinsic::ModRefBehavior RK = R->ModRef;
-    if (LK != RK) return (LK > RK);
+
+  return None;
+}
+
+struct FnAttributeComparator {
+  bool operator()(const CodeGenIntrinsic *L, const CodeGenIntrinsic *R) const {
+    return compareFnAttributes(L, R).value_or(false);
+  }
+};
+
+struct AttributeComparator {
+  bool operator()(const CodeGenIntrinsic *L, const CodeGenIntrinsic *R) const {
+    if (Optional<bool> Res = compareFnAttributes(L, R))
+      return *Res;
+
     // Order by argument attributes.
     // This is reliable because each side is already sorted internally.
     return (L->ArgumentAttributes < R->ArgumentAttributes);
   }
 };
 } // End anonymous namespace
 
 /// EmitAttributes - This emits the Intrinsic::getAttributes method.
 void IntrinsicEmitter::EmitAttributes(const CodeGenIntrinsicTable &Ints,
                                       raw_ostream &OS) {
   OS << "// Add parameter attributes that are not common to all intrinsics.\n";
   OS << "#ifdef GET_INTRINSIC_ATTRIBUTES\n";
-  OS << "AttributeList Intrinsic::getAttributes(LLVMContext &C, ID id) {\n";
-
-  // Compute the maximum number of attribute arguments and the map
-  typedef std::map<const CodeGenIntrinsic*, unsigned,
-                   AttributeComparator> UniqAttrMapTy;
-  UniqAttrMapTy UniqAttributes;
-  unsigned maxArgAttrs = 0;
-  unsigned AttrNum = 0;
-  for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
-    const CodeGenIntrinsic &intrinsic = Ints[i];
-    maxArgAttrs =
-      std::max(maxArgAttrs, unsigned(intrinsic.ArgumentAttributes.size()));
-    unsigned &N = UniqAttributes[&intrinsic];
-    if (N) continue;
-    N = ++AttrNum;
-    assert(N < 65536 && "Too many unique attributes for table!");
-  }
-
-  // Emit an array of AttributeList.  Most intrinsics will have at least one
-  // entry, for the function itself (index ~1), which is usually nounwind.
-  OS << "  static const uint16_t IntrinsicsToAttributesMap[] = {\n";
 
-  for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
-    const CodeGenIntrinsic &intrinsic = Ints[i];
-
-    OS << "    " << UniqAttributes[&intrinsic] << ", // "
-       << intrinsic.Name << "\n";
-  }
-  OS << "  };\n\n";
-
-  OS << "  AttributeList AS[" << maxArgAttrs + 1 << "];\n";
-  OS << "  unsigned NumAttrs = 0;\n";
-  OS << "  if (id != 0) {\n";
-  OS << "    switch(IntrinsicsToAttributesMap[id - 1]) {\n";
-  OS << "    default: llvm_unreachable(\"Invalid attribute number\");\n";
-  for (auto UniqAttribute : UniqAttributes) {
-    OS << "    case " << UniqAttribute.second << ": {\n";
-
-    const CodeGenIntrinsic &Intrinsic = *(UniqAttribute.first);
-
-    // Keep track of the number of attributes we're writing out.
-    unsigned numAttrs = 0;
-
-    for (const auto &[AttrIdx, Attrs] :
-         enumerate(Intrinsic.ArgumentAttributes)) {
+  // Compute unique argument attribute sets.
+  std::map<SmallVector<CodeGenIntrinsic::ArgAttribute, 0>, unsigned>
+      UniqArgAttributes;
+  OS << "static AttributeSet getIntrinsicArgAttributeSet("
+     << "LLVMContext &C, unsigned ID) {\n"
+     << "  switch (ID) {\n"
+     << "  default: llvm_unreachable(\"Invalid attribute set number\");\n";
+  for (const CodeGenIntrinsic &Int : Ints) {
+    for (auto &Attrs : Int.ArgumentAttributes) {
       if (Attrs.empty())
         continue;
 
-      // The argument attributes are alreadys sorted by argument kind.
+      unsigned ID = UniqArgAttributes.size();
+      if (!UniqArgAttributes.try_emplace(Attrs, ID).second)
+        continue;
+
       assert(is_sorted(Attrs) &&
              "Argument attributes are not sorted");
 
-      OS << "      const Attribute::AttrKind AttrParam" << AttrIdx << "[] = {";
-      ListSeparator LS(",");
-      bool AllValuesAreZero = true;
-      SmallVector<uint64_t, 8> Values;
+      OS << "  case " << ID << ":\n";
+      OS << "    return AttributeSet::get(C, {\n";
       for (const CodeGenIntrinsic::ArgAttribute &Attr : Attrs) {
         switch (Attr.Kind) {
         case CodeGenIntrinsic::NoCapture:
-          OS << LS << "Attribute::NoCapture";
+          OS << "      Attribute::get(C, Attribute::NoCapture),\n";
           break;
         case CodeGenIntrinsic::NoAlias:
-          OS << LS << "Attribute::NoAlias";
+          OS << "      Attribute::get(C, Attribute::NoAlias),\n";
           break;
         case CodeGenIntrinsic::NoUndef:
-          OS << LS << "Attribute::NoUndef";
+          OS << "      Attribute::get(C, Attribute::NoUndef),\n";
           break;
         case CodeGenIntrinsic::NonNull:
-          OS << LS << "Attribute::NonNull";
+          OS << "      Attribute::get(C, Attribute::NonNull),\n";
           break;
         case CodeGenIntrinsic::Returned:
-          OS << LS << "Attribute::Returned";
+          OS << "      Attribute::get(C, Attribute::Returned),\n";
           break;
         case CodeGenIntrinsic::ReadOnly:
-          OS << LS << "Attribute::ReadOnly";
+          OS << "      Attribute::get(C, Attribute::ReadOnly),\n";
           break;
         case CodeGenIntrinsic::WriteOnly:
-          OS << LS << "Attribute::WriteOnly";
+          OS << "      Attribute::get(C, Attribute::WriteOnly),\n";
           break;
         case CodeGenIntrinsic::ReadNone:
-          OS << LS << "Attribute::ReadNone";
+          OS << "      Attribute::get(C, Attribute::ReadNone),\n";
           break;
         case CodeGenIntrinsic::ImmArg:
-          OS << LS << "Attribute::ImmArg";
+          OS << "      Attribute::get(C, Attribute::ImmArg),\n";
           break;
         case CodeGenIntrinsic::Alignment:
-          OS << LS << "Attribute::Alignment";
+          OS << "      Attribute::get(C, Attribute::Alignment, "
+             << Attr.Value << "),\n";
           break;
         }
-
-        Values.push_back(Attr.Value);
-        AllValuesAreZero &= (Attr.Value == 0);
       }
-
-      OS << "};\n";
-
-      // Generate attribute value array if not all attribute values are zero.
-      if (!AllValuesAreZero) {
-        OS << "      const uint64_t AttrValParam" << AttrIdx << "[]= {";
-        ListSeparator LSV(",");
-        for (const auto V : Values)
-          OS << LSV << V;
-        OS << "};\n";
-      }
-      // AttributeList::ReturnIndex = 0, AttrParam0 corresponds to return
-      // value.
-      OS << "      AS[" << numAttrs++ << "] = AttributeList::get(C, "
-         << AttrIdx << ", AttrParam" << AttrIdx;
-      if (!AllValuesAreZero)
-        OS << ", AttrValParam" << AttrIdx;
-      OS << ");\n";
-    }
+      OS << "    });\n";
+  OS << "  }\n";
+  OS << "}\n\n";
 
-    if (!Intrinsic.canThrow ||
-        (Intrinsic.ModRef != CodeGenIntrinsic::ReadWriteMem &&
-         !Intrinsic.hasSideEffects) ||
-        Intrinsic.isNoReturn || Intrinsic.isNoCallback || Intrinsic.isNoSync ||
-        Intrinsic.isNoFree || Intrinsic.isWillReturn || Intrinsic.isCold ||
-        Intrinsic.isNoDuplicate || Intrinsic.isNoMerge ||
-        Intrinsic.isConvergent || Intrinsic.isSpeculatable) {
-      OS << "      const Attribute::AttrKind Atts[] = {";
-      ListSeparator LS(",");
-      if (!Intrinsic.canThrow)
-        OS << LS << "Attribute::NoUnwind";
-      if (Intrinsic.isNoReturn)
-        OS << LS << "Attribute::NoReturn";
-      if (Intrinsic.isNoCallback)
-        OS << LS << "Attribute::NoCallback";
-      if (Intrinsic.isNoSync)
-        OS << LS << "Attribute::NoSync";
-      if (Intrinsic.isNoFree)
-        OS << LS << "Attribute::NoFree";
-      if (Intrinsic.isWillReturn)
-        OS << LS << "Attribute::WillReturn";
-      if (Intrinsic.isCold)
-        OS << LS << "Attribute::Cold";
-      if (Intrinsic.isNoDuplicate)
-        OS << LS << "Attribute::NoDuplicate";
-      if (Intrinsic.isNoMerge)
-        OS << LS << "Attribute::NoMerge";
-      if (Intrinsic.isConvergent)
-        OS << LS << "Attribute::Convergent";
-      if (Intrinsic.isSpeculatable)
-        OS << LS << "Attribute::Speculatable";
+  // Compute unique function attribute sets.
+  std::map<const CodeGenIntrinsic*, unsigned, FnAttributeComparator>
+      UniqFnAttributes;
+  OS << "static AttributeSet getIntrinsicFnAttributeSet("
+     << "LLVMContext &C, unsigned ID) {\n"
+     << "  switch (ID) {\n"
+     << "  default: llvm_unreachable(\"Invalid attribute set number\");\n";
+  for (const CodeGenIntrinsic &Intrinsic : Ints) {
+    unsigned ID = UniqFnAttributes.size();
+    if (!UniqFnAttributes.try_emplace(&Intrinsic, ID).second)
+      continue;
+
+    OS << "  case " << ID << ":\n"
+       << "    return AttributeSet::get(C, {\n";
+      OS << "      Attribute::get(C, Attribute::NoUnwind),\n";
+      OS << "      Attribute::get(C, Attribute::NoReturn),\n";
+      OS << "      Attribute::get(C, Attribute::NoCallback),\n";
+      OS << "      Attribute::get(C, Attribute::NoSync),\n";
+      OS << "      Attribute::get(C, Attribute::NoFree),\n";
+      OS << "      Attribute::get(C, Attribute::WillReturn),\n";
+      OS << "      Attribute::get(C, Attribute::Cold),\n";
+      OS << "      Attribute::get(C, Attribute::NoDuplicate),\n";
+      OS << "      Attribute::get(C, Attribute::NoMerge),\n";
+      OS << "      Attribute::get(C, Attribute::Convergent),\n";
+      OS << "      Attribute::get(C, Attribute::Speculatable),\n";
 
-      switch (Intrinsic.ModRef) {
-      case CodeGenIntrinsic::NoMem:
-        if (Intrinsic.hasSideEffects)
-          break;
-        OS << LS;
-        OS << "Attribute::ReadNone";
-        break;
-      case CodeGenIntrinsic::ReadArgMem:
-        OS << LS;
-        OS << "Attribute::ReadOnly,";
-        OS << "Attribute::ArgMemOnly";
-        break;
-      case CodeGenIntrinsic::ReadMem:
-        OS << LS;
-        OS << "Attribute::ReadOnly";
-        break;
-      case CodeGenIntrinsic::ReadInaccessibleMem:
-        OS << LS;
-        OS << "Attribute::ReadOnly,";
-        OS << "Attribute::InaccessibleMemOnly";
-        break;
-      case CodeGenIntrinsic::ReadInaccessibleMemOrArgMem:
-        OS << LS;
-        OS << "Attribute::ReadOnly,";
-        OS << "Attribute::InaccessibleMemOrArgMemOnly";
-        break;
-      case CodeGenIntrinsic::WriteArgMem:
-        OS << LS;
-        OS << "Attribute::WriteOnly,";
-        OS << "Attribute::ArgMemOnly";
-        break;
-      case CodeGenIntrinsic::WriteMem:
-        OS << LS;
-        OS << "Attribute::WriteOnly";
-        break;
-      case CodeGenIntrinsic::WriteInaccessibleMem:
-        OS << LS;
-        OS << "Attribute::WriteOnly,";
-        OS << "Attribute::InaccessibleMemOnly";
-        break;
-      case CodeGenIntrinsic::WriteInaccessibleMemOrArgMem:
-        OS << LS;
-        OS << "Attribute::WriteOnly,";
-        OS << "Attribute::InaccessibleMemOrArgMemOnly";
-        break;
-      case CodeGenIntrinsic::ReadWriteArgMem:
-        OS << LS;
-        OS << "Attribute::ArgMemOnly";
-        break;
-      case CodeGenIntrinsic::ReadWriteInaccessibleMem:
-        OS << LS;
-        OS << "Attribute::InaccessibleMemOnly";
-        break;
-      case CodeGenIntrinsic::ReadWriteInaccessibleMemOrArgMem:
-        OS << LS;
-        OS << "Attribute::InaccessibleMemOrArgMemOnly";
-        break;
-      case CodeGenIntrinsic::ReadWriteMem:
-        break;
-      }
-      OS << "};\n";
-      OS << "      AS[" << numAttrs++ << "] = AttributeList::get(C, "
-         << "AttributeList::FunctionIndex, Atts);\n";
+      OS << "      Attribute::get(C, Attribute::ReadNone),\n";
+      OS << "      Attribute::get(C, Attribute::ReadOnly),\n";
+      OS << "      Attribute::get(C, Attribute::ArgMemOnly),\n";
+      OS << "      Attribute::get(C, Attribute::ReadOnly),\n";
+      OS << "      Attribute::get(C, Attribute::ReadOnly),\n";
+      OS << "      Attribute::get(C, Attribute::InaccessibleMemOnly),\n";
+      OS << "      Attribute::get(C, Attribute::ReadOnly),\n";
+      OS << "      Attribute::get(C, "
+         << "Attribute::InaccessibleMemOrArgMemOnly),\n";
+      OS << "      Attribute::get(C, Attribute::WriteOnly),\n";
+      OS << "      Attribute::get(C, Attribute::ArgMemOnly),\n";
+      OS << "      Attribute::get(C, Attribute::WriteOnly),\n";
+      OS << "      Attribute::get(C, Attribute::WriteOnly),\n";
+      OS << "      Attribute::get(C, Attribute::InaccessibleMemOnly),\n";
+      OS << "      Attribute::get(C, Attribute::WriteOnly),\n";
+      OS << "      Attribute::get(C, "
+         << "Attribute::InaccessibleMemOrArgMemOnly),\n";
+      OS << "      Attribute::get(C, Attribute::ArgMemOnly),\n";
+      OS << "      Attribute::get(C, Attribute::InaccessibleMemOnly),\n";
+      OS << "      Attribute::get(C, "
+         << "Attribute::InaccessibleMemOrArgMemOnly),\n";
+    OS << "    });\n";
+  }
+  OS << "  }\n";
+  OS << "}\n\n";
+  OS << "AttributeList Intrinsic::getAttributes(LLVMContext &C, ID id) {\n";
+
+  // Compute the maximum number of attribute arguments and the map
+  typedef std::map<const CodeGenIntrinsic*, unsigned,
+                   AttributeComparator> UniqAttrMapTy;
+  UniqAttrMapTy UniqAttributes;
+  unsigned maxArgAttrs = 0;
+  unsigned AttrNum = 0;
+  for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
+    const CodeGenIntrinsic &intrinsic = Ints[i];
+    maxArgAttrs =
+      std::max(maxArgAttrs, unsigned(intrinsic.ArgumentAttributes.size()));
+    unsigned &N = UniqAttributes[&intrinsic];
+    if (N) continue;
+    N = ++AttrNum;
+    assert(N < 65536 && "Too many unique attributes for table!");
+  }
+
+  // Emit an array of AttributeList.  Most intrinsics will have at least one
+  // entry, for the function itself (index ~1), which is usually nounwind.
+  OS << "  static const uint16_t IntrinsicsToAttributesMap[] = {\n";
+
+  for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
+    const CodeGenIntrinsic &intrinsic = Ints[i];
+
+    OS << "    " << UniqAttributes[&intrinsic] << ", // "
+       << intrinsic.Name << "\n";
+  }
+  OS << "  };\n\n";
+
+  OS << "  std::pair<unsigned, AttributeSet> AS[" << maxArgAttrs + 1 << "];\n";
+  OS << "  unsigned NumAttrs = 0;\n";
+  OS << "  if (id != 0) {\n";
+  OS << "    switch(IntrinsicsToAttributesMap[id - 1]) {\n";
+  OS << "    default: llvm_unreachable(\"Invalid attribute number\");\n";
+  for (auto UniqAttribute : UniqAttributes) {
+    OS << "    case " << UniqAttribute.second << ": {\n";
+
+    const CodeGenIntrinsic &Intrinsic = *(UniqAttribute.first);
+
+    // Keep track of the number of attributes we're writing out.
+    unsigned numAttrs = 0;
+
+    for (const auto &[AttrIdx, Attrs] :
+         enumerate(Intrinsic.ArgumentAttributes)) {
+      if (Attrs.empty())
+        continue;
+
+      unsigned ID = UniqArgAttributes.find(Attrs)->second;
+      OS << "      AS[" << numAttrs++ << "] = {" << AttrIdx
+         << ", getIntrinsicArgAttributeSet(C, " << ID << ")};\n";
+    }
+
+    if (!Intrinsic.canThrow ||
+        (Intrinsic.ModRef != CodeGenIntrinsic::ReadWriteMem &&
+         !Intrinsic.hasSideEffects) ||
+        Intrinsic.isNoReturn || Intrinsic.isNoCallback || Intrinsic.isNoSync ||
+        Intrinsic.isNoFree || Intrinsic.isWillReturn || Intrinsic.isCold ||
+        Intrinsic.isNoDuplicate || Intrinsic.isNoMerge ||
+        Intrinsic.isConvergent || Intrinsic.isSpeculatable) {
+      unsigned ID = UniqFnAttributes.find(&Intrinsic)->second;
+      OS << "      AS[" << numAttrs++ << "] = {AttributeList::FunctionIndex, "
+         << "getIntrinsicFnAttributeSet(C, " << ID << ")};\n";
     }
 
     if (numAttrs) {
       OS << "      NumAttrs = " << numAttrs << ";\n";
       OS << "      break;\n";
-      OS << "      }\n";
+      OS << "    }\n";
     } else {
       OS << "      return AttributeList();\n";
-      OS << "      }\n";
+      OS << "    }\n";
     }
   }
 
   OS << "    }\n";
   OS << "  }\n";
   OS << "  return AttributeList::get(C, makeArrayRef(AS, NumAttrs));\n";
   OS << "}\n";
   OS << "#endif // GET_INTRINSIC_ATTRIBUTES\n\n";