[clang] Patch series to reapply #118734 and substantially improve it (PR #120534)
Chandler Carruth via cfe-commits
cfe-commits at lists.llvm.org
Sun Jan 5 07:26:00 PST 2025
https://github.com/chandlerc updated https://github.com/llvm/llvm-project/pull/120534
>From e40e6bd8b61b9266e2fe116b017e5141b00abb33 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Sat, 14 Dec 2024 09:09:47 +0000
Subject: [PATCH 1/9] Reapply "Switch builtin strings to use string tables"
(#118734)
This reverts commit ca79ff07d8ae7a0c2531bfdb1cb623e25e5bd486.
It also updates the original PR to use the newly added `StringTable`
abstraction for string tables, and simplifies the construction to build
the string table and info arrays separately. This should reduce any
`constexpr` compile time memory or CPU cost of the original PR while
significantly improving the APIs throughout.
---
clang/include/clang/Basic/Builtins.h | 197 ++++++++++++++++++----
clang/include/clang/Basic/BuiltinsPPC.def | 1 +
clang/include/clang/Basic/TargetInfo.h | 11 +-
clang/lib/Basic/Builtins.cpp | 117 ++++++++-----
clang/lib/Basic/Targets/AArch64.cpp | 61 ++++---
clang/lib/Basic/Targets/AArch64.h | 3 +-
clang/lib/Basic/Targets/AMDGPU.cpp | 26 ++-
clang/lib/Basic/Targets/AMDGPU.h | 3 +-
clang/lib/Basic/Targets/ARC.h | 5 +-
clang/lib/Basic/Targets/ARM.cpp | 48 +++---
clang/lib/Basic/Targets/ARM.h | 3 +-
clang/lib/Basic/Targets/AVR.h | 5 +-
clang/lib/Basic/Targets/BPF.cpp | 22 ++-
clang/lib/Basic/Targets/BPF.h | 3 +-
clang/lib/Basic/Targets/CSKY.cpp | 4 -
clang/lib/Basic/Targets/CSKY.h | 5 +-
clang/lib/Basic/Targets/DirectX.h | 5 +-
clang/lib/Basic/Targets/Hexagon.cpp | 29 ++--
clang/lib/Basic/Targets/Hexagon.h | 3 +-
clang/lib/Basic/Targets/Lanai.h | 5 +-
clang/lib/Basic/Targets/LoongArch.cpp | 26 ++-
clang/lib/Basic/Targets/LoongArch.h | 3 +-
clang/lib/Basic/Targets/M68k.cpp | 5 +-
clang/lib/Basic/Targets/M68k.h | 3 +-
clang/lib/Basic/Targets/MSP430.h | 5 +-
clang/lib/Basic/Targets/Mips.cpp | 25 ++-
clang/lib/Basic/Targets/Mips.h | 3 +-
clang/lib/Basic/Targets/NVPTX.cpp | 29 ++--
clang/lib/Basic/Targets/NVPTX.h | 3 +-
clang/lib/Basic/Targets/PNaCl.h | 5 +-
clang/lib/Basic/Targets/PPC.cpp | 29 ++--
clang/lib/Basic/Targets/PPC.h | 3 +-
clang/lib/Basic/Targets/RISCV.cpp | 35 ++--
clang/lib/Basic/Targets/RISCV.h | 3 +-
clang/lib/Basic/Targets/SPIR.cpp | 5 +-
clang/lib/Basic/Targets/SPIR.h | 8 +-
clang/lib/Basic/Targets/Sparc.h | 5 +-
clang/lib/Basic/Targets/SystemZ.cpp | 26 ++-
clang/lib/Basic/Targets/SystemZ.h | 3 +-
clang/lib/Basic/Targets/TCE.h | 5 +-
clang/lib/Basic/Targets/VE.cpp | 22 ++-
clang/lib/Basic/Targets/VE.h | 3 +-
clang/lib/Basic/Targets/WebAssembly.cpp | 29 ++--
clang/lib/Basic/Targets/WebAssembly.h | 3 +-
clang/lib/Basic/Targets/X86.cpp | 56 +++---
clang/lib/Basic/Targets/X86.h | 6 +-
clang/lib/Basic/Targets/XCore.cpp | 25 ++-
clang/lib/Basic/Targets/XCore.h | 3 +-
clang/lib/Basic/Targets/Xtensa.h | 5 +-
49 files changed, 636 insertions(+), 301 deletions(-)
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
index 63559d977ce6b6..8c6b604b0bfe0f 100644
--- a/clang/include/clang/Basic/Builtins.h
+++ b/clang/include/clang/Basic/Builtins.h
@@ -18,6 +18,7 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringTable.h"
#include <cstring>
// VC++ defines 'alloca' as an object-like macro, which interferes with our
@@ -55,6 +56,7 @@ struct HeaderDesc {
#undef HEADER
} ID;
+ constexpr HeaderDesc() : ID() {}
constexpr HeaderDesc(HeaderID ID) : ID(ID) {}
const char *getName() const;
@@ -68,14 +70,132 @@ enum ID {
FirstTSBuiltin
};
+// The info used to represent each builtin.
struct Info {
- llvm::StringLiteral Name;
- const char *Type, *Attributes;
- const char *Features;
+ // Rather than store pointers to the string literals describing these four
+ // aspects of builtins, we store offsets into a common string table.
+ struct StrOffsets {
+ llvm::StringTable::Offset Name;
+ llvm::StringTable::Offset Type;
+ llvm::StringTable::Offset Attributes;
+ llvm::StringTable::Offset Features;
+ } Offsets;
+
HeaderDesc Header;
LanguageID Langs;
};
+// A constexpr function to construct an infos array from X-macros.
+//
+// The input array uses the same data structure, but the offsets are actually
+// _lengths_ when input. This is all we can compute from the X-macro approach to
+// builtins. This function will convert these lengths into actual offsets to a
+// string table built up through sequentially appending strings with the given
+// lengths.
+template <size_t N>
+static constexpr std::array<Info, N> MakeInfos(std::array<Info, N> Infos) {
+ // Translate lengths to offsets. We start past the initial empty string at
+ // offset zero.
+ unsigned Offset = 1;
+ for (Info &I : Infos) {
+ Info::StrOffsets NewOffsets = {};
+ NewOffsets.Name = Offset;
+ Offset += I.Offsets.Name.value();
+ NewOffsets.Type = Offset;
+ Offset += I.Offsets.Type.value();
+ NewOffsets.Attributes = Offset;
+ Offset += I.Offsets.Attributes.value();
+ NewOffsets.Features = Offset;
+ Offset += I.Offsets.Features.value();
+ I.Offsets = NewOffsets;
+ }
+ return Infos;
+}
+
+// A detail macro used below to emit a string literal that, after string literal
+// concatenation, ends up triggering the `-Woverlength-strings` warning. While
+// the warning is useful in general to catch accidentally excessive strings,
+// here we are creating them intentionally.
+//
+// This relies on a subtle aspect of `_Pragma`: that the *diagnostic* ones don't
+// turn into actual tokens that would disrupt string literal concatenation.
+#ifdef __clang__
+#define CLANG_BUILTIN_DETAIL_STR_TABLE(S) \
+ _Pragma("clang diagnostic push") \
+ _Pragma("clang diagnostic ignored \"-Woverlength-strings\"") \
+ S _Pragma("clang diagnostic pop")
+#else
+#define CLANG_BUILTIN_DETAIL_STR_TABLE(S) S
+#endif
+
+// We require string tables to start with an empty string so that a `0` offset
+// can always be used to refer to an empty string. To satisfy that when building
+// string tables with X-macros, we use this start macro prior to expanding the
+// X-macros.
+#define CLANG_BUILTIN_STR_TABLE_START CLANG_BUILTIN_DETAIL_STR_TABLE("\0")
+
+// A macro that can be used with `Builtins.def` and similar files as an X-macro
+// to add the string arguments to a builtin string table. This is typically the
+// target for the `BUILTIN`, `LANGBUILTIN`, or `LIBBUILTIN` macros in those
+// files.
+#define CLANG_BUILTIN_STR_TABLE(ID, TYPE, ATTRS) \
+ CLANG_BUILTIN_DETAIL_STR_TABLE(#ID "\0" TYPE "\0" ATTRS "\0" /*FEATURE*/ "\0")
+
+// A macro that can be used with target builtin `.def` and `.inc` files as an
+// X-macro to add the string arguments to a builtin string table. this is
+// typically the target for the `TARGET_BUILTIN` macro.
+#define CLANG_TARGET_BUILTIN_STR_TABLE(ID, TYPE, ATTRS, FEATURE) \
+ CLANG_BUILTIN_DETAIL_STR_TABLE(#ID "\0" TYPE "\0" ATTRS "\0" FEATURE "\0")
+
+// A macro that can be used with target builtin `.def` and `.inc` files as an
+// X-macro to add the string arguments to a builtin string table. this is
+// typically the target for the `TARGET_HEADER_BUILTIN` macro. We can't delegate
+// to `TARGET_BUILTIN` because the `FEATURE` string changes position.
+#define CLANG_TARGET_HEADER_BUILTIN_STR_TABLE(ID, TYPE, ATTRS, HEADER, LANGS, \
+ FEATURE) \
+ CLANG_BUILTIN_DETAIL_STR_TABLE(#ID "\0" TYPE "\0" ATTRS "\0" FEATURE "\0")
+
+// A detail macro used internally to compute the desired string table
+// `StrOffsets` struct for arguments to `MakeInfos`.
+#define CLANG_BUILTIN_DETAIL_STR_OFFSETS(ID, TYPE, ATTRS) \
+ Builtin::Info::StrOffsets { \
+ sizeof(#ID), sizeof(TYPE), sizeof(ATTRS), sizeof("") \
+ }
+
+// A detail macro used internally to compute the desired string table
+// `StrOffsets` struct for arguments to `Storage::Make`.
+#define CLANG_TARGET_BUILTIN_DETAIL_STR_OFFSETS(ID, TYPE, ATTRS, FEATURE) \
+ Builtin::Info::StrOffsets { \
+ sizeof(#ID), sizeof(TYPE), sizeof(ATTRS), sizeof(FEATURE) \
+ }
+
+// A set of macros that can be used with builtin `.def' files as an X-macro to
+// create an `Info` struct for a particular builtin. It both computes the
+// `StrOffsets` value for the string table (the lengths here, translated to
+// offsets by the `MakeInfos` function), and the other metadata for each
+// builtin.
+//
+// There is a corresponding macro for each of `BUILTIN`, `LANGBUILTIN`,
+// `LIBBUILTIN`, `TARGET_BUILTIN`, and `TARGET_HEADER_BUILTIN`.
+#define CLANG_BUILTIN_ENTRY(ID, TYPE, ATTRS) \
+ Builtin::Info{CLANG_BUILTIN_DETAIL_STR_OFFSETS(ID, TYPE, ATTRS), \
+ HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+#define CLANG_LANGBUILTIN_ENTRY(ID, TYPE, ATTRS, LANG) \
+ Builtin::Info{CLANG_BUILTIN_DETAIL_STR_OFFSETS(ID, TYPE, ATTRS), \
+ HeaderDesc::NO_HEADER, LANG},
+#define CLANG_LIBBUILTIN_ENTRY(ID, TYPE, ATTRS, HEADER, LANG) \
+ Builtin::Info{CLANG_BUILTIN_DETAIL_STR_OFFSETS(ID, TYPE, ATTRS), \
+ HeaderDesc::HEADER, LANG},
+#define CLANG_TARGET_BUILTIN_ENTRY(ID, TYPE, ATTRS, FEATURE) \
+ Builtin::Info{ \
+ CLANG_TARGET_BUILTIN_DETAIL_STR_OFFSETS(ID, TYPE, ATTRS, FEATURE), \
+ HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+#define CLANG_TARGET_HEADER_BUILTIN_ENTRY(ID, TYPE, ATTRS, HEADER, LANG, \
+ FEATURE) \
+ Builtin::Info{ \
+ CLANG_TARGET_BUILTIN_DETAIL_STR_OFFSETS(ID, TYPE, ATTRS, FEATURE), \
+ HeaderDesc::HEADER, LANG},
+
/// Holds information about both target-independent and
/// target-specific builtins, allowing easy queries by clients.
///
@@ -83,8 +203,11 @@ struct Info {
/// AuxTSRecords. Their IDs are shifted up by TSRecords.size() and need to
/// be translated back with getAuxBuiltinID() before use.
class Context {
- llvm::ArrayRef<Info> TSRecords;
- llvm::ArrayRef<Info> AuxTSRecords;
+ const llvm::StringTable *TSStrTable = nullptr;
+ const llvm::StringTable *AuxTSStrTable = nullptr;
+
+ llvm::ArrayRef<Info> TSInfos;
+ llvm::ArrayRef<Info> AuxTSInfos;
public:
Context() = default;
@@ -100,13 +223,16 @@ class Context {
/// Return the identifier name for the specified builtin,
/// e.g. "__builtin_abs".
- llvm::StringRef getName(unsigned ID) const { return getRecord(ID).Name; }
+ llvm::StringRef getName(unsigned ID) const;
/// Return a quoted name for the specified builtin for use in diagnostics.
std::string getQuotedName(unsigned ID) const;
/// Get the type descriptor string for the specified builtin.
- const char *getTypeString(unsigned ID) const { return getRecord(ID).Type; }
+ const char *getTypeString(unsigned ID) const;
+
+ /// Get the attributes descriptor string for the specified builtin.
+ const char *getAttributesString(unsigned ID) const;
/// Return true if this function is a target-specific builtin.
bool isTSBuiltin(unsigned ID) const {
@@ -115,40 +241,40 @@ class Context {
/// Return true if this function has no side effects.
bool isPure(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'U') != nullptr;
+ return strchr(getAttributesString(ID), 'U') != nullptr;
}
/// Return true if this function has no side effects and doesn't
/// read memory.
bool isConst(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'c') != nullptr;
+ return strchr(getAttributesString(ID), 'c') != nullptr;
}
/// Return true if we know this builtin never throws an exception.
bool isNoThrow(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'n') != nullptr;
+ return strchr(getAttributesString(ID), 'n') != nullptr;
}
/// Return true if we know this builtin never returns.
bool isNoReturn(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'r') != nullptr;
+ return strchr(getAttributesString(ID), 'r') != nullptr;
}
/// Return true if we know this builtin can return twice.
bool isReturnsTwice(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'j') != nullptr;
+ return strchr(getAttributesString(ID), 'j') != nullptr;
}
/// Returns true if this builtin does not perform the side-effects
/// of its arguments.
bool isUnevaluated(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'u') != nullptr;
+ return strchr(getAttributesString(ID), 'u') != nullptr;
}
/// Return true if this is a builtin for a libc/libm function,
/// with a "__builtin_" prefix (e.g. __builtin_abs).
bool isLibFunction(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'F') != nullptr;
+ return strchr(getAttributesString(ID), 'F') != nullptr;
}
/// Determines whether this builtin is a predefined libc/libm
@@ -159,21 +285,21 @@ class Context {
/// they do not, but they are recognized as builtins once we see
/// a declaration.
bool isPredefinedLibFunction(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'f') != nullptr;
+ return strchr(getAttributesString(ID), 'f') != nullptr;
}
/// Returns true if this builtin requires appropriate header in other
/// compilers. In Clang it will work even without including it, but we can emit
/// a warning about missing header.
bool isHeaderDependentFunction(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'h') != nullptr;
+ return strchr(getAttributesString(ID), 'h') != nullptr;
}
/// Determines whether this builtin is a predefined compiler-rt/libgcc
/// function, such as "__clear_cache", where we know the signature a
/// priori.
bool isPredefinedRuntimeFunction(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'i') != nullptr;
+ return strchr(getAttributesString(ID), 'i') != nullptr;
}
/// Determines whether this builtin is a C++ standard library function
@@ -181,7 +307,7 @@ class Context {
/// specialization, where the signature is determined by the standard library
/// declaration.
bool isInStdNamespace(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'z') != nullptr;
+ return strchr(getAttributesString(ID), 'z') != nullptr;
}
/// Determines whether this builtin can have its address taken with no
@@ -195,33 +321,33 @@ class Context {
/// Determines whether this builtin has custom typechecking.
bool hasCustomTypechecking(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 't') != nullptr;
+ return strchr(getAttributesString(ID), 't') != nullptr;
}
/// Determines whether a declaration of this builtin should be recognized
/// even if the type doesn't match the specified signature.
bool allowTypeMismatch(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'T') != nullptr ||
+ return strchr(getAttributesString(ID), 'T') != nullptr ||
hasCustomTypechecking(ID);
}
/// Determines whether this builtin has a result or any arguments which
/// are pointer types.
bool hasPtrArgsOrResult(unsigned ID) const {
- return strchr(getRecord(ID).Type, '*') != nullptr;
+ return strchr(getTypeString(ID), '*') != nullptr;
}
/// Return true if this builtin has a result or any arguments which are
/// reference types.
bool hasReferenceArgsOrResult(unsigned ID) const {
- return strchr(getRecord(ID).Type, '&') != nullptr ||
- strchr(getRecord(ID).Type, 'A') != nullptr;
+ return strchr(getTypeString(ID), '&') != nullptr ||
+ strchr(getTypeString(ID), 'A') != nullptr;
}
/// If this is a library function that comes from a specific
/// header, retrieve that header name.
const char *getHeaderName(unsigned ID) const {
- return getRecord(ID).Header.getName();
+ return getInfo(ID).Header.getName();
}
/// Determine whether this builtin is like printf in its
@@ -246,27 +372,25 @@ class Context {
/// Such functions can be const when the MathErrno lang option and FP
/// exceptions are disabled.
bool isConstWithoutErrnoAndExceptions(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'e') != nullptr;
+ return strchr(getAttributesString(ID), 'e') != nullptr;
}
bool isConstWithoutExceptions(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'g') != nullptr;
+ return strchr(getAttributesString(ID), 'g') != nullptr;
}
- const char *getRequiredFeatures(unsigned ID) const {
- return getRecord(ID).Features;
- }
+ const char *getRequiredFeatures(unsigned ID) const;
unsigned getRequiredVectorWidth(unsigned ID) const;
/// Return true if builtin ID belongs to AuxTarget.
bool isAuxBuiltinID(unsigned ID) const {
- return ID >= (Builtin::FirstTSBuiltin + TSRecords.size());
+ return ID >= (Builtin::FirstTSBuiltin + TSInfos.size());
}
/// Return real builtin ID (i.e. ID it would have during compilation
/// for AuxTarget).
- unsigned getAuxBuiltinID(unsigned ID) const { return ID - TSRecords.size(); }
+ unsigned getAuxBuiltinID(unsigned ID) const { return ID - TSInfos.size(); }
/// Returns true if this is a libc/libm function without the '__builtin_'
/// prefix.
@@ -278,16 +402,21 @@ class Context {
/// Return true if this function can be constant evaluated by Clang frontend.
bool isConstantEvaluated(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'E') != nullptr;
+ return strchr(getAttributesString(ID), 'E') != nullptr;
}
/// Returns true if this is an immediate (consteval) function
bool isImmediate(unsigned ID) const {
- return strchr(getRecord(ID).Attributes, 'G') != nullptr;
+ return strchr(getAttributesString(ID), 'G') != nullptr;
}
private:
- const Info &getRecord(unsigned ID) const;
+ std::pair<const llvm::StringTable &, const Info &>
+ getStrTableAndInfo(unsigned ID) const;
+
+ const Info &getInfo(unsigned ID) const {
+ return getStrTableAndInfo(ID).second;
+ }
/// Helper function for isPrintfLike and isScanfLike.
bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg,
diff --git a/clang/include/clang/Basic/BuiltinsPPC.def b/clang/include/clang/Basic/BuiltinsPPC.def
index 161df386f00f03..bb7d54bbb793eb 100644
--- a/clang/include/clang/Basic/BuiltinsPPC.def
+++ b/clang/include/clang/Basic/BuiltinsPPC.def
@@ -1138,5 +1138,6 @@ UNALIASED_CUSTOM_BUILTIN(mma_pmxvbf16ger2nn, "vW512*VVi15i15i3", true,
// FIXME: Obviously incomplete.
#undef BUILTIN
+#undef TARGET_BUILTIN
#undef CUSTOM_BUILTIN
#undef UNALIASED_CUSTOM_BUILTIN
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index f2905f30a7c34b..c42bbc326bc05b 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -16,6 +16,7 @@
#include "clang/Basic/AddressSpaces.h"
#include "clang/Basic/BitmaskEnum.h"
+#include "clang/Basic/Builtins.h"
#include "clang/Basic/CFProtectionOptions.h"
#include "clang/Basic/CodeGenOptions.h"
#include "clang/Basic/LLVM.h"
@@ -32,6 +33,7 @@
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringTable.h"
#include "llvm/Frontend/OpenMP/OMPGridValues.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/Support/DataTypes.h"
@@ -1016,10 +1018,11 @@ class TargetInfo : public TransferrableTargetInfo,
virtual void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const = 0;
- /// Return information about target-specific builtins for
- /// the current primary target, and info about which builtins are non-portable
- /// across the current set of primary and secondary targets.
- virtual ArrayRef<Builtin::Info> getTargetBuiltins() const = 0;
+ /// Return information about target-specific builtins for the current primary
+ /// target, and info about which builtins are non-portable across the current
+ /// set of primary and secondary targets.
+ virtual std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const = 0;
/// Returns target-specific min and max values VScale_Range.
virtual std::optional<std::pair<unsigned, unsigned>>
diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
index 588183788de322..58fd212f9ddf17 100644
--- a/clang/lib/Basic/Builtins.cpp
+++ b/clang/lib/Basic/Builtins.cpp
@@ -29,54 +29,91 @@ const char *HeaderDesc::getName() const {
llvm_unreachable("Unknown HeaderDesc::HeaderID enum");
}
-static constexpr Builtin::Info BuiltinInfo[] = {
- {"not a builtin function", nullptr, nullptr, nullptr, HeaderDesc::NO_HEADER,
- ALL_LANGUAGES},
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LANGBUILTIN(ID, TYPE, ATTRS, LANGS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANGS},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, LANGS},
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+ // We inject a non-builtin string into the table.
+ CLANG_BUILTIN_STR_TABLE("not a builtin function", "", "")
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
#include "clang/Basic/Builtins.inc"
-};
+ ;
+
+static constexpr auto BuiltinInfos =
+ Builtin::MakeInfos<Builtin::FirstTSBuiltin>(
+ {CLANG_BUILTIN_ENTRY("not a builtin function", "", "")
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
+#include "clang/Basic/Builtins.inc"
+ });
-const Builtin::Info &Builtin::Context::getRecord(unsigned ID) const {
+std::pair<const llvm::StringTable &, const Builtin::Info &>
+Builtin::Context::getStrTableAndInfo(unsigned ID) const {
if (ID < Builtin::FirstTSBuiltin)
- return BuiltinInfo[ID];
- assert(((ID - Builtin::FirstTSBuiltin) <
- (TSRecords.size() + AuxTSRecords.size())) &&
- "Invalid builtin ID!");
+ return {BuiltinStrings, BuiltinInfos[ID]};
+ assert(
+ ((ID - Builtin::FirstTSBuiltin) < (TSInfos.size() + AuxTSInfos.size())) &&
+ "Invalid builtin ID!");
if (isAuxBuiltinID(ID))
- return AuxTSRecords[getAuxBuiltinID(ID) - Builtin::FirstTSBuiltin];
- return TSRecords[ID - Builtin::FirstTSBuiltin];
+ return {*AuxTSStrTable,
+ AuxTSInfos[getAuxBuiltinID(ID) - Builtin::FirstTSBuiltin]};
+ return {*TSStrTable, TSInfos[ID - Builtin::FirstTSBuiltin]};
+}
+
+/// Return the identifier name for the specified builtin,
+/// e.g. "__builtin_abs".
+llvm::StringRef Builtin::Context::getName(unsigned ID) const {
+ const auto &[StrTable, I] = getStrTableAndInfo(ID);
+ return StrTable[I.Offsets.Name];
+}
+
+const char *Builtin::Context::getTypeString(unsigned ID) const {
+ const auto &[StrTable, I] = getStrTableAndInfo(ID);
+ return StrTable[I.Offsets.Type].data();
+}
+
+const char *Builtin::Context::getAttributesString(unsigned ID) const {
+ const auto &[StrTable, I] = getStrTableAndInfo(ID);
+ return StrTable[I.Offsets.Attributes].data();
+}
+
+const char *Builtin::Context::getRequiredFeatures(unsigned ID) const {
+ const auto &[StrTable, I] = getStrTableAndInfo(ID);
+ return StrTable[I.Offsets.Features].data();
}
void Builtin::Context::InitializeTarget(const TargetInfo &Target,
const TargetInfo *AuxTarget) {
- assert(TSRecords.empty() && "Already initialized target?");
- TSRecords = Target.getTargetBuiltins();
- if (AuxTarget)
- AuxTSRecords = AuxTarget->getTargetBuiltins();
+ assert(TSStrTable == nullptr && "Already initialized target?");
+ assert(TSInfos.empty() && "Already initialized target?");
+ std::tie(TSStrTable, TSInfos) = Target.getTargetBuiltinStorage();
+ if (AuxTarget) {
+ std::tie(AuxTSStrTable, AuxTSInfos) = AuxTarget->getTargetBuiltinStorage();
+ }
}
bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
bool InStdNamespace = FuncName.consume_front("std-");
+ const llvm::StringTable &StrTable = BuiltinStrings;
for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin;
++i) {
- if (FuncName == BuiltinInfo[i].Name &&
- (bool)strchr(BuiltinInfo[i].Attributes, 'z') == InStdNamespace)
- return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr;
+ const auto &I = BuiltinInfos[i];
+ if (FuncName == StrTable[I.Offsets.Name] &&
+ (bool)strchr(StrTable[I.Offsets.Attributes].data(), 'z') ==
+ InStdNamespace)
+ return strchr(StrTable[I.Offsets.Attributes].data(), 'f') != nullptr;
}
return false;
}
/// Is this builtin supported according to the given language options?
-static bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
+static bool builtinIsSupported(const llvm::StringTable &StrTable,
+ const Builtin::Info &BuiltinInfo,
const LangOptions &LangOpts) {
+ auto AttributesStr = StrTable[BuiltinInfo.Offsets.Attributes];
+
/* Builtins Unsupported */
- if (LangOpts.NoBuiltin && strchr(BuiltinInfo.Attributes, 'f') != nullptr)
+ if (LangOpts.NoBuiltin && strchr(AttributesStr.data(), 'f') != nullptr)
return false;
/* CorBuiltins Unsupported */
if (!LangOpts.Coroutines && (BuiltinInfo.Langs & COR_LANG))
@@ -123,7 +160,7 @@ static bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
if (!LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG)
return false;
/* consteval Unsupported */
- if (!LangOpts.CPlusPlus20 && strchr(BuiltinInfo.Attributes, 'G') != nullptr)
+ if (!LangOpts.CPlusPlus20 && strchr(AttributesStr.data(), 'G') != nullptr)
return false;
return true;
}
@@ -134,20 +171,22 @@ static bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
const LangOptions& LangOpts) {
// Step #1: mark all target-independent builtins with their ID's.
- for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; ++i)
- if (builtinIsSupported(BuiltinInfo[i], LangOpts)) {
- Table.get(BuiltinInfo[i].Name).setBuiltinID(i);
+ for (const auto &&[Index, I] :
+ llvm::enumerate(llvm::ArrayRef(BuiltinInfos).drop_front()))
+ if (builtinIsSupported(BuiltinStrings, I, LangOpts)) {
+ Table.get(BuiltinStrings[I.Offsets.Name]).setBuiltinID(Index + 1);
}
// Step #2: Register target-specific builtins.
- for (unsigned i = 0, e = TSRecords.size(); i != e; ++i)
- if (builtinIsSupported(TSRecords[i], LangOpts))
- Table.get(TSRecords[i].Name).setBuiltinID(i + Builtin::FirstTSBuiltin);
+ for (const auto &&[Index, I] : llvm::enumerate(TSInfos))
+ if (builtinIsSupported(*TSStrTable, I, LangOpts))
+ Table.get((*TSStrTable)[I.Offsets.Name])
+ .setBuiltinID(Index + Builtin::FirstTSBuiltin);
// Step #3: Register target-specific builtins for AuxTarget.
- for (unsigned i = 0, e = AuxTSRecords.size(); i != e; ++i)
- Table.get(AuxTSRecords[i].Name)
- .setBuiltinID(i + Builtin::FirstTSBuiltin + TSRecords.size());
+ for (const auto &&[Index, I] : llvm::enumerate(AuxTSInfos))
+ Table.get((*AuxTSStrTable)[I.Offsets.Name])
+ .setBuiltinID(Index + Builtin::FirstTSBuiltin + TSInfos.size());
// Step #4: Unregister any builtins specified by -fno-builtin-foo.
for (llvm::StringRef Name : LangOpts.NoBuiltinFuncs) {
@@ -168,7 +207,7 @@ std::string Builtin::Context::getQuotedName(unsigned ID) const {
}
unsigned Builtin::Context::getRequiredVectorWidth(unsigned ID) const {
- const char *WidthPos = ::strchr(getRecord(ID).Attributes, 'V');
+ const char *WidthPos = ::strchr(getAttributesString(ID), 'V');
if (!WidthPos)
return 0;
@@ -191,7 +230,7 @@ bool Builtin::Context::isLike(unsigned ID, unsigned &FormatIdx,
assert(::toupper(Fmt[0]) == Fmt[1] &&
"Format string is not in the form \"xX\"");
- const char *Like = ::strpbrk(getRecord(ID).Attributes, Fmt);
+ const char *Like = ::strpbrk(getAttributesString(ID), Fmt);
if (!Like)
return false;
@@ -218,7 +257,7 @@ bool Builtin::Context::isScanfLike(unsigned ID, unsigned &FormatIdx,
bool Builtin::Context::performsCallback(unsigned ID,
SmallVectorImpl<int> &Encoding) const {
- const char *CalleePos = ::strchr(getRecord(ID).Attributes, 'C');
+ const char *CalleePos = ::strchr(getAttributesString(ID), 'C');
if (!CalleePos)
return false;
diff --git a/clang/lib/Basic/Targets/AArch64.cpp b/clang/lib/Basic/Targets/AArch64.cpp
index 53e102bbe44687..09754e47b08f60 100644
--- a/clang/lib/Basic/Targets/AArch64.cpp
+++ b/clang/lib/Basic/Targets/AArch64.cpp
@@ -26,35 +26,42 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#include "clang/Basic/BuiltinsNEON.def"
+static constexpr int NumBuiltins =
+ clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsNEON.def"
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsSVE.def"
-
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsSME.def"
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsAArch64.def"
+ ;
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANG},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsNEON.def"
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsSVE.def"
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsSME.def"
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsAArch64.def"
-};
+});
void AArch64TargetInfo::setArchFeatures() {
if (*ArchInfo == llvm::AArch64::ARMV8R) {
@@ -697,9 +704,9 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
-ArrayRef<Builtin::Info> AArch64TargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo, clang::AArch64::LastTSBuiltin -
- Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+AArch64TargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
std::optional<std::pair<unsigned, unsigned>>
diff --git a/clang/lib/Basic/Targets/AArch64.h b/clang/lib/Basic/Targets/AArch64.h
index 68a8b1ebad8cde..1686d7d2e8e779 100644
--- a/clang/lib/Basic/Targets/AArch64.h
+++ b/clang/lib/Basic/Targets/AArch64.h
@@ -180,7 +180,8 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
std::optional<std::pair<unsigned, unsigned>>
getVScaleRange(const LangOptions &LangOpts) const override;
diff --git a/clang/lib/Basic/Targets/AMDGPU.cpp b/clang/lib/Basic/Targets/AMDGPU.cpp
index 99f8f2944e2796..1b256aafcf9671 100644
--- a/clang/lib/Basic/Targets/AMDGPU.cpp
+++ b/clang/lib/Basic/Targets/AMDGPU.cpp
@@ -88,13 +88,21 @@ const LangASMap AMDGPUTargetInfo::AMDGPUDefIsPrivMap = {
} // namespace targets
} // namespace clang
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsAMDGPU.def"
-};
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsAMDGPU.def"
+});
const char *const AMDGPUTargetInfo::GCCRegNames[] = {
"v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8",
@@ -266,9 +274,9 @@ void AMDGPUTargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
!isAMDGCN(getTriple()));
}
-ArrayRef<Builtin::Info> AMDGPUTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+AMDGPUTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts,
diff --git a/clang/lib/Basic/Targets/AMDGPU.h b/clang/lib/Basic/Targets/AMDGPU.h
index ea4189cdea47da..aac5ae8d9482c0 100644
--- a/clang/lib/Basic/Targets/AMDGPU.h
+++ b/clang/lib/Basic/Targets/AMDGPU.h
@@ -257,7 +257,8 @@ class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
StringRef CPU,
const std::vector<std::string> &FeatureVec) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool useFP16ConversionIntrinsics() const override { return false; }
diff --git a/clang/lib/Basic/Targets/ARC.h b/clang/lib/Basic/Targets/ARC.h
index 7f3d0aa15ab81f..905fdeafec4de0 100644
--- a/clang/lib/Basic/Targets/ARC.h
+++ b/clang/lib/Basic/Targets/ARC.h
@@ -40,7 +40,10 @@ class LLVM_LIBRARY_VISIBILITY ARCTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override { return {}; }
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/ARM.cpp b/clang/lib/Basic/Targets/ARM.cpp
index 370444057b4298..03c90f745962f7 100644
--- a/clang/lib/Basic/Targets/ARM.cpp
+++ b/clang/lib/Basic/Targets/ARM.cpp
@@ -1071,31 +1071,37 @@ void ARMTargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::ARM::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsNEON.def"
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANG},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsARM.def"
-};
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsNEON.def"
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsARM.def"
+});
-ArrayRef<Builtin::Info> ARMTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::ARM::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ARMTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
bool ARMTargetInfo::isCLZForZeroUndef() const { return false; }
diff --git a/clang/lib/Basic/Targets/ARM.h b/clang/lib/Basic/Targets/ARM.h
index 55ecb99d82d8fb..60baf0f4f97122 100644
--- a/clang/lib/Basic/Targets/ARM.h
+++ b/clang/lib/Basic/Targets/ARM.h
@@ -196,7 +196,8 @@ class LLVM_LIBRARY_VISIBILITY ARMTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool isCLZForZeroUndef() const override;
BuiltinVaListKind getBuiltinVaListKind() const override;
diff --git a/clang/lib/Basic/Targets/AVR.h b/clang/lib/Basic/Targets/AVR.h
index df1f8d171efbaa..962f5add183fdb 100644
--- a/clang/lib/Basic/Targets/AVR.h
+++ b/clang/lib/Basic/Targets/AVR.h
@@ -63,7 +63,10 @@ class LLVM_LIBRARY_VISIBILITY AVRTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override { return {}; }
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
bool allowsLargerPreferedTypeAlignment() const override { return false; }
diff --git a/clang/lib/Basic/Targets/BPF.cpp b/clang/lib/Basic/Targets/BPF.cpp
index f4684765b7ffb3..c5efbda520998d 100644
--- a/clang/lib/Basic/Targets/BPF.cpp
+++ b/clang/lib/Basic/Targets/BPF.cpp
@@ -19,11 +19,19 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::BPF::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsBPF.inc"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsBPF.inc"
-};
+});
void BPFTargetInfo::getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const {
@@ -81,9 +89,9 @@ void BPFTargetInfo::fillValidCPUList(SmallVectorImpl<StringRef> &Values) const {
Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
}
-ArrayRef<Builtin::Info> BPFTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::BPF::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+BPFTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
bool BPFTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
diff --git a/clang/lib/Basic/Targets/BPF.h b/clang/lib/Basic/Targets/BPF.h
index 27a4b5f3149702..97aaf35fc523d1 100644
--- a/clang/lib/Basic/Targets/BPF.h
+++ b/clang/lib/Basic/Targets/BPF.h
@@ -58,7 +58,8 @@ class LLVM_LIBRARY_VISIBILITY BPFTargetInfo : public TargetInfo {
bool handleTargetFeatures(std::vector<std::string> &Features,
DiagnosticsEngine &Diags) override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
std::string_view getClobbers() const override { return ""; }
diff --git a/clang/lib/Basic/Targets/CSKY.cpp b/clang/lib/Basic/Targets/CSKY.cpp
index c8bf8b9234d243..e698508a2370c9 100644
--- a/clang/lib/Basic/Targets/CSKY.cpp
+++ b/clang/lib/Basic/Targets/CSKY.cpp
@@ -139,10 +139,6 @@ bool CSKYTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
return true;
}
-ArrayRef<Builtin::Info> CSKYTargetInfo::getTargetBuiltins() const {
- return ArrayRef<Builtin::Info>();
-}
-
ArrayRef<const char *> CSKYTargetInfo::getGCCRegNames() const {
static const char *const GCCRegNames[] = {
// Integer registers
diff --git a/clang/lib/Basic/Targets/CSKY.h b/clang/lib/Basic/Targets/CSKY.h
index 94d4eeb9a1fff4..7ecc9bc780412f 100644
--- a/clang/lib/Basic/Targets/CSKY.h
+++ b/clang/lib/Basic/Targets/CSKY.h
@@ -73,7 +73,10 @@ class LLVM_LIBRARY_VISIBILITY CSKYTargetInfo : public TargetInfo {
unsigned getMinGlobalAlign(uint64_t, bool HasNonWeakDef) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
BuiltinVaListKind getBuiltinVaListKind() const override {
return VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/DirectX.h b/clang/lib/Basic/Targets/DirectX.h
index ab22d1281a4df7..55ea3f877b23f6 100644
--- a/clang/lib/Basic/Targets/DirectX.h
+++ b/clang/lib/Basic/Targets/DirectX.h
@@ -72,7 +72,10 @@ class LLVM_LIBRARY_VISIBILITY DirectXTargetInfo : public TargetInfo {
return Feature == "directx";
}
- ArrayRef<Builtin::Info> getTargetBuiltins() const override { return {}; }
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
std::string_view getClobbers() const override { return ""; }
diff --git a/clang/lib/Basic/Targets/Hexagon.cpp b/clang/lib/Basic/Targets/Hexagon.cpp
index b5e06b679ece72..a852e100a57013 100644
--- a/clang/lib/Basic/Targets/Hexagon.cpp
+++ b/clang/lib/Basic/Targets/Hexagon.cpp
@@ -204,15 +204,22 @@ ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const {
return llvm::ArrayRef(GCCRegAliases);
}
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::Hexagon::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsHexagon.def"
-};
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsHexagon.def"
+});
bool HexagonTargetInfo::hasFeature(StringRef Feature) const {
std::string VS = "hvxv" + HVXVersion;
@@ -271,7 +278,7 @@ void HexagonTargetInfo::fillValidCPUList(
Values.push_back(Suffix.Name);
}
-ArrayRef<Builtin::Info> HexagonTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo, clang::Hexagon::LastTSBuiltin -
- Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+HexagonTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
diff --git a/clang/lib/Basic/Targets/Hexagon.h b/clang/lib/Basic/Targets/Hexagon.h
index 7f053ab7e48886..b93574aa599f4c 100644
--- a/clang/lib/Basic/Targets/Hexagon.h
+++ b/clang/lib/Basic/Targets/Hexagon.h
@@ -66,7 +66,8 @@ class LLVM_LIBRARY_VISIBILITY HexagonTargetInfo : public TargetInfo {
BoolWidth = BoolAlign = 8;
}
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool validateAsmConstraint(const char *&Name,
TargetInfo::ConstraintInfo &Info) const override {
diff --git a/clang/lib/Basic/Targets/Lanai.h b/clang/lib/Basic/Targets/Lanai.h
index f7e439c7c9e1cf..e715fa220df7a1 100644
--- a/clang/lib/Basic/Targets/Lanai.h
+++ b/clang/lib/Basic/Targets/Lanai.h
@@ -78,7 +78,10 @@ class LLVM_LIBRARY_VISIBILITY LanaiTargetInfo : public TargetInfo {
return TargetInfo::VoidPtrBuiltinVaList;
}
- ArrayRef<Builtin::Info> getTargetBuiltins() const override { return {}; }
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
bool validateAsmConstraint(const char *&Name,
TargetInfo::ConstraintInfo &info) const override {
diff --git a/clang/lib/Basic/Targets/LoongArch.cpp b/clang/lib/Basic/Targets/LoongArch.cpp
index d36186aa9c2fbf..7c0f40f6af3b5f 100644
--- a/clang/lib/Basic/Targets/LoongArch.cpp
+++ b/clang/lib/Basic/Targets/LoongArch.cpp
@@ -270,13 +270,21 @@ void LoongArchTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
}
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::LoongArch::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsLoongArch.def"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsLoongArch.def"
-};
+});
bool LoongArchTargetInfo::initFeatureMap(
llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
@@ -303,9 +311,9 @@ bool LoongArchTargetInfo::hasFeature(StringRef Feature) const {
.Default(false);
}
-ArrayRef<Builtin::Info> LoongArchTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo, clang::LoongArch::LastTSBuiltin -
- Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+LoongArchTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
bool LoongArchTargetInfo::handleTargetFeatures(
diff --git a/clang/lib/Basic/Targets/LoongArch.h b/clang/lib/Basic/Targets/LoongArch.h
index abaa05aa42d438..dee92403dac3a3 100644
--- a/clang/lib/Basic/Targets/LoongArch.h
+++ b/clang/lib/Basic/Targets/LoongArch.h
@@ -70,7 +70,8 @@ class LLVM_LIBRARY_VISIBILITY LoongArchTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/M68k.cpp b/clang/lib/Basic/Targets/M68k.cpp
index b5b29fd8675630..e2a382653a5c5d 100644
--- a/clang/lib/Basic/Targets/M68k.cpp
+++ b/clang/lib/Basic/Targets/M68k.cpp
@@ -115,9 +115,10 @@ void M68kTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__HAVE_68881__");
}
-ArrayRef<Builtin::Info> M68kTargetInfo::getTargetBuiltins() const {
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+M68kTargetInfo::getTargetBuiltinStorage() const {
// FIXME: Implement.
- return {};
+ return {nullptr, {}};
}
bool M68kTargetInfo::hasFeature(StringRef Feature) const {
diff --git a/clang/lib/Basic/Targets/M68k.h b/clang/lib/Basic/Targets/M68k.h
index b732add77e0340..104cdfd20c1bdc 100644
--- a/clang/lib/Basic/Targets/M68k.h
+++ b/clang/lib/Basic/Targets/M68k.h
@@ -44,7 +44,8 @@ class LLVM_LIBRARY_VISIBILITY M68kTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool hasFeature(StringRef Feature) const override;
ArrayRef<const char *> getGCCRegNames() const override;
ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
diff --git a/clang/lib/Basic/Targets/MSP430.h b/clang/lib/Basic/Targets/MSP430.h
index 2266ada25c1dd6..a998ea0143b7f0 100644
--- a/clang/lib/Basic/Targets/MSP430.h
+++ b/clang/lib/Basic/Targets/MSP430.h
@@ -50,9 +50,10 @@ class LLVM_LIBRARY_VISIBILITY MSP430TargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override {
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
// FIXME: Implement.
- return {};
+ return {nullptr, {}};
}
bool allowsLargerPreferedTypeAlignment() const override { return false; }
diff --git a/clang/lib/Basic/Targets/Mips.cpp b/clang/lib/Basic/Targets/Mips.cpp
index d56995e3ccc48e..d6910768378544 100644
--- a/clang/lib/Basic/Targets/Mips.cpp
+++ b/clang/lib/Basic/Targets/Mips.cpp
@@ -20,13 +20,20 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsMips.def"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
#include "clang/Basic/BuiltinsMips.def"
-};
+});
bool MipsTargetInfo::processorSupportsGPR64() const {
return llvm::StringSwitch<bool>(CPU)
@@ -223,9 +230,9 @@ bool MipsTargetInfo::hasFeature(StringRef Feature) const {
.Default(false);
}
-ArrayRef<Builtin::Info> MipsTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+MipsTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
unsigned MipsTargetInfo::getUnwindWordWidth() const {
diff --git a/clang/lib/Basic/Targets/Mips.h b/clang/lib/Basic/Targets/Mips.h
index 7ddcd57053cb2b..4274dcedc909c5 100644
--- a/clang/lib/Basic/Targets/Mips.h
+++ b/clang/lib/Basic/Targets/Mips.h
@@ -198,7 +198,8 @@ class LLVM_LIBRARY_VISIBILITY MipsTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool hasFeature(StringRef Feature) const override;
diff --git a/clang/lib/Basic/Targets/NVPTX.cpp b/clang/lib/Basic/Targets/NVPTX.cpp
index dbc3fec3657610..e765ff545b54e0 100644
--- a/clang/lib/Basic/Targets/NVPTX.cpp
+++ b/clang/lib/Basic/Targets/NVPTX.cpp
@@ -20,15 +20,22 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::NVPTX::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsNVPTX.def"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsNVPTX.def"
-};
+});
const char *const NVPTXTargetInfo::GCCRegNames[] = {"r0"};
@@ -295,7 +302,7 @@ void NVPTXTargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
-ArrayRef<Builtin::Info> NVPTXTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::NVPTX::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+NVPTXTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
diff --git a/clang/lib/Basic/Targets/NVPTX.h b/clang/lib/Basic/Targets/NVPTX.h
index d81b89a7f24ac0..bd029e10039e26 100644
--- a/clang/lib/Basic/Targets/NVPTX.h
+++ b/clang/lib/Basic/Targets/NVPTX.h
@@ -74,7 +74,8 @@ class LLVM_LIBRARY_VISIBILITY NVPTXTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool useFP16ConversionIntrinsics() const override { return false; }
diff --git a/clang/lib/Basic/Targets/PNaCl.h b/clang/lib/Basic/Targets/PNaCl.h
index 7e0e10aa362d87..89648f980f4eba 100644
--- a/clang/lib/Basic/Targets/PNaCl.h
+++ b/clang/lib/Basic/Targets/PNaCl.h
@@ -52,7 +52,10 @@ class LLVM_LIBRARY_VISIBILITY PNaClTargetInfo : public TargetInfo {
return Feature == "pnacl";
}
- ArrayRef<Builtin::Info> getTargetBuiltins() const override { return {}; }
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::PNaClABIBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/PPC.cpp b/clang/lib/Basic/Targets/PPC.cpp
index 1448069173b5f4..ab96983c3dc30c 100644
--- a/clang/lib/Basic/Targets/PPC.cpp
+++ b/clang/lib/Basic/Targets/PPC.cpp
@@ -19,15 +19,22 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::PPC::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsPPC.def"
-};
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
+#include "clang/Basic/BuiltinsPPC.def"
+});
/// handleTargetFeatures - Perform initialization based on the user
/// configured set of features.
@@ -927,9 +934,9 @@ void PPCTargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
MaxAtomicInlineWidth = 128;
}
-ArrayRef<Builtin::Info> PPCTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::PPC::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+PPCTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
bool PPCTargetInfo::validateCpuSupports(StringRef FeatureStr) const {
diff --git a/clang/lib/Basic/Targets/PPC.h b/clang/lib/Basic/Targets/PPC.h
index 3cd0fcad172939..76f4d152ae5919 100644
--- a/clang/lib/Basic/Targets/PPC.h
+++ b/clang/lib/Basic/Targets/PPC.h
@@ -187,7 +187,8 @@ class LLVM_LIBRARY_VISIBILITY PPCTargetInfo : public TargetInfo {
StringRef getABI() const override { return ABI; }
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool isCLZForZeroUndef() const override { return false; }
diff --git a/clang/lib/Basic/Targets/RISCV.cpp b/clang/lib/Basic/Targets/RISCV.cpp
index a541dfedc9b8e1..efa7a91ad03078 100644
--- a/clang/lib/Basic/Targets/RISCV.cpp
+++ b/clang/lib/Basic/Targets/RISCV.cpp
@@ -240,22 +240,31 @@ void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::RISCV::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsRISCVVector.def"
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsRISCV.inc"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsRISCVVector.def"
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsRISCV.inc"
-};
+});
-ArrayRef<Builtin::Info> RISCVTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::RISCV::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+RISCVTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
bool RISCVTargetInfo::initFeatureMap(
diff --git a/clang/lib/Basic/Targets/RISCV.h b/clang/lib/Basic/Targets/RISCV.h
index 68f10e74ba98c3..c3f62acff2623d 100644
--- a/clang/lib/Basic/Targets/RISCV.h
+++ b/clang/lib/Basic/Targets/RISCV.h
@@ -62,7 +62,8 @@ class RISCVTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/SPIR.cpp b/clang/lib/Basic/Targets/SPIR.cpp
index 040303983594f8..fd755ca056691b 100644
--- a/clang/lib/Basic/Targets/SPIR.cpp
+++ b/clang/lib/Basic/Targets/SPIR.cpp
@@ -81,8 +81,9 @@ SPIRV64AMDGCNTargetInfo::convertConstraint(const char *&Constraint) const {
return AMDGPUTI.convertConstraint(Constraint);
}
-ArrayRef<Builtin::Info> SPIRV64AMDGCNTargetInfo::getTargetBuiltins() const {
- return AMDGPUTI.getTargetBuiltins();
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+SPIRV64AMDGCNTargetInfo::getTargetBuiltinStorage() const {
+ return AMDGPUTI.getTargetBuiltinStorage();
}
void SPIRV64AMDGCNTargetInfo::getTargetDefines(const LangOptions &Opts,
diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index 85e4bd920d8535..b1c5c6ea063545 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -159,7 +159,10 @@ class LLVM_LIBRARY_VISIBILITY BaseSPIRTargetInfo : public TargetInfo {
// memcpy as per section 3 of the SPIR spec.
bool useFP16ConversionIntrinsics() const override { return false; }
- ArrayRef<Builtin::Info> getTargetBuiltins() const override { return {}; }
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
std::string_view getClobbers() const override { return ""; }
@@ -408,7 +411,8 @@ class LLVM_LIBRARY_VISIBILITY SPIRV64AMDGCNTargetInfo final
std::string convertConstraint(const char *&Constraint) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
diff --git a/clang/lib/Basic/Targets/Sparc.h b/clang/lib/Basic/Targets/Sparc.h
index 9c529a5bc5e7fa..9836f82a2fc54a 100644
--- a/clang/lib/Basic/Targets/Sparc.h
+++ b/clang/lib/Basic/Targets/Sparc.h
@@ -48,9 +48,10 @@ class LLVM_LIBRARY_VISIBILITY SparcTargetInfo : public TargetInfo {
bool hasFeature(StringRef Feature) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override {
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
// FIXME: Implement!
- return {};
+ return {nullptr, {}};
}
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/SystemZ.cpp b/clang/lib/Basic/Targets/SystemZ.cpp
index 06f08db2eadd47..be84329bf85d41 100644
--- a/clang/lib/Basic/Targets/SystemZ.cpp
+++ b/clang/lib/Basic/Targets/SystemZ.cpp
@@ -20,13 +20,21 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::SystemZ::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsSystemZ.def"
-};
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsSystemZ.def"
+});
const char *const SystemZTargetInfo::GCCRegNames[] = {
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
@@ -170,7 +178,7 @@ void SystemZTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__VEC__", "10304");
}
-ArrayRef<Builtin::Info> SystemZTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo, clang::SystemZ::LastTSBuiltin -
- Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+SystemZTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
diff --git a/clang/lib/Basic/Targets/SystemZ.h b/clang/lib/Basic/Targets/SystemZ.h
index e6405f174f660f..66292c206cbe41 100644
--- a/clang/lib/Basic/Targets/SystemZ.h
+++ b/clang/lib/Basic/Targets/SystemZ.h
@@ -99,7 +99,8 @@ class LLVM_LIBRARY_VISIBILITY SystemZTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
ArrayRef<const char *> getGCCRegNames() const override;
diff --git a/clang/lib/Basic/Targets/TCE.h b/clang/lib/Basic/Targets/TCE.h
index d6280b02f07b25..4f06e013d1dbd4 100644
--- a/clang/lib/Basic/Targets/TCE.h
+++ b/clang/lib/Basic/Targets/TCE.h
@@ -95,7 +95,10 @@ class LLVM_LIBRARY_VISIBILITY TCETargetInfo : public TargetInfo {
bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }
- ArrayRef<Builtin::Info> getTargetBuiltins() const override { return {}; }
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
+ }
std::string_view getClobbers() const override { return ""; }
diff --git a/clang/lib/Basic/Targets/VE.cpp b/clang/lib/Basic/Targets/VE.cpp
index 67cae8faf60522..a955767f46599a 100644
--- a/clang/lib/Basic/Targets/VE.cpp
+++ b/clang/lib/Basic/Targets/VE.cpp
@@ -18,11 +18,19 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::VE::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsVE.def"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsVE.def"
-};
+});
void VETargetInfo::getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const {
@@ -39,7 +47,7 @@ void VETargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
}
-ArrayRef<Builtin::Info> VETargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::VE::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+VETargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
diff --git a/clang/lib/Basic/Targets/VE.h b/clang/lib/Basic/Targets/VE.h
index 7e8fdf6096ef23..69621023acff00 100644
--- a/clang/lib/Basic/Targets/VE.h
+++ b/clang/lib/Basic/Targets/VE.h
@@ -55,7 +55,8 @@ class LLVM_LIBRARY_VISIBILITY VETargetInfo : public TargetInfo {
bool hasSjLjLowering() const override { return true; }
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/WebAssembly.cpp b/clang/lib/Basic/Targets/WebAssembly.cpp
index 7b0fd0c841ba23..4282b1496333ba 100644
--- a/clang/lib/Basic/Targets/WebAssembly.cpp
+++ b/clang/lib/Basic/Targets/WebAssembly.cpp
@@ -20,15 +20,22 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ clang::WebAssembly::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsWebAssembly.def"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
#include "clang/Basic/BuiltinsWebAssembly.def"
-};
+});
static constexpr llvm::StringLiteral ValidCPUNames[] = {
{"mvp"}, {"bleeding-edge"}, {"generic"}, {"lime1"}};
@@ -360,9 +367,9 @@ bool WebAssemblyTargetInfo::handleTargetFeatures(
return true;
}
-ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin -
- Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+WebAssemblyTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags,
diff --git a/clang/lib/Basic/Targets/WebAssembly.h b/clang/lib/Basic/Targets/WebAssembly.h
index 0a14da6a277b8e..a67bf5e3733088 100644
--- a/clang/lib/Basic/Targets/WebAssembly.h
+++ b/clang/lib/Basic/Targets/WebAssembly.h
@@ -120,7 +120,8 @@ class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo {
bool setCPU(const std::string &Name) final { return isValidCPUName(Name); }
- ArrayRef<Builtin::Info> getTargetBuiltins() const final;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const final;
BuiltinVaListKind getBuiltinVaListKind() const final {
return VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/X86.cpp b/clang/lib/Basic/Targets/X86.cpp
index d2d92fb864c310..4ed8bcec94a5be 100644
--- a/clang/lib/Basic/Targets/X86.cpp
+++ b/clang/lib/Basic/Targets/X86.cpp
@@ -23,23 +23,37 @@
namespace clang {
namespace targets {
-static constexpr Builtin::Info BuiltinInfoX86[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
+// The x86-32 builtins are a subset and prefix of the x86-64 builtins.
+static constexpr int NumX86Builtins =
+ X86::LastX86CommonBuiltin - Builtin::FirstTSBuiltin + 1;
+static constexpr int NumX86_64Builtins =
+ X86::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static_assert(NumX86Builtins < NumX86_64Builtins);
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsX86.inc"
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
- {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsX86_64.inc"
-};
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumX86_64Builtins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsX86.inc"
+
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsX86_64.inc"
+});
static const char *const GCCRegNames[] = {
"ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
@@ -1856,12 +1870,14 @@ ArrayRef<TargetInfo::AddlRegName> X86TargetInfo::getGCCAddlRegNames() const {
return llvm::ArrayRef(AddlRegNames);
}
-ArrayRef<Builtin::Info> X86_32TargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfoX86, clang::X86::LastX86CommonBuiltin -
- Builtin::FirstTSBuiltin + 1);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+X86_32TargetInfo::getTargetBuiltinStorage() const {
+ // Only use the relevant prefix of the infos, the string table base is common.
+ return {&BuiltinStrings,
+ llvm::ArrayRef(BuiltinInfos).take_front(NumX86Builtins)};
}
-ArrayRef<Builtin::Info> X86_64TargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfoX86,
- X86::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+X86_64TargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
diff --git a/clang/lib/Basic/Targets/X86.h b/clang/lib/Basic/Targets/X86.h
index 553c452d4ba3c2..d29f9298a285bb 100644
--- a/clang/lib/Basic/Targets/X86.h
+++ b/clang/lib/Basic/Targets/X86.h
@@ -508,7 +508,8 @@ class LLVM_LIBRARY_VISIBILITY X86_32TargetInfo : public X86TargetInfo {
MaxAtomicInlineWidth = 64;
}
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool hasBitIntType() const override { return true; }
size_t getMaxBitIntWidth() const override {
@@ -812,7 +813,8 @@ class LLVM_LIBRARY_VISIBILITY X86_64TargetInfo : public X86TargetInfo {
MaxAtomicInlineWidth = 128;
}
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
bool hasBitIntType() const override { return true; }
size_t getMaxBitIntWidth() const override {
diff --git a/clang/lib/Basic/Targets/XCore.cpp b/clang/lib/Basic/Targets/XCore.cpp
index fd377bbfb90e16..334e853a48a12a 100644
--- a/clang/lib/Basic/Targets/XCore.cpp
+++ b/clang/lib/Basic/Targets/XCore.cpp
@@ -18,13 +18,20 @@
using namespace clang;
using namespace clang::targets;
-static constexpr Builtin::Info BuiltinInfo[] = {
-#define BUILTIN(ID, TYPE, ATTRS) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
-#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
- {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
+static constexpr int NumBuiltins =
+ XCore::LastTSBuiltin - Builtin::FirstTSBuiltin;
+
+static constexpr llvm::StringTable BuiltinStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsXCore.def"
+ ;
+
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+#define BUILTIN CLANG_BUILTIN_ENTRY
+#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
#include "clang/Basic/BuiltinsXCore.def"
-};
+});
void XCoreTargetInfo::getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const {
@@ -32,7 +39,7 @@ void XCoreTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__XS1B__");
}
-ArrayRef<Builtin::Info> XCoreTargetInfo::getTargetBuiltins() const {
- return llvm::ArrayRef(BuiltinInfo,
- clang::XCore::LastTSBuiltin - Builtin::FirstTSBuiltin);
+std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+XCoreTargetInfo::getTargetBuiltinStorage() const {
+ return {&BuiltinStrings, BuiltinInfos};
}
diff --git a/clang/lib/Basic/Targets/XCore.h b/clang/lib/Basic/Targets/XCore.h
index 84fd59d1a71e49..3f31095fcef297 100644
--- a/clang/lib/Basic/Targets/XCore.h
+++ b/clang/lib/Basic/Targets/XCore.h
@@ -43,7 +43,8 @@ class LLVM_LIBRARY_VISIBILITY XCoreTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/Xtensa.h b/clang/lib/Basic/Targets/Xtensa.h
index a440ba8aa3c6d6..e262c392ddbf39 100644
--- a/clang/lib/Basic/Targets/Xtensa.h
+++ b/clang/lib/Basic/Targets/Xtensa.h
@@ -56,8 +56,9 @@ class LLVM_LIBRARY_VISIBILITY XtensaTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- ArrayRef<Builtin::Info> getTargetBuiltins() const override {
- return std::nullopt;
+ std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
+ getTargetBuiltinStorage() const override {
+ return {nullptr, {}};
}
BuiltinVaListKind getBuiltinVaListKind() const override {
>From b875cee78b17a9a257d444eb2b3ca6aa56220633 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Sun, 15 Dec 2024 08:15:18 +0000
Subject: [PATCH 2/9] Restructure builtin structures to support sharding
Once using a string table model for builtin strings, these string tables
become extremely large. However, there are often pre-existing reasonable
sharding structures to builtins that will let us divide them up and
expose more efficient ways of representing
a fundamentally sharded structure to their builtins.
This PR establishes a sharded structure in the API design and ensures it
is effective by using it rather than merging tables in AArch64,
LoongArch, RISCV, and X86. This can help reduce the scaling challenges
of the large tables used across various targets including these.
However, just this PR in isolation doesn't help the scaling as much as
it might seem. The largest parts of the largest targets are currently
single shards here.
The other big benefit is that by switching to a sharded architecture, we
can start to introduce different construction or even representations
for the shards. All the different sources and structures driving
builtins make it hard to specialize any of them in a way that improves
scaling, but with a sharded model that should become much more
attainable.
---
clang/include/clang/Basic/Builtins.h | 50 ++++---
.../include/clang/Basic/BuiltinsLoongArch.def | 28 ----
clang/include/clang/Basic/TargetBuiltins.h | 12 +-
clang/include/clang/Basic/TargetInfo.h | 3 +-
clang/include/module.modulemap | 1 -
clang/lib/Basic/Builtins.cpp | 132 +++++++++++-------
clang/lib/Basic/Targets/AArch64.cpp | 44 +++++-
clang/lib/Basic/Targets/AArch64.h | 3 +-
clang/lib/Basic/Targets/AMDGPU.cpp | 6 +-
clang/lib/Basic/Targets/AMDGPU.h | 3 +-
clang/lib/Basic/Targets/ARC.h | 5 +-
clang/lib/Basic/Targets/ARM.cpp | 6 +-
clang/lib/Basic/Targets/ARM.h | 3 +-
clang/lib/Basic/Targets/AVR.h | 5 +-
clang/lib/Basic/Targets/BPF.cpp | 6 +-
clang/lib/Basic/Targets/BPF.h | 3 +-
clang/lib/Basic/Targets/CSKY.h | 5 +-
clang/lib/Basic/Targets/DirectX.h | 5 +-
clang/lib/Basic/Targets/Hexagon.cpp | 6 +-
clang/lib/Basic/Targets/Hexagon.h | 3 +-
clang/lib/Basic/Targets/Lanai.h | 5 +-
clang/lib/Basic/Targets/LoongArch.cpp | 58 ++++++--
clang/lib/Basic/Targets/LoongArch.h | 3 +-
clang/lib/Basic/Targets/M68k.cpp | 6 +-
clang/lib/Basic/Targets/M68k.h | 3 +-
clang/lib/Basic/Targets/MSP430.h | 5 +-
clang/lib/Basic/Targets/Mips.cpp | 6 +-
clang/lib/Basic/Targets/Mips.h | 3 +-
clang/lib/Basic/Targets/NVPTX.cpp | 6 +-
clang/lib/Basic/Targets/NVPTX.h | 3 +-
clang/lib/Basic/Targets/PNaCl.h | 5 +-
clang/lib/Basic/Targets/PPC.cpp | 6 +-
clang/lib/Basic/Targets/PPC.h | 3 +-
clang/lib/Basic/Targets/RISCV.cpp | 23 ++-
clang/lib/Basic/Targets/RISCV.h | 3 +-
clang/lib/Basic/Targets/SPIR.cpp | 6 +-
clang/lib/Basic/Targets/SPIR.h | 8 +-
clang/lib/Basic/Targets/Sparc.h | 5 +-
clang/lib/Basic/Targets/SystemZ.cpp | 6 +-
clang/lib/Basic/Targets/SystemZ.h | 3 +-
clang/lib/Basic/Targets/TCE.h | 5 +-
clang/lib/Basic/Targets/VE.cpp | 5 +-
clang/lib/Basic/Targets/VE.h | 3 +-
clang/lib/Basic/Targets/WebAssembly.cpp | 6 +-
clang/lib/Basic/Targets/WebAssembly.h | 3 +-
clang/lib/Basic/Targets/X86.cpp | 34 +++--
clang/lib/Basic/Targets/X86.h | 6 +-
clang/lib/Basic/Targets/XCore.cpp | 6 +-
clang/lib/Basic/Targets/XCore.h | 3 +-
clang/lib/Basic/Targets/Xtensa.h | 5 +-
50 files changed, 324 insertions(+), 247 deletions(-)
delete mode 100644 clang/include/clang/Basic/BuiltinsLoongArch.def
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
index 8c6b604b0bfe0f..a03442e8e29194 100644
--- a/clang/include/clang/Basic/Builtins.h
+++ b/clang/include/clang/Basic/Builtins.h
@@ -70,7 +70,7 @@ enum ID {
FirstTSBuiltin
};
-// The info used to represent each builtin.
+/// The info used to represent each builtin.
struct Info {
// Rather than store pointers to the string literals describing these four
// aspects of builtins, we store offsets into a common string table.
@@ -85,13 +85,13 @@ struct Info {
LanguageID Langs;
};
-// A constexpr function to construct an infos array from X-macros.
-//
-// The input array uses the same data structure, but the offsets are actually
-// _lengths_ when input. This is all we can compute from the X-macro approach to
-// builtins. This function will convert these lengths into actual offsets to a
-// string table built up through sequentially appending strings with the given
-// lengths.
+/// A constexpr function to construct an infos array from X-macros.
+///
+/// The input array uses the same data structure, but the offsets are actually
+/// _lengths_ when input. This is all we can compute from the X-macro approach
+/// to builtins. This function will convert these lengths into actual offsets to
+/// a string table built up through sequentially appending strings with the
+/// given lengths.
template <size_t N>
static constexpr std::array<Info, N> MakeInfos(std::array<Info, N> Infos) {
// Translate lengths to offsets. We start past the initial empty string at
@@ -112,6 +112,16 @@ static constexpr std::array<Info, N> MakeInfos(std::array<Info, N> Infos) {
return Infos;
}
+/// A shard of a target's builtins string table and info.
+///
+/// Target builtins are sharded across multiple tables due to different
+/// structures, origins, and also to improve the overall scaling by avoiding a
+/// single table across all builtins.
+struct InfosShard {
+ const llvm::StringTable *Strings;
+ llvm::ArrayRef<Info> Infos;
+};
+
// A detail macro used below to emit a string literal that, after string literal
// concatenation, ends up triggering the `-Woverlength-strings` warning. While
// the warning is useful in general to catch accidentally excessive strings,
@@ -203,14 +213,16 @@ static constexpr std::array<Info, N> MakeInfos(std::array<Info, N> Infos) {
/// AuxTSRecords. Their IDs are shifted up by TSRecords.size() and need to
/// be translated back with getAuxBuiltinID() before use.
class Context {
- const llvm::StringTable *TSStrTable = nullptr;
- const llvm::StringTable *AuxTSStrTable = nullptr;
+ llvm::SmallVector<InfosShard> BuiltinShards;
+
+ llvm::SmallVector<InfosShard> TargetShards;
+ llvm::SmallVector<InfosShard> AuxTargetShards;
- llvm::ArrayRef<Info> TSInfos;
- llvm::ArrayRef<Info> AuxTSInfos;
+ unsigned NumTargetBuiltins = 0;
+ unsigned NumAuxTargetBuiltins = 0;
public:
- Context() = default;
+ Context();
/// Perform target-specific initialization
/// \param AuxTarget Target info to incorporate builtins from. May be nullptr.
@@ -385,12 +397,12 @@ class Context {
/// Return true if builtin ID belongs to AuxTarget.
bool isAuxBuiltinID(unsigned ID) const {
- return ID >= (Builtin::FirstTSBuiltin + TSInfos.size());
+ return ID >= (Builtin::FirstTSBuiltin + NumTargetBuiltins);
}
/// Return real builtin ID (i.e. ID it would have during compilation
/// for AuxTarget).
- unsigned getAuxBuiltinID(unsigned ID) const { return ID - TSInfos.size(); }
+ unsigned getAuxBuiltinID(unsigned ID) const { return ID - NumTargetBuiltins; }
/// Returns true if this is a libc/libm function without the '__builtin_'
/// prefix.
@@ -411,12 +423,10 @@ class Context {
}
private:
- std::pair<const llvm::StringTable &, const Info &>
- getStrTableAndInfo(unsigned ID) const;
+ std::pair<const InfosShard &, const Info &>
+ getShardAndInfo(unsigned ID) const;
- const Info &getInfo(unsigned ID) const {
- return getStrTableAndInfo(ID).second;
- }
+ const Info &getInfo(unsigned ID) const { return getShardAndInfo(ID).second; }
/// Helper function for isPrintfLike and isScanfLike.
bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg,
diff --git a/clang/include/clang/Basic/BuiltinsLoongArch.def b/clang/include/clang/Basic/BuiltinsLoongArch.def
deleted file mode 100644
index 95359a3fdc711d..00000000000000
--- a/clang/include/clang/Basic/BuiltinsLoongArch.def
+++ /dev/null
@@ -1,28 +0,0 @@
-//==- BuiltinsLoongArch.def - LoongArch Builtin function database -- C++ -*-==//
-//
-// 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 file defines the LoongArch-specific builtin function database. Users of
-// this file must define the BUILTIN macro to make use of this information.
-//
-//===----------------------------------------------------------------------===//
-
-#if defined(BUILTIN) && !defined(TARGET_BUILTIN)
-# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-// Definition of LoongArch basic builtins.
-#include "clang/Basic/BuiltinsLoongArchBase.def"
-
-// Definition of LSX builtins.
-#include "clang/Basic/BuiltinsLoongArchLSX.def"
-
-// Definition of LASX builtins.
-#include "clang/Basic/BuiltinsLoongArchLASX.def"
-
-#undef BUILTIN
-#undef TARGET_BUILTIN
diff --git a/clang/include/clang/Basic/TargetBuiltins.h b/clang/include/clang/Basic/TargetBuiltins.h
index 914be3691ee812..f34e4241b26842 100644
--- a/clang/include/clang/Basic/TargetBuiltins.h
+++ b/clang/include/clang/Basic/TargetBuiltins.h
@@ -168,8 +168,16 @@ namespace clang {
namespace LoongArch {
enum {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
-#include "clang/Basic/BuiltinsLoongArch.def"
+#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
+#include "clang/Basic/BuiltinsLoongArchBase.def"
+ FirstLSXBuiltin,
+ LastBaseBuiltin = FirstLSXBuiltin - 1,
+#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
+#include "clang/Basic/BuiltinsLoongArchLSX.def"
+ FirstLASXBuiltin,
+ LastLSXBuiltin = FirstLASXBuiltin - 1,
+#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
+#include "clang/Basic/BuiltinsLoongArchLASX.def"
LastTSBuiltin
};
} // namespace LoongArch
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index c42bbc326bc05b..466f6622029b8c 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -1021,8 +1021,7 @@ class TargetInfo : public TransferrableTargetInfo,
/// Return information about target-specific builtins for the current primary
/// target, and info about which builtins are non-portable across the current
/// set of primary and secondary targets.
- virtual std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const = 0;
+ virtual llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const = 0;
/// Returns target-specific min and max values VScale_Range.
virtual std::optional<std::pair<unsigned, unsigned>>
diff --git a/clang/include/module.modulemap b/clang/include/module.modulemap
index 5bb9f6b7a91f67..34b97c220e7f6b 100644
--- a/clang/include/module.modulemap
+++ b/clang/include/module.modulemap
@@ -47,7 +47,6 @@ module Clang_Basic {
textual header "clang/Basic/BuiltinsHexagon.def"
textual header "clang/Basic/BuiltinsHexagonDep.def"
textual header "clang/Basic/BuiltinsHexagonMapCustomDep.def"
- textual header "clang/Basic/BuiltinsLoongArch.def"
textual header "clang/Basic/BuiltinsLoongArchBase.def"
textual header "clang/Basic/BuiltinsLoongArchLASX.def"
textual header "clang/Basic/BuiltinsLoongArchLSX.def"
diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
index 58fd212f9ddf17..52375a3663f39e 100644
--- a/clang/lib/Basic/Builtins.cpp
+++ b/clang/lib/Basic/Builtins.cpp
@@ -36,6 +36,7 @@ static constexpr llvm::StringTable BuiltinStrings =
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#include "clang/Basic/Builtins.inc"
;
+static_assert(BuiltinStrings.size() < 100'000);
static constexpr auto BuiltinInfos =
Builtin::MakeInfos<Builtin::FirstTSBuiltin>(
@@ -46,71 +47,90 @@ static constexpr auto BuiltinInfos =
#include "clang/Basic/Builtins.inc"
});
-std::pair<const llvm::StringTable &, const Builtin::Info &>
-Builtin::Context::getStrTableAndInfo(unsigned ID) const {
- if (ID < Builtin::FirstTSBuiltin)
- return {BuiltinStrings, BuiltinInfos[ID]};
- assert(
- ((ID - Builtin::FirstTSBuiltin) < (TSInfos.size() + AuxTSInfos.size())) &&
- "Invalid builtin ID!");
- if (isAuxBuiltinID(ID))
- return {*AuxTSStrTable,
- AuxTSInfos[getAuxBuiltinID(ID) - Builtin::FirstTSBuiltin]};
- return {*TSStrTable, TSInfos[ID - Builtin::FirstTSBuiltin]};
+std::pair<const Builtin::InfosShard &, const Builtin::Info &>
+Builtin::Context::getShardAndInfo(unsigned ID) const {
+ assert((ID < (Builtin::FirstTSBuiltin + NumTargetBuiltins +
+ NumAuxTargetBuiltins)) &&
+ "Invalid builtin ID!");
+
+ ArrayRef<InfosShard> Shards = BuiltinShards;
+ if (isAuxBuiltinID(ID)) {
+ Shards = AuxTargetShards;
+ ID = getAuxBuiltinID(ID) - Builtin::FirstTSBuiltin;
+ } else if (ID >= Builtin::FirstTSBuiltin) {
+ Shards = TargetShards;
+ ID -= Builtin::FirstTSBuiltin;
+ }
+
+ // Loop over the shards to find the one matching this ID. We don't expect to
+ // have many shards and so its better to search linearly than with a binary
+ // search.
+ for (const auto &Shard : Shards) {
+ if (ID < Shard.Infos.size()) {
+ return {Shard, Shard.Infos[ID]};
+ }
+
+ ID -= Shard.Infos.size();
+ }
+ llvm_unreachable("Invalid target builtin shard structure!");
}
/// Return the identifier name for the specified builtin,
/// e.g. "__builtin_abs".
llvm::StringRef Builtin::Context::getName(unsigned ID) const {
- const auto &[StrTable, I] = getStrTableAndInfo(ID);
- return StrTable[I.Offsets.Name];
+ const auto &[Shard, I] = getShardAndInfo(ID);
+ return (*Shard.Strings)[I.Offsets.Name];
}
const char *Builtin::Context::getTypeString(unsigned ID) const {
- const auto &[StrTable, I] = getStrTableAndInfo(ID);
- return StrTable[I.Offsets.Type].data();
+ const auto &[Shard, I] = getShardAndInfo(ID);
+ return (*Shard.Strings)[I.Offsets.Type].data();
}
const char *Builtin::Context::getAttributesString(unsigned ID) const {
- const auto &[StrTable, I] = getStrTableAndInfo(ID);
- return StrTable[I.Offsets.Attributes].data();
+ const auto &[Shard, I] = getShardAndInfo(ID);
+ return (*Shard.Strings)[I.Offsets.Attributes].data();
}
const char *Builtin::Context::getRequiredFeatures(unsigned ID) const {
- const auto &[StrTable, I] = getStrTableAndInfo(ID);
- return StrTable[I.Offsets.Features].data();
+ const auto &[Shard, I] = getShardAndInfo(ID);
+ return (*Shard.Strings)[I.Offsets.Features].data();
}
+Builtin::Context::Context() : BuiltinShards{{&BuiltinStrings, BuiltinInfos}} {}
+
void Builtin::Context::InitializeTarget(const TargetInfo &Target,
const TargetInfo *AuxTarget) {
- assert(TSStrTable == nullptr && "Already initialized target?");
- assert(TSInfos.empty() && "Already initialized target?");
- std::tie(TSStrTable, TSInfos) = Target.getTargetBuiltinStorage();
+ assert(TargetShards.empty() && "Already initialized target?");
+ assert(NumTargetBuiltins == 0 && "Already initialized target?");
+ TargetShards = Target.getTargetBuiltins();
+ for (const auto &Shard : TargetShards)
+ NumTargetBuiltins += Shard.Infos.size();
if (AuxTarget) {
- std::tie(AuxTSStrTable, AuxTSInfos) = AuxTarget->getTargetBuiltinStorage();
+ AuxTargetShards = AuxTarget->getTargetBuiltins();
+ for (const auto &Shard : AuxTargetShards)
+ NumAuxTargetBuiltins += Shard.Infos.size();
}
}
bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
bool InStdNamespace = FuncName.consume_front("std-");
- const llvm::StringTable &StrTable = BuiltinStrings;
- for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin;
- ++i) {
- const auto &I = BuiltinInfos[i];
- if (FuncName == StrTable[I.Offsets.Name] &&
- (bool)strchr(StrTable[I.Offsets.Attributes].data(), 'z') ==
- InStdNamespace)
- return strchr(StrTable[I.Offsets.Attributes].data(), 'f') != nullptr;
- }
+ for (const auto &Shard : {InfosShard{&BuiltinStrings, BuiltinInfos}})
+ for (const auto &I : Shard.Infos)
+ if (FuncName == (*Shard.Strings)[I.Offsets.Name] &&
+ (bool)strchr((*Shard.Strings)[I.Offsets.Attributes].data(), 'z') ==
+ InStdNamespace)
+ return strchr((*Shard.Strings)[I.Offsets.Attributes].data(), 'f') !=
+ nullptr;
return false;
}
/// Is this builtin supported according to the given language options?
-static bool builtinIsSupported(const llvm::StringTable &StrTable,
+static bool builtinIsSupported(const llvm::StringTable &Strings,
const Builtin::Info &BuiltinInfo,
const LangOptions &LangOpts) {
- auto AttributesStr = StrTable[BuiltinInfo.Offsets.Attributes];
+ auto AttributesStr = Strings[BuiltinInfo.Offsets.Attributes];
/* Builtins Unsupported */
if (LangOpts.NoBuiltin && strchr(AttributesStr.data(), 'f') != nullptr)
@@ -169,24 +189,34 @@ static bool builtinIsSupported(const llvm::StringTable &StrTable,
/// appropriate builtin ID # and mark any non-portable builtin identifiers as
/// such.
void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
- const LangOptions& LangOpts) {
- // Step #1: mark all target-independent builtins with their ID's.
- for (const auto &&[Index, I] :
- llvm::enumerate(llvm::ArrayRef(BuiltinInfos).drop_front()))
- if (builtinIsSupported(BuiltinStrings, I, LangOpts)) {
- Table.get(BuiltinStrings[I.Offsets.Name]).setBuiltinID(Index + 1);
- }
-
- // Step #2: Register target-specific builtins.
- for (const auto &&[Index, I] : llvm::enumerate(TSInfos))
- if (builtinIsSupported(*TSStrTable, I, LangOpts))
- Table.get((*TSStrTable)[I.Offsets.Name])
- .setBuiltinID(Index + Builtin::FirstTSBuiltin);
+ const LangOptions &LangOpts) {
+ {
+ unsigned ID = 0;
+ // Step #1: mark all target-independent builtins with their ID's.
+ for (const auto &Shard : BuiltinShards)
+ for (const auto &I : Shard.Infos) {
+ // If this is a real builtin (ID != 0) and is supported, add it.
+ if (ID != 0 && builtinIsSupported(*Shard.Strings, I, LangOpts))
+ Table.get((*Shard.Strings)[I.Offsets.Name]).setBuiltinID(ID);
+ ++ID;
+ }
+ assert(ID == FirstTSBuiltin && "Should have added all non-target IDs!");
+
+ // Step #2: Register target-specific builtins.
+ for (const auto &Shard : TargetShards)
+ for (const auto &I : Shard.Infos) {
+ if (builtinIsSupported(*Shard.Strings, I, LangOpts))
+ Table.get((*Shard.Strings)[I.Offsets.Name]).setBuiltinID(ID);
+ ++ID;
+ }
- // Step #3: Register target-specific builtins for AuxTarget.
- for (const auto &&[Index, I] : llvm::enumerate(AuxTSInfos))
- Table.get((*AuxTSStrTable)[I.Offsets.Name])
- .setBuiltinID(Index + Builtin::FirstTSBuiltin + TSInfos.size());
+ // Step #3: Register target-specific builtins for AuxTarget.
+ for (const auto &Shard : AuxTargetShards)
+ for (const auto &I : Shard.Infos) {
+ Table.get((*Shard.Strings)[I.Offsets.Name]).setBuiltinID(ID);
+ ++ID;
+ }
+ }
// Step #4: Unregister any builtins specified by -fno-builtin-foo.
for (llvm::StringRef Name : LangOpts.NoBuiltinFuncs) {
diff --git a/clang/lib/Basic/Targets/AArch64.cpp b/clang/lib/Basic/Targets/AArch64.cpp
index 09754e47b08f60..04697deb50be79 100644
--- a/clang/lib/Basic/Targets/AArch64.cpp
+++ b/clang/lib/Basic/Targets/AArch64.cpp
@@ -26,42 +26,67 @@
using namespace clang;
using namespace clang::targets;
+static constexpr int NumNEONBuiltins =
+ NEON::FirstTSBuiltin - Builtin::FirstTSBuiltin;
+static constexpr int NumSVEBuiltins =
+ SVE::FirstTSBuiltin - NEON::FirstTSBuiltin;
+static constexpr int NumSMEBuiltins = SME::FirstTSBuiltin - SVE::FirstTSBuiltin;
+static constexpr int NumAArch64Builtins =
+ AArch64::LastTSBuiltin - SME::FirstTSBuiltin;
static constexpr int NumBuiltins =
- clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
+ AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static_assert(NumBuiltins == (NumNEONBuiltins + NumSVEBuiltins +
+ NumSMEBuiltins + NumAArch64Builtins));
-static constexpr llvm::StringTable BuiltinStrings =
+static constexpr llvm::StringTable BuiltinNEONStrings =
CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsNEON.def"
+ ;
+static constexpr llvm::StringTable BuiltinSVEStrings =
+ CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsSVE.def"
+ ;
+static constexpr llvm::StringTable BuiltinSMEStrings =
+ CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsSME.def"
+ ;
+static constexpr llvm::StringTable BuiltinAArch64Strings =
+ CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsAArch64.def"
;
-static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+static constexpr auto BuiltinNEONInfos = Builtin::MakeInfos<NumNEONBuiltins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsNEON.def"
+});
+static constexpr auto BuiltinSVEInfos = Builtin::MakeInfos<NumSVEBuiltins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsSVE.def"
+});
+static constexpr auto BuiltinSMEInfos = Builtin::MakeInfos<NumSMEBuiltins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsSME.def"
+});
+static constexpr auto BuiltinAArch64Infos =
+ Builtin::MakeInfos<NumAArch64Builtins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY
#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsAArch64.def"
-});
+ });
void AArch64TargetInfo::setArchFeatures() {
if (*ArchInfo == llvm::AArch64::ARMV8R) {
@@ -704,9 +729,14 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-AArch64TargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+AArch64TargetInfo::getTargetBuiltins() const {
+ return {
+ {&BuiltinNEONStrings, BuiltinNEONInfos},
+ {&BuiltinSVEStrings, BuiltinSVEInfos},
+ {&BuiltinSMEStrings, BuiltinSMEInfos},
+ {&BuiltinAArch64Strings, BuiltinAArch64Infos},
+ };
}
std::optional<std::pair<unsigned, unsigned>>
diff --git a/clang/lib/Basic/Targets/AArch64.h b/clang/lib/Basic/Targets/AArch64.h
index 1686d7d2e8e779..b70f080041f741 100644
--- a/clang/lib/Basic/Targets/AArch64.h
+++ b/clang/lib/Basic/Targets/AArch64.h
@@ -180,8 +180,7 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
std::optional<std::pair<unsigned, unsigned>>
getVScaleRange(const LangOptions &LangOpts) const override;
diff --git a/clang/lib/Basic/Targets/AMDGPU.cpp b/clang/lib/Basic/Targets/AMDGPU.cpp
index 1b256aafcf9671..ecfc4e8b35e7c5 100644
--- a/clang/lib/Basic/Targets/AMDGPU.cpp
+++ b/clang/lib/Basic/Targets/AMDGPU.cpp
@@ -274,9 +274,9 @@ void AMDGPUTargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
!isAMDGCN(getTriple()));
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-AMDGPUTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+AMDGPUTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts,
diff --git a/clang/lib/Basic/Targets/AMDGPU.h b/clang/lib/Basic/Targets/AMDGPU.h
index aac5ae8d9482c0..3d6778fb5a76fb 100644
--- a/clang/lib/Basic/Targets/AMDGPU.h
+++ b/clang/lib/Basic/Targets/AMDGPU.h
@@ -257,8 +257,7 @@ class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
StringRef CPU,
const std::vector<std::string> &FeatureVec) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool useFP16ConversionIntrinsics() const override { return false; }
diff --git a/clang/lib/Basic/Targets/ARC.h b/clang/lib/Basic/Targets/ARC.h
index 905fdeafec4de0..2b69f95591fa10 100644
--- a/clang/lib/Basic/Targets/ARC.h
+++ b/clang/lib/Basic/Targets/ARC.h
@@ -40,9 +40,8 @@ class LLVM_LIBRARY_VISIBILITY ARCTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
BuiltinVaListKind getBuiltinVaListKind() const override {
diff --git a/clang/lib/Basic/Targets/ARM.cpp b/clang/lib/Basic/Targets/ARM.cpp
index 03c90f745962f7..d111443d04409a 100644
--- a/clang/lib/Basic/Targets/ARM.cpp
+++ b/clang/lib/Basic/Targets/ARM.cpp
@@ -1099,9 +1099,9 @@ static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
#include "clang/Basic/BuiltinsARM.def"
});
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-ARMTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+ARMTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
bool ARMTargetInfo::isCLZForZeroUndef() const { return false; }
diff --git a/clang/lib/Basic/Targets/ARM.h b/clang/lib/Basic/Targets/ARM.h
index 60baf0f4f97122..2c5577c123b309 100644
--- a/clang/lib/Basic/Targets/ARM.h
+++ b/clang/lib/Basic/Targets/ARM.h
@@ -196,8 +196,7 @@ class LLVM_LIBRARY_VISIBILITY ARMTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool isCLZForZeroUndef() const override;
BuiltinVaListKind getBuiltinVaListKind() const override;
diff --git a/clang/lib/Basic/Targets/AVR.h b/clang/lib/Basic/Targets/AVR.h
index 962f5add183fdb..2117ab58e6f303 100644
--- a/clang/lib/Basic/Targets/AVR.h
+++ b/clang/lib/Basic/Targets/AVR.h
@@ -63,9 +63,8 @@ class LLVM_LIBRARY_VISIBILITY AVRTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
bool allowsLargerPreferedTypeAlignment() const override { return false; }
diff --git a/clang/lib/Basic/Targets/BPF.cpp b/clang/lib/Basic/Targets/BPF.cpp
index c5efbda520998d..b4504faa4d5eeb 100644
--- a/clang/lib/Basic/Targets/BPF.cpp
+++ b/clang/lib/Basic/Targets/BPF.cpp
@@ -89,9 +89,9 @@ void BPFTargetInfo::fillValidCPUList(SmallVectorImpl<StringRef> &Values) const {
Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-BPFTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+BPFTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
bool BPFTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
diff --git a/clang/lib/Basic/Targets/BPF.h b/clang/lib/Basic/Targets/BPF.h
index 97aaf35fc523d1..d1f68b842348ea 100644
--- a/clang/lib/Basic/Targets/BPF.h
+++ b/clang/lib/Basic/Targets/BPF.h
@@ -58,8 +58,7 @@ class LLVM_LIBRARY_VISIBILITY BPFTargetInfo : public TargetInfo {
bool handleTargetFeatures(std::vector<std::string> &Features,
DiagnosticsEngine &Diags) override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
std::string_view getClobbers() const override { return ""; }
diff --git a/clang/lib/Basic/Targets/CSKY.h b/clang/lib/Basic/Targets/CSKY.h
index 7ecc9bc780412f..ddfbe4794daadd 100644
--- a/clang/lib/Basic/Targets/CSKY.h
+++ b/clang/lib/Basic/Targets/CSKY.h
@@ -73,9 +73,8 @@ class LLVM_LIBRARY_VISIBILITY CSKYTargetInfo : public TargetInfo {
unsigned getMinGlobalAlign(uint64_t, bool HasNonWeakDef) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
BuiltinVaListKind getBuiltinVaListKind() const override {
diff --git a/clang/lib/Basic/Targets/DirectX.h b/clang/lib/Basic/Targets/DirectX.h
index 55ea3f877b23f6..9ab387ebc8d41c 100644
--- a/clang/lib/Basic/Targets/DirectX.h
+++ b/clang/lib/Basic/Targets/DirectX.h
@@ -72,9 +72,8 @@ class LLVM_LIBRARY_VISIBILITY DirectXTargetInfo : public TargetInfo {
return Feature == "directx";
}
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
std::string_view getClobbers() const override { return ""; }
diff --git a/clang/lib/Basic/Targets/Hexagon.cpp b/clang/lib/Basic/Targets/Hexagon.cpp
index a852e100a57013..e3ec5c94c4861b 100644
--- a/clang/lib/Basic/Targets/Hexagon.cpp
+++ b/clang/lib/Basic/Targets/Hexagon.cpp
@@ -278,7 +278,7 @@ void HexagonTargetInfo::fillValidCPUList(
Values.push_back(Suffix.Name);
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-HexagonTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+HexagonTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
diff --git a/clang/lib/Basic/Targets/Hexagon.h b/clang/lib/Basic/Targets/Hexagon.h
index b93574aa599f4c..a65663ca09eee7 100644
--- a/clang/lib/Basic/Targets/Hexagon.h
+++ b/clang/lib/Basic/Targets/Hexagon.h
@@ -66,8 +66,7 @@ class LLVM_LIBRARY_VISIBILITY HexagonTargetInfo : public TargetInfo {
BoolWidth = BoolAlign = 8;
}
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool validateAsmConstraint(const char *&Name,
TargetInfo::ConstraintInfo &Info) const override {
diff --git a/clang/lib/Basic/Targets/Lanai.h b/clang/lib/Basic/Targets/Lanai.h
index e715fa220df7a1..e32ef9d7d40daa 100644
--- a/clang/lib/Basic/Targets/Lanai.h
+++ b/clang/lib/Basic/Targets/Lanai.h
@@ -78,9 +78,8 @@ class LLVM_LIBRARY_VISIBILITY LanaiTargetInfo : public TargetInfo {
return TargetInfo::VoidPtrBuiltinVaList;
}
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
bool validateAsmConstraint(const char *&Name,
diff --git a/clang/lib/Basic/Targets/LoongArch.cpp b/clang/lib/Basic/Targets/LoongArch.cpp
index 7c0f40f6af3b5f..95111756d3999f 100644
--- a/clang/lib/Basic/Targets/LoongArch.cpp
+++ b/clang/lib/Basic/Targets/LoongArch.cpp
@@ -270,20 +270,54 @@ void LoongArchTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
}
+static constexpr int NumBaseBuiltins =
+ LoongArch::FirstLSXBuiltin - Builtin::FirstTSBuiltin;
+static constexpr int NumLSXBuiltins =
+ LoongArch::FirstLASXBuiltin - LoongArch::FirstLSXBuiltin;
+static constexpr int NumLASXBuiltins =
+ LoongArch::LastTSBuiltin - LoongArch::FirstLASXBuiltin;
static constexpr int NumBuiltins =
- clang::LoongArch::LastTSBuiltin - Builtin::FirstTSBuiltin;
+ LoongArch::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static_assert(NumBuiltins ==
+ (NumBaseBuiltins + NumLSXBuiltins + NumLASXBuiltins));
-static constexpr llvm::StringTable BuiltinStrings =
+static constexpr llvm::StringTable BuiltinBaseStrings =
CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#include "clang/Basic/BuiltinsLoongArch.def"
+#include "clang/Basic/BuiltinsLoongArchBase.def"
+#undef TARGET_BUILTIN
;
-static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
+static constexpr auto BuiltinBaseInfos = Builtin::MakeInfos<NumBaseBuiltins>({
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#include "clang/Basic/BuiltinsLoongArch.def"
+#include "clang/Basic/BuiltinsLoongArchBase.def"
+#undef TARGET_BUILTIN
+});
+
+static constexpr llvm::StringTable BuiltinLSXStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsLoongArchLSX.def"
+#undef TARGET_BUILTIN
+ ;
+
+static constexpr auto BuiltinLSXInfos = Builtin::MakeInfos<NumLSXBuiltins>({
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsLoongArchLSX.def"
+#undef TARGET_BUILTIN
+});
+
+static constexpr llvm::StringTable BuiltinLASXStrings =
+ CLANG_BUILTIN_STR_TABLE_START
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#include "clang/Basic/BuiltinsLoongArchLASX.def"
+#undef TARGET_BUILTIN
+ ;
+
+static constexpr auto BuiltinLASXInfos = Builtin::MakeInfos<NumLASXBuiltins>({
+#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+#include "clang/Basic/BuiltinsLoongArchLASX.def"
+#undef TARGET_BUILTIN
});
bool LoongArchTargetInfo::initFeatureMap(
@@ -311,9 +345,13 @@ bool LoongArchTargetInfo::hasFeature(StringRef Feature) const {
.Default(false);
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-LoongArchTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+LoongArchTargetInfo::getTargetBuiltins() const {
+ return {
+ {&BuiltinBaseStrings, BuiltinBaseInfos},
+ {&BuiltinLSXStrings, BuiltinLSXInfos},
+ {&BuiltinLASXStrings, BuiltinLASXInfos},
+ };
}
bool LoongArchTargetInfo::handleTargetFeatures(
diff --git a/clang/lib/Basic/Targets/LoongArch.h b/clang/lib/Basic/Targets/LoongArch.h
index dee92403dac3a3..89eb8e3861ed77 100644
--- a/clang/lib/Basic/Targets/LoongArch.h
+++ b/clang/lib/Basic/Targets/LoongArch.h
@@ -70,8 +70,7 @@ class LLVM_LIBRARY_VISIBILITY LoongArchTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/M68k.cpp b/clang/lib/Basic/Targets/M68k.cpp
index e2a382653a5c5d..e5b7f06829cd91 100644
--- a/clang/lib/Basic/Targets/M68k.cpp
+++ b/clang/lib/Basic/Targets/M68k.cpp
@@ -115,10 +115,10 @@ void M68kTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__HAVE_68881__");
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-M68kTargetInfo::getTargetBuiltinStorage() const {
+llvm::SmallVector<Builtin::InfosShard>
+M68kTargetInfo::getTargetBuiltins() const {
// FIXME: Implement.
- return {nullptr, {}};
+ return {};
}
bool M68kTargetInfo::hasFeature(StringRef Feature) const {
diff --git a/clang/lib/Basic/Targets/M68k.h b/clang/lib/Basic/Targets/M68k.h
index 104cdfd20c1bdc..729d79ff77fbf6 100644
--- a/clang/lib/Basic/Targets/M68k.h
+++ b/clang/lib/Basic/Targets/M68k.h
@@ -44,8 +44,7 @@ class LLVM_LIBRARY_VISIBILITY M68kTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool hasFeature(StringRef Feature) const override;
ArrayRef<const char *> getGCCRegNames() const override;
ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
diff --git a/clang/lib/Basic/Targets/MSP430.h b/clang/lib/Basic/Targets/MSP430.h
index a998ea0143b7f0..d7d05f992f4f6b 100644
--- a/clang/lib/Basic/Targets/MSP430.h
+++ b/clang/lib/Basic/Targets/MSP430.h
@@ -50,10 +50,9 @@ class LLVM_LIBRARY_VISIBILITY MSP430TargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
// FIXME: Implement.
- return {nullptr, {}};
+ return {};
}
bool allowsLargerPreferedTypeAlignment() const override { return false; }
diff --git a/clang/lib/Basic/Targets/Mips.cpp b/clang/lib/Basic/Targets/Mips.cpp
index d6910768378544..866be53c8a3632 100644
--- a/clang/lib/Basic/Targets/Mips.cpp
+++ b/clang/lib/Basic/Targets/Mips.cpp
@@ -230,9 +230,9 @@ bool MipsTargetInfo::hasFeature(StringRef Feature) const {
.Default(false);
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-MipsTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+MipsTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
unsigned MipsTargetInfo::getUnwindWordWidth() const {
diff --git a/clang/lib/Basic/Targets/Mips.h b/clang/lib/Basic/Targets/Mips.h
index 4274dcedc909c5..35501ed44ccd72 100644
--- a/clang/lib/Basic/Targets/Mips.h
+++ b/clang/lib/Basic/Targets/Mips.h
@@ -198,8 +198,7 @@ class LLVM_LIBRARY_VISIBILITY MipsTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool hasFeature(StringRef Feature) const override;
diff --git a/clang/lib/Basic/Targets/NVPTX.cpp b/clang/lib/Basic/Targets/NVPTX.cpp
index e765ff545b54e0..93e04d3460f0e3 100644
--- a/clang/lib/Basic/Targets/NVPTX.cpp
+++ b/clang/lib/Basic/Targets/NVPTX.cpp
@@ -302,7 +302,7 @@ void NVPTXTargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-NVPTXTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+NVPTXTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
diff --git a/clang/lib/Basic/Targets/NVPTX.h b/clang/lib/Basic/Targets/NVPTX.h
index bd029e10039e26..3dd13836a73035 100644
--- a/clang/lib/Basic/Targets/NVPTX.h
+++ b/clang/lib/Basic/Targets/NVPTX.h
@@ -74,8 +74,7 @@ class LLVM_LIBRARY_VISIBILITY NVPTXTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool useFP16ConversionIntrinsics() const override { return false; }
diff --git a/clang/lib/Basic/Targets/PNaCl.h b/clang/lib/Basic/Targets/PNaCl.h
index 89648f980f4eba..d162776b5a0d63 100644
--- a/clang/lib/Basic/Targets/PNaCl.h
+++ b/clang/lib/Basic/Targets/PNaCl.h
@@ -52,9 +52,8 @@ class LLVM_LIBRARY_VISIBILITY PNaClTargetInfo : public TargetInfo {
return Feature == "pnacl";
}
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
BuiltinVaListKind getBuiltinVaListKind() const override {
diff --git a/clang/lib/Basic/Targets/PPC.cpp b/clang/lib/Basic/Targets/PPC.cpp
index ab96983c3dc30c..2d8891a739ca35 100644
--- a/clang/lib/Basic/Targets/PPC.cpp
+++ b/clang/lib/Basic/Targets/PPC.cpp
@@ -934,9 +934,9 @@ void PPCTargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
MaxAtomicInlineWidth = 128;
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-PPCTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+PPCTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
bool PPCTargetInfo::validateCpuSupports(StringRef FeatureStr) const {
diff --git a/clang/lib/Basic/Targets/PPC.h b/clang/lib/Basic/Targets/PPC.h
index 76f4d152ae5919..db6ac6f0bd3380 100644
--- a/clang/lib/Basic/Targets/PPC.h
+++ b/clang/lib/Basic/Targets/PPC.h
@@ -187,8 +187,7 @@ class LLVM_LIBRARY_VISIBILITY PPCTargetInfo : public TargetInfo {
StringRef getABI() const override { return ABI; }
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool isCLZForZeroUndef() const override { return false; }
diff --git a/clang/lib/Basic/Targets/RISCV.cpp b/clang/lib/Basic/Targets/RISCV.cpp
index efa7a91ad03078..ccd70f0e6e7b2a 100644
--- a/clang/lib/Basic/Targets/RISCV.cpp
+++ b/clang/lib/Basic/Targets/RISCV.cpp
@@ -240,31 +240,44 @@ void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
+static constexpr int NumRVVBuiltins =
+ clang::RISCVVector::FirstTSBuiltin - Builtin::FirstTSBuiltin;
+static constexpr int NumRISCVBuiltins =
+ clang::RISCV::LastTSBuiltin - RISCVVector::FirstTSBuiltin;
static constexpr int NumBuiltins =
clang::RISCV::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static_assert(NumBuiltins == (NumRVVBuiltins + NumRISCVBuiltins));
-static constexpr llvm::StringTable BuiltinStrings =
+static constexpr llvm::StringTable BuiltinRVVStrings =
CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsRISCVVector.def"
+ ;
+static constexpr llvm::StringTable BuiltinRISCVStrings =
+ CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsRISCV.inc"
;
-static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
+static constexpr auto BuiltinRVVInfos = Builtin::MakeInfos<NumRVVBuiltins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsRISCVVector.def"
+});
+static constexpr auto BuiltinRISCVInfos = Builtin::MakeInfos<NumRISCVBuiltins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsRISCV.inc"
});
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-RISCVTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+RISCVTargetInfo::getTargetBuiltins() const {
+ return {
+ {&BuiltinRVVStrings, BuiltinRVVInfos},
+ {&BuiltinRISCVStrings, BuiltinRISCVInfos},
+ };
}
bool RISCVTargetInfo::initFeatureMap(
diff --git a/clang/lib/Basic/Targets/RISCV.h b/clang/lib/Basic/Targets/RISCV.h
index c3f62acff2623d..886fdb851f502c 100644
--- a/clang/lib/Basic/Targets/RISCV.h
+++ b/clang/lib/Basic/Targets/RISCV.h
@@ -62,8 +62,7 @@ class RISCVTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/SPIR.cpp b/clang/lib/Basic/Targets/SPIR.cpp
index fd755ca056691b..694b0e6cf9c955 100644
--- a/clang/lib/Basic/Targets/SPIR.cpp
+++ b/clang/lib/Basic/Targets/SPIR.cpp
@@ -81,9 +81,9 @@ SPIRV64AMDGCNTargetInfo::convertConstraint(const char *&Constraint) const {
return AMDGPUTI.convertConstraint(Constraint);
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-SPIRV64AMDGCNTargetInfo::getTargetBuiltinStorage() const {
- return AMDGPUTI.getTargetBuiltinStorage();
+llvm::SmallVector<Builtin::InfosShard>
+SPIRV64AMDGCNTargetInfo::getTargetBuiltins() const {
+ return AMDGPUTI.getTargetBuiltins();
}
void SPIRV64AMDGCNTargetInfo::getTargetDefines(const LangOptions &Opts,
diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h
index b1c5c6ea063545..b37e3a09ff5329 100644
--- a/clang/lib/Basic/Targets/SPIR.h
+++ b/clang/lib/Basic/Targets/SPIR.h
@@ -159,9 +159,8 @@ class LLVM_LIBRARY_VISIBILITY BaseSPIRTargetInfo : public TargetInfo {
// memcpy as per section 3 of the SPIR spec.
bool useFP16ConversionIntrinsics() const override { return false; }
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
std::string_view getClobbers() const override { return ""; }
@@ -411,8 +410,7 @@ class LLVM_LIBRARY_VISIBILITY SPIRV64AMDGCNTargetInfo final
std::string convertConstraint(const char *&Constraint) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
diff --git a/clang/lib/Basic/Targets/Sparc.h b/clang/lib/Basic/Targets/Sparc.h
index 9836f82a2fc54a..3215e648ba6c31 100644
--- a/clang/lib/Basic/Targets/Sparc.h
+++ b/clang/lib/Basic/Targets/Sparc.h
@@ -48,10 +48,9 @@ class LLVM_LIBRARY_VISIBILITY SparcTargetInfo : public TargetInfo {
bool hasFeature(StringRef Feature) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
// FIXME: Implement!
- return {nullptr, {}};
+ return {};
}
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/SystemZ.cpp b/clang/lib/Basic/Targets/SystemZ.cpp
index be84329bf85d41..26e212220f85ad 100644
--- a/clang/lib/Basic/Targets/SystemZ.cpp
+++ b/clang/lib/Basic/Targets/SystemZ.cpp
@@ -178,7 +178,7 @@ void SystemZTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__VEC__", "10304");
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-SystemZTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+SystemZTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
diff --git a/clang/lib/Basic/Targets/SystemZ.h b/clang/lib/Basic/Targets/SystemZ.h
index 66292c206cbe41..b64ee286131659 100644
--- a/clang/lib/Basic/Targets/SystemZ.h
+++ b/clang/lib/Basic/Targets/SystemZ.h
@@ -99,8 +99,7 @@ class LLVM_LIBRARY_VISIBILITY SystemZTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
ArrayRef<const char *> getGCCRegNames() const override;
diff --git a/clang/lib/Basic/Targets/TCE.h b/clang/lib/Basic/Targets/TCE.h
index 4f06e013d1dbd4..18c71514fa5ced 100644
--- a/clang/lib/Basic/Targets/TCE.h
+++ b/clang/lib/Basic/Targets/TCE.h
@@ -95,9 +95,8 @@ class LLVM_LIBRARY_VISIBILITY TCETargetInfo : public TargetInfo {
bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
std::string_view getClobbers() const override { return ""; }
diff --git a/clang/lib/Basic/Targets/VE.cpp b/clang/lib/Basic/Targets/VE.cpp
index a955767f46599a..5451f3c303637d 100644
--- a/clang/lib/Basic/Targets/VE.cpp
+++ b/clang/lib/Basic/Targets/VE.cpp
@@ -47,7 +47,6 @@ void VETargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-VETargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard> VETargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
diff --git a/clang/lib/Basic/Targets/VE.h b/clang/lib/Basic/Targets/VE.h
index 69621023acff00..e9b7e92f3f8504 100644
--- a/clang/lib/Basic/Targets/VE.h
+++ b/clang/lib/Basic/Targets/VE.h
@@ -55,8 +55,7 @@ class LLVM_LIBRARY_VISIBILITY VETargetInfo : public TargetInfo {
bool hasSjLjLowering() const override { return true; }
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/WebAssembly.cpp b/clang/lib/Basic/Targets/WebAssembly.cpp
index 4282b1496333ba..f19c57f1a3a502 100644
--- a/clang/lib/Basic/Targets/WebAssembly.cpp
+++ b/clang/lib/Basic/Targets/WebAssembly.cpp
@@ -367,9 +367,9 @@ bool WebAssemblyTargetInfo::handleTargetFeatures(
return true;
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-WebAssemblyTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+WebAssemblyTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags,
diff --git a/clang/lib/Basic/Targets/WebAssembly.h b/clang/lib/Basic/Targets/WebAssembly.h
index a67bf5e3733088..83dad2b50ef40f 100644
--- a/clang/lib/Basic/Targets/WebAssembly.h
+++ b/clang/lib/Basic/Targets/WebAssembly.h
@@ -120,8 +120,7 @@ class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo {
bool setCPU(const std::string &Name) final { return isValidCPUName(Name); }
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const final;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const final;
BuiltinVaListKind getBuiltinVaListKind() const final {
return VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/X86.cpp b/clang/lib/Basic/Targets/X86.cpp
index 4ed8bcec94a5be..9999487c385c50 100644
--- a/clang/lib/Basic/Targets/X86.cpp
+++ b/clang/lib/Basic/Targets/X86.cpp
@@ -27,33 +27,40 @@ namespace targets {
static constexpr int NumX86Builtins =
X86::LastX86CommonBuiltin - Builtin::FirstTSBuiltin + 1;
static constexpr int NumX86_64Builtins =
- X86::LastTSBuiltin - Builtin::FirstTSBuiltin;
-static_assert(NumX86Builtins < NumX86_64Builtins);
+ X86::LastTSBuiltin - X86::FirstX86_64Builtin;
+static constexpr int NumBuiltins = X86::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static_assert(NumBuiltins == (NumX86Builtins + NumX86_64Builtins));
-static constexpr llvm::StringTable BuiltinStrings =
+static constexpr llvm::StringTable BuiltinX86Strings =
CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsX86.inc"
+ ;
+static constexpr llvm::StringTable BuiltinX86_64Strings =
+ CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsX86_64.inc"
;
-static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumX86_64Builtins>({
+static constexpr auto BuiltinX86Infos = Builtin::MakeInfos<NumX86Builtins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsX86.inc"
+});
+static constexpr auto BuiltinX86_64Infos =
+ Builtin::MakeInfos<NumX86_64Builtins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsX86_64.inc"
-});
+ });
static const char *const GCCRegNames[] = {
"ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
@@ -1870,14 +1877,15 @@ ArrayRef<TargetInfo::AddlRegName> X86TargetInfo::getGCCAddlRegNames() const {
return llvm::ArrayRef(AddlRegNames);
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-X86_32TargetInfo::getTargetBuiltinStorage() const {
- // Only use the relevant prefix of the infos, the string table base is common.
- return {&BuiltinStrings,
- llvm::ArrayRef(BuiltinInfos).take_front(NumX86Builtins)};
+llvm::SmallVector<Builtin::InfosShard>
+X86_32TargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinX86Strings, BuiltinX86Infos}};
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-X86_64TargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+X86_64TargetInfo::getTargetBuiltins() const {
+ return {
+ {&BuiltinX86Strings, BuiltinX86Infos},
+ {&BuiltinX86_64Strings, BuiltinX86_64Infos},
+ };
}
diff --git a/clang/lib/Basic/Targets/X86.h b/clang/lib/Basic/Targets/X86.h
index d29f9298a285bb..1e651293d48748 100644
--- a/clang/lib/Basic/Targets/X86.h
+++ b/clang/lib/Basic/Targets/X86.h
@@ -508,8 +508,7 @@ class LLVM_LIBRARY_VISIBILITY X86_32TargetInfo : public X86TargetInfo {
MaxAtomicInlineWidth = 64;
}
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool hasBitIntType() const override { return true; }
size_t getMaxBitIntWidth() const override {
@@ -813,8 +812,7 @@ class LLVM_LIBRARY_VISIBILITY X86_64TargetInfo : public X86TargetInfo {
MaxAtomicInlineWidth = 128;
}
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
bool hasBitIntType() const override { return true; }
size_t getMaxBitIntWidth() const override {
diff --git a/clang/lib/Basic/Targets/XCore.cpp b/clang/lib/Basic/Targets/XCore.cpp
index 334e853a48a12a..c725703ede5b0b 100644
--- a/clang/lib/Basic/Targets/XCore.cpp
+++ b/clang/lib/Basic/Targets/XCore.cpp
@@ -39,7 +39,7 @@ void XCoreTargetInfo::getTargetDefines(const LangOptions &Opts,
Builder.defineMacro("__XS1B__");
}
-std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
-XCoreTargetInfo::getTargetBuiltinStorage() const {
- return {&BuiltinStrings, BuiltinInfos};
+llvm::SmallVector<Builtin::InfosShard>
+XCoreTargetInfo::getTargetBuiltins() const {
+ return {{&BuiltinStrings, BuiltinInfos}};
}
diff --git a/clang/lib/Basic/Targets/XCore.h b/clang/lib/Basic/Targets/XCore.h
index 3f31095fcef297..9af9e0658f629a 100644
--- a/clang/lib/Basic/Targets/XCore.h
+++ b/clang/lib/Basic/Targets/XCore.h
@@ -43,8 +43,7 @@ class LLVM_LIBRARY_VISIBILITY XCoreTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override;
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
diff --git a/clang/lib/Basic/Targets/Xtensa.h b/clang/lib/Basic/Targets/Xtensa.h
index e262c392ddbf39..470835aacff527 100644
--- a/clang/lib/Basic/Targets/Xtensa.h
+++ b/clang/lib/Basic/Targets/Xtensa.h
@@ -56,9 +56,8 @@ class LLVM_LIBRARY_VISIBILITY XtensaTargetInfo : public TargetInfo {
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override;
- std::pair<const llvm::StringTable *, ArrayRef<Builtin::Info>>
- getTargetBuiltinStorage() const override {
- return {nullptr, {}};
+ llvm::SmallVector<Builtin::InfosShard> getTargetBuiltins() const override {
+ return {};
}
BuiltinVaListKind getBuiltinVaListKind() const override {
>From ed3c9a5dfc1b7710926183a11ceaaeed35da0a43 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Sun, 15 Dec 2024 03:20:15 +0000
Subject: [PATCH 3/9] Switch RISCV to leverage sharded builtins w/ TableGen
This lets the TableGen-ed code be much cleaner, directly building an
efficient string table without duplicates.
The pattern here can then be repeated in other targets.
---
.../clang/Basic/BuiltinsRISCVVector.def | 22 -----
clang/include/clang/Basic/TargetBuiltins.h | 8 +-
clang/lib/Basic/Targets/RISCV.cpp | 59 ++++++++-----
clang/utils/TableGen/RISCVVEmitter.cpp | 84 ++++++++++++++-----
4 files changed, 109 insertions(+), 64 deletions(-)
delete mode 100644 clang/include/clang/Basic/BuiltinsRISCVVector.def
diff --git a/clang/include/clang/Basic/BuiltinsRISCVVector.def b/clang/include/clang/Basic/BuiltinsRISCVVector.def
deleted file mode 100644
index 6dfa87a1a1d313..00000000000000
--- a/clang/include/clang/Basic/BuiltinsRISCVVector.def
+++ /dev/null
@@ -1,22 +0,0 @@
-//==- BuiltinsRISCVVector.def - RISC-V Vector Builtin Database ---*- C++ -*-==//
-//
-// 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 file defines the RISC-V-specific builtin function database. Users of
-// this file must define the BUILTIN macro to make use of this information.
-//
-//===----------------------------------------------------------------------===//
-
-#if defined(BUILTIN) && !defined(TARGET_BUILTIN)
-# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-#include "clang/Basic/riscv_vector_builtins.inc"
-#include "clang/Basic/riscv_sifive_vector_builtins.inc"
-
-#undef BUILTIN
-#undef TARGET_BUILTIN
diff --git a/clang/include/clang/Basic/TargetBuiltins.h b/clang/include/clang/Basic/TargetBuiltins.h
index f34e4241b26842..370f1f7cb1497f 100644
--- a/clang/include/clang/Basic/TargetBuiltins.h
+++ b/clang/include/clang/Basic/TargetBuiltins.h
@@ -146,8 +146,12 @@ namespace clang {
namespace RISCVVector {
enum {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
-#include "clang/Basic/BuiltinsRISCVVector.def"
+#define GET_RISCVV_BUILTIN_ENUMERATORS
+#include "clang/Basic/riscv_vector_builtins.inc"
+ FirstSiFiveBuiltin,
+ LastRVVBuiltin = FirstSiFiveBuiltin - 1,
+#include "clang/Basic/riscv_sifive_vector_builtins.inc"
+#undef GET_RISCVV_BUILTIN_ENUMERATORS
FirstTSBuiltin,
};
}
diff --git a/clang/lib/Basic/Targets/RISCV.cpp b/clang/lib/Basic/Targets/RISCV.cpp
index ccd70f0e6e7b2a..0e78471d6f4d7b 100644
--- a/clang/lib/Basic/Targets/RISCV.cpp
+++ b/clang/lib/Basic/Targets/RISCV.cpp
@@ -241,32 +241,50 @@ void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts,
}
static constexpr int NumRVVBuiltins =
- clang::RISCVVector::FirstTSBuiltin - Builtin::FirstTSBuiltin;
+ RISCVVector::FirstSiFiveBuiltin - Builtin::FirstTSBuiltin;
+static constexpr int NumRVVSiFiveBuiltins =
+ RISCVVector::FirstTSBuiltin - RISCVVector::FirstSiFiveBuiltin;
static constexpr int NumRISCVBuiltins =
- clang::RISCV::LastTSBuiltin - RISCVVector::FirstTSBuiltin;
+ RISCV::LastTSBuiltin - RISCVVector::FirstTSBuiltin;
static constexpr int NumBuiltins =
- clang::RISCV::LastTSBuiltin - Builtin::FirstTSBuiltin;
-static_assert(NumBuiltins == (NumRVVBuiltins + NumRISCVBuiltins));
-
-static constexpr llvm::StringTable BuiltinRVVStrings =
- CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#include "clang/Basic/BuiltinsRISCVVector.def"
- ;
-static constexpr llvm::StringTable BuiltinRISCVStrings =
+ RISCV::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static_assert(NumBuiltins ==
+ (NumRVVBuiltins + NumRVVSiFiveBuiltins + NumRISCVBuiltins));
+
+namespace RVV {
+#define GET_RISCVV_BUILTIN_STR_TABLE
+#include "clang/Basic/riscv_vector_builtins.inc"
+#undef GET_RISCVV_BUILTIN_STR_TABLE
+static_assert(BuiltinStrings.size() < 100'000);
+
+static constexpr std::array<Builtin::Info, NumRVVBuiltins> BuiltinInfos = {
+#define GET_RISCVV_BUILTIN_INFOS
+#include "clang/Basic/riscv_vector_builtins.inc"
+#undef GET_RISCVV_BUILTIN_INFOS
+};
+} // namespace RVV
+
+namespace RVVSiFive {
+#define GET_RISCVV_BUILTIN_STR_TABLE
+#include "clang/Basic/riscv_sifive_vector_builtins.inc"
+#undef GET_RISCVV_BUILTIN_STR_TABLE
+
+static constexpr std::array<Builtin::Info, NumRVVSiFiveBuiltins> BuiltinInfos =
+ {
+#define GET_RISCVV_BUILTIN_INFOS
+#include "clang/Basic/riscv_sifive_vector_builtins.inc"
+#undef GET_RISCVV_BUILTIN_INFOS
+};
+} // namespace RVVSiFive
+
+static constexpr llvm::StringTable BuiltinStrings =
CLANG_BUILTIN_STR_TABLE_START
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsRISCV.inc"
;
-static constexpr auto BuiltinRVVInfos = Builtin::MakeInfos<NumRVVBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#include "clang/Basic/BuiltinsRISCVVector.def"
-});
-static constexpr auto BuiltinRISCVInfos = Builtin::MakeInfos<NumRISCVBuiltins>({
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumRISCVBuiltins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
#include "clang/Basic/BuiltinsRISCV.inc"
@@ -275,8 +293,9 @@ static constexpr auto BuiltinRISCVInfos = Builtin::MakeInfos<NumRISCVBuiltins>({
llvm::SmallVector<Builtin::InfosShard>
RISCVTargetInfo::getTargetBuiltins() const {
return {
- {&BuiltinRVVStrings, BuiltinRVVInfos},
- {&BuiltinRISCVStrings, BuiltinRISCVInfos},
+ {&RVV::BuiltinStrings, RVV::BuiltinInfos},
+ {&RVVSiFive::BuiltinStrings, RVVSiFive::BuiltinInfos},
+ {&BuiltinStrings, BuiltinInfos},
};
}
diff --git a/clang/utils/TableGen/RISCVVEmitter.cpp b/clang/utils/TableGen/RISCVVEmitter.cpp
index acba1a31912816..077854f71d236d 100644
--- a/clang/utils/TableGen/RISCVVEmitter.cpp
+++ b/clang/utils/TableGen/RISCVVEmitter.cpp
@@ -18,10 +18,12 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Twine.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/StringToOffsetTable.h"
#include <optional>
using namespace llvm;
@@ -498,31 +500,73 @@ void RVVEmitter::createBuiltins(raw_ostream &OS) {
std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
createRVVIntrinsics(Defs);
- // Map to keep track of which builtin names have already been emitted.
- StringMap<RVVIntrinsic *> BuiltinMap;
+ llvm::StringToOffsetTable Table;
+ // Ensure offset zero is the empty string.
+ Table.GetOrAddStringOffset("");
+ // Hard coded strings used in the builtin structures.
+ Table.GetOrAddStringOffset("n");
+ Table.GetOrAddStringOffset("zve32x");
- OS << "#if defined(TARGET_BUILTIN) && !defined(RISCVV_BUILTIN)\n";
- OS << "#define RISCVV_BUILTIN(ID, TYPE, ATTRS) TARGET_BUILTIN(ID, TYPE, "
- "ATTRS, \"zve32x\")\n";
- OS << "#endif\n";
+ auto PrefixName = [](RVVIntrinsic *Def) -> std::string {
+ return ("__builtin_rvv_" + Def->getBuiltinName()).str();
+ };
+
+ // Map to unique the builtin names.
+ StringMap<RVVIntrinsic *> BuiltinMap;
+ std::vector<RVVIntrinsic *> UniqueDefs;
for (auto &Def : Defs) {
- auto P =
- BuiltinMap.insert(std::make_pair(Def->getBuiltinName(), Def.get()));
- if (!P.second) {
- // Verf that this would have produced the same builtin definition.
- if (P.first->second->hasBuiltinAlias() != Def->hasBuiltinAlias())
- PrintFatalError("Builtin with same name has different hasAutoDef");
- else if (!Def->hasBuiltinAlias() &&
- P.first->second->getBuiltinTypeStr() != Def->getBuiltinTypeStr())
- PrintFatalError("Builtin with same name has different type string");
+ auto P = BuiltinMap.insert({Def->getBuiltinName(), Def.get()});
+ if (P.second) {
+ Table.GetOrAddStringOffset(PrefixName(Def.get()));
+ if (!Def->hasBuiltinAlias())
+ Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
+ UniqueDefs.push_back(Def.get());
continue;
}
- OS << "RISCVV_BUILTIN(__builtin_rvv_" << Def->getBuiltinName() << ",\"";
- if (!Def->hasBuiltinAlias())
- OS << Def->getBuiltinTypeStr();
- OS << "\", \"n\")\n";
+
+ // Verf that this would have produced the same builtin definition.
+ if (P.first->second->hasBuiltinAlias() != Def->hasBuiltinAlias())
+ PrintFatalError("Builtin with same name has different hasAutoDef");
+ else if (!Def->hasBuiltinAlias() &&
+ P.first->second->getBuiltinTypeStr() != Def->getBuiltinTypeStr())
+ PrintFatalError("Builtin with same name has different type string");
+ }
+
+ // Emit the enumerators of RVV builtins. Note that these are emitted without
+ // any outer context to enable concatenating them.
+ OS << "// RISCV Vector builtin enumerators\n";
+ OS << "#ifdef GET_RISCVV_BUILTIN_ENUMERATORS\n";
+ for (RVVIntrinsic *Def : UniqueDefs)
+ OS << " BI__builtin_rvv_" << Def->getBuiltinName() << ",\n";
+ OS << "#endif // GET_RISCVV_BUILTIN_ENUMERATORS\n\n";
+
+ // Emit the string table for the RVV builtins.
+ OS << "// RISCV Vector builtin enumerators\n";
+ OS << "#ifdef GET_RISCVV_BUILTIN_STR_TABLE\n";
+ Table.EmitStringLiteralDef(
+ OS, "static constexpr llvm::StringTable BuiltinStrings", "");
+ OS << "#endif // GET_RISCVV_BUILTIN_STR_TABLE\n\n";
+
+ // Emit the info structs of RVV builtins. Note that these are emitted without
+ // any outer context to enable concatenating them.
+ OS << "// RISCV Vector builtin infos\n";
+ OS << "#ifdef GET_RISCVV_BUILTIN_INFOS\n";
+ for (RVVIntrinsic *Def : UniqueDefs) {
+ OS << " Builtin::Info{Builtin::Info::StrOffsets{"
+ << Table.GetStringOffset(PrefixName(Def)) << " /* " << PrefixName(Def)
+ << " */, ";
+ if (Def->hasBuiltinAlias()) {
+ OS << "0, ";
+ } else {
+ OS << Table.GetStringOffset(Def->getBuiltinTypeStr()) << " /* "
+ << Def->getBuiltinTypeStr() << " */, ";
+ }
+ OS << Table.GetStringOffset("n") << " /* n */, ";
+ OS << Table.GetStringOffset("zve32x") << " /* zve32x */}, ";
+
+ OS << "HeaderDesc::NO_HEADER, ALL_LANGUAGES},\n";
}
- OS << "#undef RISCVV_BUILTIN\n";
+ OS << "#endif // GET_RISCVV_BUILTIN_INFOS\n\n";
}
void RVVEmitter::createCodeGen(raw_ostream &OS) {
>From f0e2a0f2c1238940e3aa03ae18da1304052c9a1a Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Mon, 16 Dec 2024 20:27:41 +0000
Subject: [PATCH 4/9] Switch AArch64 and ARM to use directly TableGen-ed
builtin tables
This leverages the sharded structure of the builtins to make it easy to
directly tablegen most of the AArch64 and ARM builtins while still using
X-macros for a few edge cases. This in turn shrinks the largest string
table by a factor of two.
---
clang/include/clang/Basic/BuiltinsNEON.def | 22 ----
clang/include/clang/Basic/TargetBuiltins.h | 26 +++--
clang/lib/Basic/Targets/AArch64.cpp | 114 +++++++++++++------
clang/lib/Basic/Targets/ARM.cpp | 54 ++++++---
clang/lib/Sema/SemaARM.cpp | 16 +--
clang/utils/TableGen/NeonEmitter.cpp | 61 ++++++----
clang/utils/TableGen/SveEmitter.cpp | 126 +++++++++++++++++----
7 files changed, 284 insertions(+), 135 deletions(-)
delete mode 100644 clang/include/clang/Basic/BuiltinsNEON.def
diff --git a/clang/include/clang/Basic/BuiltinsNEON.def b/clang/include/clang/Basic/BuiltinsNEON.def
deleted file mode 100644
index 9627005ba9824e..00000000000000
--- a/clang/include/clang/Basic/BuiltinsNEON.def
+++ /dev/null
@@ -1,22 +0,0 @@
-//===--- BuiltinsNEON.def - NEON Builtin function database ------*- C++ -*-===//
-//
-// 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 file defines the NEON-specific builtin function database. Users of
-// this file must define the BUILTIN macro to make use of this information.
-//
-//===----------------------------------------------------------------------===//
-
-// The format of this database matches clang/Basic/Builtins.def.
-
-#define GET_NEON_BUILTINS
-#include "clang/Basic/arm_neon.inc"
-#include "clang/Basic/arm_fp16.inc"
-#undef GET_NEON_BUILTINS
-
-#undef BUILTIN
-#undef TARGET_BUILTIN
diff --git a/clang/include/clang/Basic/TargetBuiltins.h b/clang/include/clang/Basic/TargetBuiltins.h
index 370f1f7cb1497f..f066f902a18c02 100644
--- a/clang/include/clang/Basic/TargetBuiltins.h
+++ b/clang/include/clang/Basic/TargetBuiltins.h
@@ -26,9 +26,12 @@ namespace clang {
namespace NEON {
enum {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
-#include "clang/Basic/BuiltinsNEON.def"
+#define GET_NEON_BUILTIN_ENUMERATORS
+#include "clang/Basic/arm_neon.inc"
+ FirstFp16Builtin,
+ LastNeonBuiltin = FirstFp16Builtin - 1,
+#include "clang/Basic/arm_fp16.inc"
+#undef GET_NEON_BUILTIN_ENUMERATORS
FirstTSBuiltin
};
}
@@ -47,9 +50,16 @@ namespace clang {
namespace SVE {
enum {
LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+#define GET_SVE_BUILTIN_ENUMERATORS
+#include "clang/Basic/arm_sve_builtins.inc"
+#undef GET_SVE_BUILTIN_ENUMERATORS
+ FirstNeonBridgeBuiltin,
+ LastSveBuiltin = FirstNeonBridgeBuiltin - 1,
+#define GET_SVE_BUILTINS
#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
-#include "clang/Basic/BuiltinsSVE.def"
+#include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
+#undef TARGET_BUILTIN
+#undef GET_SVE_BUILTINS
FirstTSBuiltin,
};
}
@@ -57,9 +67,9 @@ namespace clang {
namespace SME {
enum {
LastSVEBuiltin = SVE::FirstTSBuiltin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
-#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
-#include "clang/Basic/BuiltinsSME.def"
+#define GET_SME_BUILTIN_ENUMERATORS
+#include "clang/Basic/arm_sme_builtins.inc"
+#undef GET_SME_BUILTIN_ENUMERATORS
FirstTSBuiltin,
};
}
diff --git a/clang/lib/Basic/Targets/AArch64.cpp b/clang/lib/Basic/Targets/AArch64.cpp
index 04697deb50be79..a23cdc5734e49d 100644
--- a/clang/lib/Basic/Targets/AArch64.cpp
+++ b/clang/lib/Basic/Targets/AArch64.cpp
@@ -26,35 +26,80 @@
using namespace clang;
using namespace clang::targets;
-static constexpr int NumNEONBuiltins =
- NEON::FirstTSBuiltin - Builtin::FirstTSBuiltin;
+static constexpr int NumNeonBuiltins =
+ NEON::FirstFp16Builtin - Builtin::FirstTSBuiltin;
+static constexpr int NumFp16Builtins =
+ NEON::FirstTSBuiltin - NEON::FirstFp16Builtin;
static constexpr int NumSVEBuiltins =
- SVE::FirstTSBuiltin - NEON::FirstTSBuiltin;
+ SVE::FirstNeonBridgeBuiltin - NEON::FirstTSBuiltin;
+static constexpr int NumSVENeonBridgeBuiltins =
+ SVE::FirstTSBuiltin - SVE::FirstNeonBridgeBuiltin;
static constexpr int NumSMEBuiltins = SME::FirstTSBuiltin - SVE::FirstTSBuiltin;
static constexpr int NumAArch64Builtins =
AArch64::LastTSBuiltin - SME::FirstTSBuiltin;
static constexpr int NumBuiltins =
AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
-static_assert(NumBuiltins == (NumNEONBuiltins + NumSVEBuiltins +
- NumSMEBuiltins + NumAArch64Builtins));
+static_assert(NumBuiltins ==
+ (NumNeonBuiltins + NumFp16Builtins + NumSVEBuiltins +
+ NumSVENeonBridgeBuiltins + NumSMEBuiltins + NumAArch64Builtins));
+
+namespace clang {
+namespace NEON {
+#define GET_NEON_BUILTIN_STR_TABLE
+#include "clang/Basic/arm_neon.inc"
+#undef GET_NEON_BUILTIN_STR_TABLE
+
+static constexpr std::array<Builtin::Info, NumNeonBuiltins> BuiltinInfos = {
+#define GET_NEON_BUILTIN_INFOS
+#include "clang/Basic/arm_neon.inc"
+#undef GET_NEON_BUILTIN_INFOS
+};
-static constexpr llvm::StringTable BuiltinNEONStrings =
- CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#include "clang/Basic/BuiltinsNEON.def"
- ;
-static constexpr llvm::StringTable BuiltinSVEStrings =
- CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#include "clang/Basic/BuiltinsSVE.def"
- ;
-static constexpr llvm::StringTable BuiltinSMEStrings =
+namespace FP16 {
+#define GET_NEON_BUILTIN_STR_TABLE
+#include "clang/Basic/arm_fp16.inc"
+#undef GET_NEON_BUILTIN_STR_TABLE
+
+static constexpr std::array<Builtin::Info, NumFp16Builtins> BuiltinInfos = {
+#define GET_NEON_BUILTIN_INFOS
+#include "clang/Basic/arm_fp16.inc"
+#undef GET_NEON_BUILTIN_INFOS
+};
+} // namespace FP16
+} // namespace NEON
+
+namespace SVE {
+#define GET_SVE_BUILTIN_STR_TABLE
+#include "clang/Basic/arm_sve_builtins.inc"
+#undef GET_SVE_BUILTIN_STR_TABLE
+
+static constexpr std::array<Builtin::Info, NumSVEBuiltins> BuiltinInfos = {
+#define GET_SVE_BUILTIN_INFOS
+#include "clang/Basic/arm_sve_builtins.inc"
+#undef GET_SVE_BUILTIN_INFOS
+};
+} // namespace SVE
+
+namespace SME {
+#define GET_SME_BUILTIN_STR_TABLE
+#include "clang/Basic/arm_sme_builtins.inc"
+#undef GET_SME_BUILTIN_STR_TABLE
+
+static constexpr std::array<Builtin::Info, NumSMEBuiltins> BuiltinInfos = {
+#define GET_SME_BUILTIN_INFOS
+#include "clang/Basic/arm_sme_builtins.inc"
+#undef GET_SME_BUILTIN_INFOS
+};
+} // namespace SME
+} // namespace clang
+
+static constexpr llvm::StringTable BuiltinSVENeonBridgeStrings =
CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#include "clang/Basic/BuiltinsSME.def"
+#define GET_SVE_BUILTINS
+#include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
+#undef GET_SVE_BUILTINS
+#undef TARGET_BUILTIN
;
static constexpr llvm::StringTable BuiltinAArch64Strings =
CLANG_BUILTIN_STR_TABLE_START
@@ -64,21 +109,14 @@ static constexpr llvm::StringTable BuiltinAArch64Strings =
#include "clang/Basic/BuiltinsAArch64.def"
;
-static constexpr auto BuiltinNEONInfos = Builtin::MakeInfos<NumNEONBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
+static constexpr auto BuiltinSVENeonBridgeInfos =
+ Builtin::MakeInfos<NumSVENeonBridgeBuiltins>({
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#include "clang/Basic/BuiltinsNEON.def"
-});
-static constexpr auto BuiltinSVEInfos = Builtin::MakeInfos<NumSVEBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#include "clang/Basic/BuiltinsSVE.def"
-});
-static constexpr auto BuiltinSMEInfos = Builtin::MakeInfos<NumSMEBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#include "clang/Basic/BuiltinsSME.def"
-});
+#define GET_SVE_BUILTINS
+#include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
+#undef GET_SVE_BUILTINS
+#undef TARGET_BUILTIN
+ });
static constexpr auto BuiltinAArch64Infos =
Builtin::MakeInfos<NumAArch64Builtins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
@@ -732,9 +770,11 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
llvm::SmallVector<Builtin::InfosShard>
AArch64TargetInfo::getTargetBuiltins() const {
return {
- {&BuiltinNEONStrings, BuiltinNEONInfos},
- {&BuiltinSVEStrings, BuiltinSVEInfos},
- {&BuiltinSMEStrings, BuiltinSMEInfos},
+ {&NEON::BuiltinStrings, NEON::BuiltinInfos},
+ {&NEON::FP16::BuiltinStrings, NEON::FP16::BuiltinInfos},
+ {&SVE::BuiltinStrings, SVE::BuiltinInfos},
+ {&BuiltinSVENeonBridgeStrings, BuiltinSVENeonBridgeInfos},
+ {&SME::BuiltinStrings, SME::BuiltinInfos},
{&BuiltinAArch64Strings, BuiltinAArch64Infos},
};
}
diff --git a/clang/lib/Basic/Targets/ARM.cpp b/clang/lib/Basic/Targets/ARM.cpp
index d111443d04409a..92428908fe4a61 100644
--- a/clang/lib/Basic/Targets/ARM.cpp
+++ b/clang/lib/Basic/Targets/ARM.cpp
@@ -1071,26 +1071,50 @@ void ARMTargetInfo::getTargetDefines(const LangOptions &Opts,
}
}
-static constexpr int NumBuiltins =
- clang::ARM::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static constexpr int NumBuiltins = ARM::LastTSBuiltin - Builtin::FirstTSBuiltin;
+static constexpr int NumNeonBuiltins =
+ NEON::FirstFp16Builtin - Builtin::FirstTSBuiltin;
+static constexpr int NumFp16Builtins =
+ NEON::FirstTSBuiltin - NEON::FirstFp16Builtin;
+static constexpr int NumARMBuiltins = ARM::LastTSBuiltin - NEON::FirstTSBuiltin;
+static_assert(NumBuiltins ==
+ (NumNeonBuiltins + NumFp16Builtins + NumARMBuiltins));
+
+namespace clang {
+namespace NEON {
+#define GET_NEON_BUILTIN_STR_TABLE
+#include "clang/Basic/arm_neon.inc"
+#undef GET_NEON_BUILTIN_STR_TABLE
+
+static constexpr std::array<Builtin::Info, NumNeonBuiltins> BuiltinInfos = {
+#define GET_NEON_BUILTIN_INFOS
+#include "clang/Basic/arm_neon.inc"
+#undef GET_NEON_BUILTIN_INFOS
+};
+
+namespace FP16 {
+#define GET_NEON_BUILTIN_STR_TABLE
+#include "clang/Basic/arm_fp16.inc"
+#undef GET_NEON_BUILTIN_STR_TABLE
+
+static constexpr std::array<Builtin::Info, NumFp16Builtins> BuiltinInfos = {
+#define GET_NEON_BUILTIN_INFOS
+#include "clang/Basic/arm_fp16.inc"
+#undef GET_NEON_BUILTIN_INFOS
+};
+} // namespace FP16
+} // namespace NEON
+} // namespace clang
static constexpr llvm::StringTable BuiltinStrings =
CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#include "clang/Basic/BuiltinsNEON.def"
-
#define BUILTIN CLANG_BUILTIN_STR_TABLE
#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsARM.def"
- ;
+ ; // namespace clang
-static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#include "clang/Basic/BuiltinsNEON.def"
+static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumARMBuiltins>({
#define BUILTIN CLANG_BUILTIN_ENTRY
#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY
#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
@@ -1101,7 +1125,11 @@ static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
llvm::SmallVector<Builtin::InfosShard>
ARMTargetInfo::getTargetBuiltins() const {
- return {{&BuiltinStrings, BuiltinInfos}};
+ return {
+ {&NEON::BuiltinStrings, NEON::BuiltinInfos},
+ {&NEON::FP16::BuiltinStrings, NEON::FP16::BuiltinInfos},
+ {&BuiltinStrings, BuiltinInfos},
+ };
}
bool ARMTargetInfo::isCLZForZeroUndef() const { return false; }
diff --git a/clang/lib/Sema/SemaARM.cpp b/clang/lib/Sema/SemaARM.cpp
index 411baa066f7097..42b4b96872f37a 100644
--- a/clang/lib/Sema/SemaARM.cpp
+++ b/clang/lib/Sema/SemaARM.cpp
@@ -718,22 +718,18 @@ bool SemaARM::CheckNeonBuiltinFunctionCall(const TargetInfo &TI,
unsigned BuiltinID,
CallExpr *TheCall) {
if (const FunctionDecl *FD = SemaRef.getCurFunctionDecl()) {
+ std::optional<ArmStreamingType> BuiltinType;
switch (BuiltinID) {
default:
break;
-#define GET_NEON_BUILTINS
-#define TARGET_BUILTIN(id, ...) case NEON::BI##id:
-#define BUILTIN(id, ...) case NEON::BI##id:
+#define GET_NEON_STREAMING_COMPAT_FLAG
#include "clang/Basic/arm_neon.inc"
- if (checkArmStreamingBuiltin(SemaRef, TheCall, FD, ArmNonStreaming,
- BuiltinID))
- return true;
- break;
-#undef TARGET_BUILTIN
-#undef BUILTIN
-#undef GET_NEON_BUILTINS
+#undef GET_NEON_STREAMING_COMPAT_FLAG
}
+ if (BuiltinType &&
+ checkArmStreamingBuiltin(SemaRef, TheCall, FD, *BuiltinType, BuiltinID))
+ return true;
}
llvm::APSInt Result;
diff --git a/clang/utils/TableGen/NeonEmitter.cpp b/clang/utils/TableGen/NeonEmitter.cpp
index d7d649dd2456d5..e371fa9e8c8a0c 100644
--- a/clang/utils/TableGen/NeonEmitter.cpp
+++ b/clang/utils/TableGen/NeonEmitter.cpp
@@ -37,6 +37,7 @@
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/SetTheory.h"
+#include "llvm/TableGen/StringToOffsetTable.h"
#include <algorithm>
#include <cassert>
#include <cctype>
@@ -2056,40 +2057,56 @@ void NeonEmitter::createIntrinsic(const Record *R,
CurrentRecord = nullptr;
}
-/// genBuiltinsDef: Generate the BuiltinsARM.def and BuiltinsAArch64.def
-/// declaration of builtins, checking for unique builtin declarations.
+/// genBuiltinsDef: Generate the builtin infos, checking for unique builtin
+/// declarations.
void NeonEmitter::genBuiltinsDef(raw_ostream &OS,
SmallVectorImpl<Intrinsic *> &Defs) {
- OS << "#ifdef GET_NEON_BUILTINS\n";
+ // We only want to emit a builtin once, and in order of its name.
+ std::map<std::string, Intrinsic *> Builtins;
- // We only want to emit a builtin once, and we want to emit them in
- // alphabetical order, so use a std::set.
- std::set<std::pair<std::string, std::string>> Builtins;
+ llvm::StringToOffsetTable Table;
+ Table.GetOrAddStringOffset("");
+ Table.GetOrAddStringOffset("n");
+
+ auto PrefixName = [](Intrinsic *Def) -> std::string {
+ return (llvm::Twine("__builtin_neon_") + Def->getMangledName()).str();
+ };
for (auto *Def : Defs) {
if (Def->hasBody())
continue;
- std::string S = "__builtin_neon_" + Def->getMangledName() + ", \"";
- S += Def->getBuiltinTypeStr();
- S += "\", \"n\"";
-
- Builtins.emplace(S, Def->getTargetGuard());
+ if (Builtins.insert({Def->getMangledName(), Def}).second) {
+ Table.GetOrAddStringOffset(PrefixName(Def));
+ Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
+ Table.GetOrAddStringOffset(Def->getTargetGuard());
+ }
}
- for (auto &S : Builtins) {
- if (S.second == "")
- OS << "BUILTIN(";
- else
- OS << "TARGET_BUILTIN(";
- OS << S.first;
- if (S.second == "")
- OS << ")\n";
- else
- OS << ", \"" << S.second << "\")\n";
+ OS << "#ifdef GET_NEON_BUILTIN_ENUMERATORS\n";
+ for (const auto &[Name, Def] : Builtins) {
+ OS << " BI__builtin_neon_" << Name << ",\n";
}
+ OS << "#endif // GET_NEON_BUILTIN_ENUMERATORS\n\n";
- OS << "#endif\n\n";
+ OS << "#ifdef GET_NEON_BUILTIN_STR_TABLE\n";
+ Table.EmitStringLiteralDef(
+ OS, "static constexpr llvm::StringTable BuiltinStrings", "");
+ OS << "#endif // GET_NEON_BUILTIN_STR_TABLE\n\n";
+
+ OS << "#ifdef GET_NEON_BUILTIN_INFOS\n";
+ for (const auto &[Name, Def] : Builtins) {
+ OS << " Builtin::Info{Builtin::Info::StrOffsets{"
+ << Table.GetStringOffset(PrefixName(Def)) << " /* " << PrefixName(Def)
+ << " */, ";
+ OS << Table.GetStringOffset(Def->getBuiltinTypeStr()) << " /* "
+ << Def->getBuiltinTypeStr() << " */, ";
+ OS << Table.GetStringOffset("n") << " /* n */, ";
+ OS << Table.GetStringOffset(Def->getTargetGuard()) << " /* "
+ << Def->getTargetGuard() << " */}, ";
+ OS << "HeaderDesc::NO_HEADER, ALL_LANGUAGES},\n";
+ }
+ OS << "#endif // GET_NEON_BUILTIN_INFOS\n\n";
}
void NeonEmitter::genStreamingSVECompatibleList(
diff --git a/clang/utils/TableGen/SveEmitter.cpp b/clang/utils/TableGen/SveEmitter.cpp
index cf7e5a1ee3e008..c9cbbb73580c00 100644
--- a/clang/utils/TableGen/SveEmitter.cpp
+++ b/clang/utils/TableGen/SveEmitter.cpp
@@ -27,9 +27,11 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/AArch64ImmCheck.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/StringToOffsetTable.h"
#include <array>
#include <cctype>
#include <set>
@@ -198,7 +200,9 @@ class Intrinsic {
StringRef getSVEGuard() const { return SVEGuard; }
StringRef getSMEGuard() const { return SMEGuard; }
- void printGuard(raw_ostream &OS) const {
+ std::string getGuard() const {
+ std::string Guard;
+ llvm::raw_string_ostream OS(Guard);
if (!SVEGuard.empty() && SMEGuard.empty())
OS << SVEGuard;
else if (SVEGuard.empty() && !SMEGuard.empty())
@@ -216,6 +220,7 @@ class Intrinsic {
else
OS << SMEGuard;
}
+ return Guard;
}
ClassKind getClassKind() const { return Class; }
@@ -1471,19 +1476,23 @@ void SVEEmitter::createBuiltins(raw_ostream &OS) {
return A->getMangledName() < B->getMangledName();
});
- OS << "#ifdef GET_SVE_BUILTINS\n";
- for (auto &Def : Defs) {
- // Only create BUILTINs for non-overloaded intrinsics, as overloaded
- // declarations only live in the header file.
+ llvm::StringToOffsetTable Table;
+ Table.GetOrAddStringOffset("");
+ Table.GetOrAddStringOffset("n");
+
+ auto PrefixName = [](Intrinsic *Def) -> std::string {
+ return (llvm::Twine("__builtin_sve_") + Def->getMangledName()).str();
+ };
+
+ for (const auto &Def : Defs)
if (Def->getClassKind() != ClassG) {
- OS << "TARGET_BUILTIN(__builtin_sve_" << Def->getMangledName() << ", \""
- << Def->getBuiltinTypeStr() << "\", \"n\", \"";
- Def->printGuard(OS);
- OS << "\")\n";
+ Table.GetOrAddStringOffset(PrefixName(Def.get()));
+ Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
+ Table.GetOrAddStringOffset(Def->getGuard());
}
- }
- // Add reinterpret functions.
+ Table.GetOrAddStringOffset("sme|sve");
+ SmallVector<std::pair<std::string, std::string>> ReinterpretBuiltins;
for (auto [N, Suffix] :
std::initializer_list<std::pair<unsigned, const char *>>{
{1, ""}, {2, "_x2"}, {3, "_x3"}, {4, "_x4"}}) {
@@ -1491,14 +1500,55 @@ void SVEEmitter::createBuiltins(raw_ostream &OS) {
SVEType ToV(To.BaseType, N);
for (const ReinterpretTypeInfo &From : Reinterprets) {
SVEType FromV(From.BaseType, N);
- OS << "TARGET_BUILTIN(__builtin_sve_reinterpret_" << To.Suffix << "_"
- << From.Suffix << Suffix << +", \"" << ToV.builtin_str()
- << FromV.builtin_str() << "\", \"n\", \"sme|sve\")\n";
+ std::string Name = (Twine("__builtin_sve_reinterpret_") + To.Suffix +
+ "_" + From.Suffix + Suffix)
+ .str();
+ std::string Type = ToV.builtin_str() + FromV.builtin_str();
+ Table.GetOrAddStringOffset(Name);
+ Table.GetOrAddStringOffset(Type);
+ ReinterpretBuiltins.push_back({Name, Type});
}
}
}
- OS << "#endif\n\n";
+ OS << "#ifdef GET_SVE_BUILTIN_ENUMERATORS\n";
+ for (const auto &Def : Defs)
+ if (Def->getClassKind() != ClassG)
+ OS << " BI" << PrefixName(Def.get()) << ",\n";
+ for (const auto &[Name, _] : ReinterpretBuiltins)
+ OS << " BI" << Name << ",\n";
+ OS << "#endif // GET_SVE_BUILTIN_ENUMERATORS\n\n";
+
+ OS << "#ifdef GET_SVE_BUILTIN_STR_TABLE\n";
+ Table.EmitStringLiteralDef(
+ OS, "static constexpr llvm::StringTable BuiltinStrings", "");
+ OS << "#endif // GET_SVE_BUILTIN_STR_TABLE\n\n";
+
+ OS << "#ifdef GET_SVE_BUILTIN_INFOS\n";
+ for (const auto &Def : Defs) {
+ // Only create BUILTINs for non-overloaded intrinsics, as overloaded
+ // declarations only live in the header file.
+ if (Def->getClassKind() != ClassG) {
+ OS << " Builtin::Info{Builtin::Info::StrOffsets{"
+ << Table.GetStringOffset(PrefixName(Def.get())) << " /* "
+ << PrefixName(Def.get()) << " */, ";
+ OS << Table.GetStringOffset(Def->getBuiltinTypeStr()) << " /* "
+ << Def->getBuiltinTypeStr() << " */, ";
+ OS << Table.GetStringOffset("n") << " /* n */, ";
+ OS << Table.GetStringOffset(Def->getGuard()) << " /* " << Def->getGuard()
+ << " */}, ";
+ OS << "HeaderDesc::NO_HEADER, ALL_LANGUAGES},\n";
+ }
+ }
+ for (const auto &[Name, Type] : ReinterpretBuiltins) {
+ OS << " Builtin::Info{Builtin::Info::StrOffsets{"
+ << Table.GetStringOffset(Name) << " /* " << Name << " */, ";
+ OS << Table.GetStringOffset(Type) << " /* " << Type << " */, ";
+ OS << Table.GetStringOffset("n") << " /* n */, ";
+ OS << Table.GetStringOffset("sme|sve") << " /* sme|sve */}, ";
+ OS << "HeaderDesc::NO_HEADER, ALL_LANGUAGES},\n";
+ }
+ OS << "#endif // GET_SVE_BUILTIN_INFOS\n\n";
}
void SVEEmitter::createCodeGenMap(raw_ostream &OS) {
@@ -1678,19 +1728,49 @@ void SVEEmitter::createSMEBuiltins(raw_ostream &OS) {
return A->getMangledName() < B->getMangledName();
});
- OS << "#ifdef GET_SME_BUILTINS\n";
- for (auto &Def : Defs) {
+ llvm::StringToOffsetTable Table;
+ Table.GetOrAddStringOffset("");
+ Table.GetOrAddStringOffset("n");
+
+ auto PrefixName = [](Intrinsic *Def) -> std::string {
+ return (llvm::Twine("__builtin_sme_") + Def->getMangledName()).str();
+ };
+
+ for (const auto &Def : Defs)
+ if (Def->getClassKind() != ClassG) {
+ Table.GetOrAddStringOffset(PrefixName(Def.get()));
+ Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
+ Table.GetOrAddStringOffset(Def->getGuard());
+ }
+
+ OS << "#ifdef GET_SME_BUILTIN_ENUMERATORS\n";
+ for (const auto &Def : Defs)
+ if (Def->getClassKind() != ClassG)
+ OS << " BI" << PrefixName(Def.get()) << ",\n";
+ OS << "#endif // GET_SME_BUILTIN_ENUMERATORS\n\n";
+
+ OS << "#ifdef GET_SME_BUILTIN_STR_TABLE\n";
+ Table.EmitStringLiteralDef(
+ OS, "static constexpr llvm::StringTable BuiltinStrings", "");
+ OS << "#endif // GET_SME_BUILTIN_STR_TABLE\n\n";
+
+ OS << "#ifdef GET_SME_BUILTIN_INFOS\n";
+ for (const auto &Def : Defs) {
// Only create BUILTINs for non-overloaded intrinsics, as overloaded
// declarations only live in the header file.
if (Def->getClassKind() != ClassG) {
- OS << "TARGET_BUILTIN(__builtin_sme_" << Def->getMangledName() << ", \""
- << Def->getBuiltinTypeStr() << "\", \"n\", \"";
- Def->printGuard(OS);
- OS << "\")\n";
+ OS << " Builtin::Info{Builtin::Info::StrOffsets{"
+ << Table.GetStringOffset(PrefixName(Def.get())) << " /* "
+ << PrefixName(Def.get()) << " */, ";
+ OS << Table.GetStringOffset(Def->getBuiltinTypeStr()) << " /* "
+ << Def->getBuiltinTypeStr() << " */, ";
+ OS << Table.GetStringOffset("n") << " /* n */, ";
+ OS << Table.GetStringOffset(Def->getGuard()) << " /* " << Def->getGuard()
+ << " */}, ";
+ OS << "HeaderDesc::NO_HEADER, ALL_LANGUAGES},\n";
}
}
-
- OS << "#endif\n\n";
+ OS << "#endif // GET_SME_BUILTIN_INFOS\n\n";
}
void SVEEmitter::createSMECodeGenMap(raw_ostream &OS) {
>From 661cfc1957c297f886e7959f2b281c47e17d56df Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Sat, 21 Dec 2024 23:42:57 +0000
Subject: [PATCH 5/9] Remove the `CustomEntry` escape hatch from builtin
TableGen
This was an especially challenging escape hatch because it directly
forced the use of a specific X-macro structure and prevented any other
form of TableGen emission.
The problematic feature that motivated this is a case where a builtin's
prototype can't be represented in the mini-language used by TableGen.
Instead of adding a complete custom entry for this, this PR just teaches
the prototype handling to do the same thing the X-macros did in this
case: emit an empty string and let the Clang builtin handling respond
appropriately.
This should produce identical results while preserving all the rest of
the structured representation in the builtin TableGen code.
---
clang/include/clang/Basic/Builtins.td | 8 ++++---
clang/include/clang/Basic/BuiltinsBase.td | 13 +++++++----
clang/utils/TableGen/ClangBuiltinsEmitter.cpp | 22 ++++++++++++++-----
3 files changed, 31 insertions(+), 12 deletions(-)
diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td
index b5b47ae2746011..8c1d5e1c3e8ec6 100644
--- a/clang/include/clang/Basic/Builtins.td
+++ b/clang/include/clang/Basic/Builtins.td
@@ -3347,10 +3347,12 @@ def VFork : LibBuiltin<"unistd.h"> {
}
// POSIX pthread.h
-// FIXME: This should be a GNULibBuiltin, but it's currently missing the prototype.
-def PthreadCreate : CustomEntry {
- let Entry = "LIBBUILTIN(pthread_create, \"\", \"fC<2,3>\", PTHREAD_H, ALL_GNU_LANGUAGES)";
+def PthreadCreate : GNULibBuiltin<"pthread.h"> {
+ let Spellings = ["pthread_create"];
+ let Attributes = [FunctionWithoutBuiltinPrefix, Callback<[2, 3]>];
+ // Note that we don't have an expressable prototype so we leave it empty.
+ let Prototype = "";
}
def SigSetJmp : LibBuiltin<"setjmp.h"> {
diff --git a/clang/include/clang/Basic/BuiltinsBase.td b/clang/include/clang/Basic/BuiltinsBase.td
index 1a1096d41da40a..6180a94aa4b5c7 100644
--- a/clang/include/clang/Basic/BuiltinsBase.td
+++ b/clang/include/clang/Basic/BuiltinsBase.td
@@ -17,6 +17,11 @@ class IndexedAttribute<string baseMangling, int I> : Attribute<baseMangling> {
int Index = I;
}
+class MultiIndexAttribute<string baseMangling, list<int> Is>
+ : Attribute<baseMangling> {
+ list<int> Indices = Is;
+}
+
// Standard Attributes
// -------------------
def NoReturn : Attribute<"r">;
@@ -77,6 +82,10 @@ def Constexpr : Attribute<"E">;
// Builtin is immediate and must be constant evaluated. Implies Constexpr, and will only be supported in C++20 mode.
def Consteval : Attribute<"EG">;
+// Callback behavior: the first index argument is called with the arguments
+// indicated by the remaining indices.
+class Callback<list<int> ArgIndices> : MultiIndexAttribute<"C", ArgIndices>;
+
// Builtin kinds
// =============
@@ -92,10 +101,6 @@ class Builtin {
bit EnableOpenCLLong = 0;
}
-class CustomEntry {
- string Entry;
-}
-
class AtomicBuiltin : Builtin;
class LibBuiltin<string header, string languages = "ALL_LANGUAGES"> : Builtin {
diff --git a/clang/utils/TableGen/ClangBuiltinsEmitter.cpp b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
index 94cc2183760026..6aca4edfdfb888 100644
--- a/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
+++ b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
@@ -11,6 +11,7 @@
//===----------------------------------------------------------------------===//
#include "TableGenBackends.h"
+#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
@@ -39,6 +40,14 @@ class PrototypeParser {
private:
void ParsePrototype(StringRef Prototype) {
Prototype = Prototype.trim();
+
+ // Some builtins don't have an expressible prototype, simply emit an empty
+ // string for them.
+ if (Prototype.empty()) {
+ Type = "";
+ return;
+ }
+
ParseTypes(Prototype);
}
@@ -246,8 +255,15 @@ void PrintAttributes(const Record *Builtin, BuiltinType BT, raw_ostream &OS) {
for (const auto *Attr : Builtin->getValueAsListOfDefs("Attributes")) {
OS << Attr->getValueAsString("Mangling");
- if (Attr->isSubClassOf("IndexedAttribute"))
+ if (Attr->isSubClassOf("IndexedAttribute")) {
OS << ':' << Attr->getValueAsInt("Index") << ':';
+ } else if (Attr->isSubClassOf("MultiIndexAttribute")) {
+ OS << '<';
+ llvm::ListSeparator Sep(",");
+ for (int64_t Index : Attr->getValueAsListOfInts("Indices"))
+ OS << Sep << Index;
+ OS << '>';
+ }
}
OS << '\"';
}
@@ -405,10 +421,6 @@ void clang::EmitClangBuiltins(const RecordKeeper &Records, raw_ostream &OS) {
EmitBuiltin(OS, Builtin);
}
- for (const auto *Entry : Records.getAllDerivedDefinitions("CustomEntry")) {
- OS << Entry->getValueAsString("Entry") << '\n';
- }
-
OS << R"c++(
#undef ATOMIC_BUILTIN
#undef BUILTIN
>From f20a3fbce63dc9f793cd6669d8f2eda452c868d8 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Tue, 17 Dec 2024 19:21:27 +0000
Subject: [PATCH 6/9] Teach main builtin TableGen to use direct enums, strings,
and info
This moves the main builtins and several targets to use nice generated
string tables and info structures rather than X-macros. Even without
obvious prefixes to factor out, the resulting tables are significantly
smaller and much cheaper to compile with out all the X-macro overhead.
This leaves the X-macros in place for atomic builtins which have a wide
range of uses that don't seem reasonable to fold into TableGen.
As future work, these should move to their own file (whether as X-macros
or just generated patterns) so the AST headers don't have to include all
the data for other builtins.
---
clang/include/clang/AST/Expr.h | 2 -
clang/include/clang/Basic/Builtins.h | 17 +-
clang/include/clang/Basic/IdentifierTable.h | 3 +-
clang/include/clang/Basic/TargetBuiltins.h | 14 +-
clang/lib/AST/StmtPrinter.cpp | 1 -
clang/lib/Basic/Builtins.cpp | 26 +-
clang/lib/Basic/Targets/BPF.cpp | 14 +-
clang/lib/Basic/Targets/RISCV.cpp | 16 +-
clang/lib/Basic/Targets/X86.cpp | 51 ++-
clang/lib/Sema/SemaChecking.cpp | 1 -
.../target-builtins-prototype-parser.td | 16 +-
clang/utils/TableGen/ClangBuiltinsEmitter.cpp | 342 +++++++++++-------
12 files changed, 289 insertions(+), 214 deletions(-)
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index 708c8656decbe0..b1e969106f8c0a 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -6678,7 +6678,6 @@ class PseudoObjectExpr final
class AtomicExpr : public Expr {
public:
enum AtomicOp {
-#define BUILTIN(ID, TYPE, ATTRS)
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) AO ## ID,
#include "clang/Basic/Builtins.inc"
// Avoid trailing comma
@@ -6742,7 +6741,6 @@ class AtomicExpr : public Expr {
AtomicOp getOp() const { return Op; }
StringRef getOpAsString() const {
switch (Op) {
-#define BUILTIN(ID, TYPE, ATTRS)
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
case AO##ID: \
return #ID;
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
index a03442e8e29194..4bbb210d7b5246 100644
--- a/clang/include/clang/Basic/Builtins.h
+++ b/clang/include/clang/Basic/Builtins.h
@@ -64,9 +64,10 @@ struct HeaderDesc {
namespace Builtin {
enum ID {
- NotBuiltin = 0, // This is not a builtin function.
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+ NotBuiltin = 0, // This is not a builtin function.
+#define GET_BUILTIN_ENUMERATORS
#include "clang/Basic/Builtins.inc"
+#undef GET_BUILTIN_ENUMERATORS
FirstTSBuiltin
};
@@ -75,14 +76,14 @@ struct Info {
// Rather than store pointers to the string literals describing these four
// aspects of builtins, we store offsets into a common string table.
struct StrOffsets {
- llvm::StringTable::Offset Name;
- llvm::StringTable::Offset Type;
- llvm::StringTable::Offset Attributes;
- llvm::StringTable::Offset Features;
+ llvm::StringTable::Offset Name = 0;
+ llvm::StringTable::Offset Type = 0;
+ llvm::StringTable::Offset Attributes = 0;
+ llvm::StringTable::Offset Features = 0;
} Offsets;
- HeaderDesc Header;
- LanguageID Langs;
+ HeaderDesc Header = HeaderDesc::NO_HEADER;
+ LanguageID Langs = ALL_LANGUAGES;
};
/// A constexpr function to construct an infos array from X-macros.
diff --git a/clang/include/clang/Basic/IdentifierTable.h b/clang/include/clang/Basic/IdentifierTable.h
index 33d1cdb46f108b..512a2f0b842d78 100644
--- a/clang/include/clang/Basic/IdentifierTable.h
+++ b/clang/include/clang/Basic/IdentifierTable.h
@@ -101,8 +101,9 @@ enum class InterestingIdentifier {
NUM_OBJC_KEYWORDS_AND_NOTABLE_IDENTIFIERS,
NotBuiltin,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+#define GET_BUILTIN_ENUMERATORS
#include "clang/Basic/Builtins.inc"
+#undef GET_BUILTIN_ENUMERATORS
FirstTSBuiltin,
NotInterestingIdentifier = 65534
diff --git a/clang/include/clang/Basic/TargetBuiltins.h b/clang/include/clang/Basic/TargetBuiltins.h
index f066f902a18c02..b8b1338df690a1 100644
--- a/clang/include/clang/Basic/TargetBuiltins.h
+++ b/clang/include/clang/Basic/TargetBuiltins.h
@@ -93,8 +93,9 @@ namespace clang {
namespace BPF {
enum {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
- #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
- #include "clang/Basic/BuiltinsBPF.inc"
+#define GET_BUILTIN_ENUMERATORS
+#include "clang/Basic/BuiltinsBPF.inc"
+#undef GET_BUILTIN_ENUMERATORS
LastTSBuiltin
};
}
@@ -133,12 +134,14 @@ namespace clang {
namespace X86 {
enum {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+#define GET_BUILTIN_ENUMERATORS
#include "clang/Basic/BuiltinsX86.inc"
+#undef GET_BUILTIN_ENUMERATORS
FirstX86_64Builtin,
LastX86CommonBuiltin = FirstX86_64Builtin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+#define GET_BUILTIN_ENUMERATORS
#include "clang/Basic/BuiltinsX86_64.inc"
+#undef GET_BUILTIN_ENUMERATORS
LastTSBuiltin
};
}
@@ -172,8 +175,9 @@ namespace clang {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
FirstRVVBuiltin = clang::Builtin::FirstTSBuiltin,
LastRVVBuiltin = RISCVVector::FirstTSBuiltin - 1,
-#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
+#define GET_BUILTIN_ENUMERATORS
#include "clang/Basic/BuiltinsRISCV.inc"
+#undef GET_BUILTIN_ENUMERATORS
LastTSBuiltin
};
} // namespace RISCV
diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp
index c5d19f70fc6ea0..9a89a4dd0b0c84 100644
--- a/clang/lib/AST/StmtPrinter.cpp
+++ b/clang/lib/AST/StmtPrinter.cpp
@@ -1928,7 +1928,6 @@ void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
const char *Name = nullptr;
switch (Node->getOp()) {
-#define BUILTIN(ID, TYPE, ATTRS)
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
case AtomicExpr::AO ## ID: \
Name = #ID "("; \
diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
index 52375a3663f39e..16a83cd689db41 100644
--- a/clang/lib/Basic/Builtins.cpp
+++ b/clang/lib/Basic/Builtins.cpp
@@ -29,23 +29,19 @@ const char *HeaderDesc::getName() const {
llvm_unreachable("Unknown HeaderDesc::HeaderID enum");
}
-static constexpr llvm::StringTable BuiltinStrings =
- CLANG_BUILTIN_STR_TABLE_START
- // We inject a non-builtin string into the table.
- CLANG_BUILTIN_STR_TABLE("not a builtin function", "", "")
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
+static constexpr unsigned NumBuiltins = Builtin::FirstTSBuiltin;
+
+#define GET_BUILTIN_STR_TABLE
#include "clang/Basic/Builtins.inc"
- ;
-static_assert(BuiltinStrings.size() < 100'000);
-
-static constexpr auto BuiltinInfos =
- Builtin::MakeInfos<Builtin::FirstTSBuiltin>(
- {CLANG_BUILTIN_ENTRY("not a builtin function", "", "")
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY
-#define LIBBUILTIN CLANG_LIBBUILTIN_ENTRY
+#undef GET_BUILTIN_STR_TABLE
+
+static constexpr Builtin::Info BuiltinInfos[] = {
+ Builtin::Info{}, // No-builtin info entry.
+#define GET_BUILTIN_INFOS
#include "clang/Basic/Builtins.inc"
- });
+#undef GET_BUILTIN_INFOS
+};
+static_assert(std::size(BuiltinInfos) == NumBuiltins);
std::pair<const Builtin::InfosShard &, const Builtin::Info &>
Builtin::Context::getShardAndInfo(unsigned ID) const {
diff --git a/clang/lib/Basic/Targets/BPF.cpp b/clang/lib/Basic/Targets/BPF.cpp
index b4504faa4d5eeb..a463de08840201 100644
--- a/clang/lib/Basic/Targets/BPF.cpp
+++ b/clang/lib/Basic/Targets/BPF.cpp
@@ -22,16 +22,16 @@ using namespace clang::targets;
static constexpr int NumBuiltins =
clang::BPF::LastTSBuiltin - Builtin::FirstTSBuiltin;
-static constexpr llvm::StringTable BuiltinStrings =
- CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
+#define GET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsBPF.inc"
- ;
+#undef GET_BUILTIN_STR_TABLE
-static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
+static constexpr Builtin::Info BuiltinInfos[] = {
+#define GET_BUILTIN_INFOS
#include "clang/Basic/BuiltinsBPF.inc"
-});
+#undef GET_BUILTIN_INFOS
+};
+static_assert(std::size(BuiltinInfos) == NumBuiltins);
void BPFTargetInfo::getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const {
diff --git a/clang/lib/Basic/Targets/RISCV.cpp b/clang/lib/Basic/Targets/RISCV.cpp
index 0e78471d6f4d7b..079ddc3c5d6e13 100644
--- a/clang/lib/Basic/Targets/RISCV.cpp
+++ b/clang/lib/Basic/Targets/RISCV.cpp
@@ -277,18 +277,16 @@ static constexpr std::array<Builtin::Info, NumRVVSiFiveBuiltins> BuiltinInfos =
};
} // namespace RVVSiFive
-static constexpr llvm::StringTable BuiltinStrings =
- CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
+#define GET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsRISCV.inc"
- ;
+#undef GET_BUILTIN_STR_TABLE
-static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumRISCVBuiltins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
+static constexpr Builtin::Info BuiltinInfos[] = {
+#define GET_BUILTIN_INFOS
#include "clang/Basic/BuiltinsRISCV.inc"
-});
+#undef GET_BUILTIN_INFOS
+};
+static_assert(std::size(BuiltinInfos) == NumRISCVBuiltins);
llvm::SmallVector<Builtin::InfosShard>
RISCVTargetInfo::getTargetBuiltins() const {
diff --git a/clang/lib/Basic/Targets/X86.cpp b/clang/lib/Basic/Targets/X86.cpp
index 9999487c385c50..dacadec27e1ea0 100644
--- a/clang/lib/Basic/Targets/X86.cpp
+++ b/clang/lib/Basic/Targets/X86.cpp
@@ -31,36 +31,31 @@ static constexpr int NumX86_64Builtins =
static constexpr int NumBuiltins = X86::LastTSBuiltin - Builtin::FirstTSBuiltin;
static_assert(NumBuiltins == (NumX86Builtins + NumX86_64Builtins));
-static constexpr llvm::StringTable BuiltinX86Strings =
- CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
+namespace X86 {
+#define GET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsX86.inc"
- ;
+#undef GET_BUILTIN_STR_TABLE
-static constexpr llvm::StringTable BuiltinX86_64Strings =
- CLANG_BUILTIN_STR_TABLE_START
-#define BUILTIN CLANG_BUILTIN_STR_TABLE
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
-#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
-#include "clang/Basic/BuiltinsX86_64.inc"
- ;
-
-static constexpr auto BuiltinX86Infos = Builtin::MakeInfos<NumX86Builtins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
+static constexpr Builtin::Info BuiltinInfos[] = {
+#define GET_BUILTIN_INFOS
#include "clang/Basic/BuiltinsX86.inc"
-});
+#undef GET_BUILTIN_INFOS
+};
+static_assert(std::size(BuiltinInfos) == NumX86Builtins);
+} // namespace X86
-static constexpr auto BuiltinX86_64Infos =
- Builtin::MakeInfos<NumX86_64Builtins>({
-#define BUILTIN CLANG_BUILTIN_ENTRY
-#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
-#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
+namespace X86_64 {
+#define GET_BUILTIN_STR_TABLE
#include "clang/Basic/BuiltinsX86_64.inc"
- });
+#undef GET_BUILTIN_STR_TABLE
+
+static constexpr Builtin::Info BuiltinInfos[] = {
+#define GET_BUILTIN_INFOS
+#include "clang/Basic/BuiltinsX86_64.inc"
+#undef GET_BUILTIN_INFOS
+};
+static_assert(std::size(BuiltinInfos) == NumX86_64Builtins);
+} // namespace X86_64
static const char *const GCCRegNames[] = {
"ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
@@ -1879,13 +1874,13 @@ ArrayRef<TargetInfo::AddlRegName> X86TargetInfo::getGCCAddlRegNames() const {
llvm::SmallVector<Builtin::InfosShard>
X86_32TargetInfo::getTargetBuiltins() const {
- return {{&BuiltinX86Strings, BuiltinX86Infos}};
+ return {{&X86::BuiltinStrings, X86::BuiltinInfos}};
}
llvm::SmallVector<Builtin::InfosShard>
X86_64TargetInfo::getTargetBuiltins() const {
return {
- {&BuiltinX86Strings, BuiltinX86Infos},
- {&BuiltinX86_64Strings, BuiltinX86_64Infos},
+ {&X86::BuiltinStrings, X86::BuiltinInfos},
+ {&X86_64::BuiltinStrings, X86_64::BuiltinInfos},
};
}
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index ce846ae88c38b4..cb79a224018faa 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -2446,7 +2446,6 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
break;
}
-#define BUILTIN(ID, TYPE, ATTRS)
#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
case Builtin::BI##ID: \
return AtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
diff --git a/clang/test/TableGen/target-builtins-prototype-parser.td b/clang/test/TableGen/target-builtins-prototype-parser.td
index 555aebb3ccfb1f..cbc15c3dba6c7c 100644
--- a/clang/test/TableGen/target-builtins-prototype-parser.td
+++ b/clang/test/TableGen/target-builtins-prototype-parser.td
@@ -10,49 +10,49 @@
include "clang/Basic/BuiltinsBase.td"
def : Builtin {
-// CHECK: BUILTIN(__builtin_01, "E8idE4b", "")
+// CHECK: Builtin::Info{{.*}} __builtin_01 {{.*}} /* E8idE4b */
let Prototype = "_ExtVector<8,int>(double, _ExtVector<4, bool>)";
let Spellings = ["__builtin_01"];
}
def : Builtin {
-// CHECK: BUILTIN(__builtin_02, "E8UiE4s", "")
+// CHECK: Builtin::Info{{.*}} __builtin_02 {{.*}} /* E8UiE4s */
let Prototype = "_ExtVector<8,unsigned int>(_ExtVector<4, short>)";
let Spellings = ["__builtin_02"];
}
def : Builtin {
-// CHECK: BUILTIN(__builtin_03, "di", "")
+// CHECK: Builtin::Info{{.*}} __builtin_03 {{.*}} /* di */
let Prototype = "double(int)";
let Spellings = ["__builtin_03"];
}
def : Builtin {
-// CHECK: BUILTIN(__builtin_04, "diIUi", "")
+// CHECK: Builtin::Info{{.*}} __builtin_04 {{.*}} /* diIUi */
let Prototype = "double(int, _Constant unsigned int)";
let Spellings = ["__builtin_04"];
}
def : Builtin {
-// CHECK: BUILTIN(__builtin_05, "v&v&", "")
+// CHECK: Builtin::Info{{.*}} __builtin_05 {{.*}} /* v&v& */
let Prototype = "void&(void&)";
let Spellings = ["__builtin_05"];
}
def : Builtin {
-// CHECK: BUILTIN(__builtin_06, "v*v*cC*.", "")
+// CHECK: Builtin::Info{{.*}} __builtin_06 {{.*}} /* v*v*cC*. */
let Prototype = "void*(void*, char const*, ...)";
let Spellings = ["__builtin_06"];
}
def : Builtin {
-// CHECK: BUILTIN(__builtin_07, "E8iE4dE4b.", "")
+// CHECK: Builtin::Info{{.*}} __builtin_07 {{.*}} /* E8iE4dE4b. */
let Prototype = "_ExtVector<8, int>(_ExtVector<4,double>, _ExtVector<4, bool>, ...)";
let Spellings = ["__builtin_07"];
}
def : Builtin {
-// CHECK: BUILTIN(__builtin_08, "di*R", "")
+// CHECK: Builtin::Info{{.*}} __builtin_08 {{.*}} /* di*R */
let Prototype = "double(int * restrict)";
let Spellings = ["__builtin_08"];
}
diff --git a/clang/utils/TableGen/ClangBuiltinsEmitter.cpp b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
index 6aca4edfdfb888..acdfffb534cb29 100644
--- a/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
+++ b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
@@ -15,7 +15,9 @@
#include "llvm/ADT/StringSwitch.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/StringToOffsetTable.h"
#include "llvm/TableGen/TableGenBackend.h"
+#include <sstream>
using namespace llvm;
@@ -29,6 +31,119 @@ enum class BuiltinType {
TargetLibBuiltin,
};
+class HeaderNameParser {
+public:
+ HeaderNameParser(const Record *Builtin) {
+ for (char c : Builtin->getValueAsString("Header")) {
+ if (std::islower(c))
+ HeaderName += static_cast<char>(std::toupper(c));
+ else if (c == '.' || c == '_' || c == '/' || c == '-')
+ HeaderName += '_';
+ else
+ PrintFatalError(Builtin->getLoc(), "Unexpected header name");
+ }
+ }
+
+ void Print(raw_ostream &OS) const { OS << HeaderName; }
+
+private:
+ std::string HeaderName;
+};
+
+struct Builtin {
+ BuiltinType BT;
+ std::string Name;
+ std::string Type;
+ std::string Attributes;
+
+ const Record *BuiltinRecord;
+
+ void EmitEnumerator(llvm::raw_ostream &OS) const {
+ OS << " BI" << Name << ",\n";
+ }
+
+ void EmitInfo(llvm::raw_ostream &OS, const StringToOffsetTable &Table) const {
+ OS << " Builtin::Info{Builtin::Info::StrOffsets{"
+ << Table.GetStringOffset(Name) << " /* " << Name << " */, "
+ << Table.GetStringOffset(Type) << " /* " << Type << " */, "
+ << Table.GetStringOffset(Attributes) << " /* " << Attributes << " */, ";
+ if (BT == BuiltinType::TargetBuiltin) {
+ const auto &Features = BuiltinRecord->getValueAsString("Features");
+ OS << Table.GetStringOffset(Features) << " /* " << Features << " */";
+ } else {
+ OS << "0";
+ }
+ OS << "}, ";
+ if (BT == BuiltinType::LibBuiltin || BT == BuiltinType::TargetLibBuiltin) {
+ OS << "HeaderDesc::";
+ HeaderNameParser{BuiltinRecord}.Print(OS);
+ } else {
+ OS << "HeaderDesc::NO_HEADER";
+ }
+ OS << ", ";
+ if (BT == BuiltinType::LibBuiltin || BT == BuiltinType::LangBuiltin ||
+ BT == BuiltinType::TargetLibBuiltin) {
+ OS << BuiltinRecord->getValueAsString("Languages");
+ } else {
+ OS << "ALL_LANGUAGES";
+ }
+ OS << "},\n";
+ }
+
+ void EmitXMacro(llvm::raw_ostream &OS) const {
+ if (BuiltinRecord->getValueAsBit("RequiresUndef"))
+ OS << "#undef " << Name << '\n';
+ switch (BT) {
+ case BuiltinType::LibBuiltin:
+ OS << "LIBBUILTIN";
+ break;
+ case BuiltinType::LangBuiltin:
+ OS << "LANGBUILTIN";
+ break;
+ case BuiltinType::Builtin:
+ OS << "BUILTIN";
+ break;
+ case BuiltinType::AtomicBuiltin:
+ OS << "ATOMIC_BUILTIN";
+ break;
+ case BuiltinType::TargetBuiltin:
+ OS << "TARGET_BUILTIN";
+ break;
+ case BuiltinType::TargetLibBuiltin:
+ OS << "TARGET_HEADER_BUILTIN";
+ break;
+ }
+
+ OS << "(" << Name << ", \"" << Type << "\", \"" << Attributes << "\"";
+
+ switch (BT) {
+ case BuiltinType::LibBuiltin: {
+ OS << ", ";
+ HeaderNameParser{BuiltinRecord}.Print(OS);
+ [[fallthrough]];
+ }
+ case BuiltinType::LangBuiltin: {
+ OS << ", " << BuiltinRecord->getValueAsString("Languages");
+ break;
+ }
+ case BuiltinType::TargetLibBuiltin: {
+ OS << ", ";
+ HeaderNameParser{BuiltinRecord}.Print(OS);
+ OS << ", " << BuiltinRecord->getValueAsString("Languages");
+ [[fallthrough]];
+ }
+ case BuiltinType::TargetBuiltin: {
+ OS << ", \"" << BuiltinRecord->getValueAsString("Features") << "\"";
+ break;
+ }
+ case BuiltinType::AtomicBuiltin:
+ case BuiltinType::Builtin:
+ break;
+ }
+ OS << ")\n";
+ }
+};
+
class PrototypeParser {
public:
PrototypeParser(StringRef Substitution, const Record *Builtin)
@@ -37,6 +152,8 @@ class PrototypeParser {
ParsePrototype(Builtin->getValueAsString("Prototype"));
}
+ std::string takeTypeString() && { return std::move(Type); }
+
private:
void ParsePrototype(StringRef Prototype) {
Prototype = Prototype.trim();
@@ -206,37 +323,15 @@ class PrototypeParser {
}
}
-public:
- void Print(raw_ostream &OS) const { OS << ", \"" << Type << '\"'; }
-
-private:
SMLoc Loc;
StringRef Substitution;
bool EnableOpenCLLong;
std::string Type;
};
-class HeaderNameParser {
-public:
- HeaderNameParser(const Record *Builtin) {
- for (char c : Builtin->getValueAsString("Header")) {
- if (std::islower(c))
- HeaderName += static_cast<char>(std::toupper(c));
- else if (c == '.' || c == '_' || c == '/' || c == '-')
- HeaderName += '_';
- else
- PrintFatalError(Builtin->getLoc(), "Unexpected header name");
- }
- }
-
- void Print(raw_ostream &OS) const { OS << HeaderName; }
-
-private:
- std::string HeaderName;
-};
-
-void PrintAttributes(const Record *Builtin, BuiltinType BT, raw_ostream &OS) {
- OS << '\"';
+std::string renderAttributes(const Record *Builtin, BuiltinType BT) {
+ std::string Attributes;
+ raw_string_ostream OS(Attributes);
if (Builtin->isSubClassOf("LibBuiltin")) {
if (BT == BuiltinType::LibBuiltin) {
OS << 'f';
@@ -265,63 +360,18 @@ void PrintAttributes(const Record *Builtin, BuiltinType BT, raw_ostream &OS) {
OS << '>';
}
}
- OS << '\"';
+ return Attributes;
}
-void EmitBuiltinDef(raw_ostream &OS, StringRef Substitution,
- const Record *Builtin, Twine Spelling, BuiltinType BT) {
- if (Builtin->getValueAsBit("RequiresUndef"))
- OS << "#undef " << Spelling << '\n';
- switch (BT) {
- case BuiltinType::LibBuiltin:
- OS << "LIBBUILTIN";
- break;
- case BuiltinType::LangBuiltin:
- OS << "LANGBUILTIN";
- break;
- case BuiltinType::Builtin:
- OS << "BUILTIN";
- break;
- case BuiltinType::AtomicBuiltin:
- OS << "ATOMIC_BUILTIN";
- break;
- case BuiltinType::TargetBuiltin:
- OS << "TARGET_BUILTIN";
- break;
- case BuiltinType::TargetLibBuiltin:
- OS << "TARGET_HEADER_BUILTIN";
- break;
- }
-
- OS << "(" << Spelling;
- PrototypeParser{Substitution, Builtin}.Print(OS);
- OS << ", ";
- PrintAttributes(Builtin, BT, OS);
-
- switch (BT) {
- case BuiltinType::LibBuiltin: {
- OS << ", ";
- HeaderNameParser{Builtin}.Print(OS);
- [[fallthrough]];
- }
- case BuiltinType::LangBuiltin: {
- OS << ", " << Builtin->getValueAsString("Languages");
- break;
- }
- case BuiltinType::TargetLibBuiltin: {
- OS << ", ";
- HeaderNameParser{Builtin}.Print(OS);
- OS << ", " << Builtin->getValueAsString("Languages");
- [[fallthrough]];
- }
- case BuiltinType::TargetBuiltin:
- OS << ", \"" << Builtin->getValueAsString("Features") << "\"";
- break;
- case BuiltinType::AtomicBuiltin:
- case BuiltinType::Builtin:
- break;
- }
- OS << ")\n";
+Builtin buildBuiltin(StringRef Substitution, const Record *BuiltinRecord,
+ Twine Spelling, BuiltinType BT) {
+ Builtin B;
+ B.BT = BT;
+ B.Name = Spelling.str();
+ B.Type = PrototypeParser(Substitution, BuiltinRecord).takeTypeString();
+ B.Attributes = renderAttributes(BuiltinRecord, BT);
+ B.BuiltinRecord = BuiltinRecord;
+ return B;
}
struct TemplateInsts {
@@ -347,10 +397,11 @@ TemplateInsts getTemplateInsts(const Record *R) {
return temp;
}
-void EmitBuiltin(raw_ostream &OS, const Record *Builtin) {
+void collectBuiltins(const Record *BuiltinRecord,
+ SmallVectorImpl<Builtin> &Builtins) {
TemplateInsts Templates = {};
- if (Builtin->isSubClassOf("Template")) {
- Templates = getTemplateInsts(Builtin);
+ if (BuiltinRecord->isSubClassOf("Template")) {
+ Templates = getTemplateInsts(BuiltinRecord);
} else {
Templates.Affix.emplace_back();
Templates.Substitution.emplace_back();
@@ -358,26 +409,28 @@ void EmitBuiltin(raw_ostream &OS, const Record *Builtin) {
for (auto [Substitution, Affix] :
zip(Templates.Substitution, Templates.Affix)) {
- for (StringRef Spelling : Builtin->getValueAsListOfStrings("Spellings")) {
+ for (StringRef Spelling :
+ BuiltinRecord->getValueAsListOfStrings("Spellings")) {
auto FullSpelling =
(Templates.IsPrefix ? Affix + Spelling : Spelling + Affix).str();
BuiltinType BT = BuiltinType::Builtin;
- if (Builtin->isSubClassOf("AtomicBuiltin")) {
+ if (BuiltinRecord->isSubClassOf("AtomicBuiltin")) {
BT = BuiltinType::AtomicBuiltin;
- } else if (Builtin->isSubClassOf("LangBuiltin")) {
+ } else if (BuiltinRecord->isSubClassOf("LangBuiltin")) {
BT = BuiltinType::LangBuiltin;
- } else if (Builtin->isSubClassOf("TargetLibBuiltin")) {
+ } else if (BuiltinRecord->isSubClassOf("TargetLibBuiltin")) {
BT = BuiltinType::TargetLibBuiltin;
- } else if (Builtin->isSubClassOf("TargetBuiltin")) {
+ } else if (BuiltinRecord->isSubClassOf("TargetBuiltin")) {
BT = BuiltinType::TargetBuiltin;
- } else if (Builtin->isSubClassOf("LibBuiltin")) {
+ } else if (BuiltinRecord->isSubClassOf("LibBuiltin")) {
BT = BuiltinType::LibBuiltin;
- if (Builtin->getValueAsBit("AddBuiltinPrefixedAlias"))
- EmitBuiltinDef(OS, Substitution, Builtin,
- std::string("__builtin_") + FullSpelling,
- BuiltinType::Builtin);
+ if (BuiltinRecord->getValueAsBit("AddBuiltinPrefixedAlias"))
+ Builtins.push_back(buildBuiltin(
+ Substitution, BuiltinRecord,
+ std::string("__builtin_") + FullSpelling, BuiltinType::Builtin));
}
- EmitBuiltinDef(OS, Substitution, Builtin, FullSpelling, BT);
+ Builtins.push_back(
+ buildBuiltin(Substitution, BuiltinRecord, FullSpelling, BT));
}
}
}
@@ -386,47 +439,78 @@ void EmitBuiltin(raw_ostream &OS, const Record *Builtin) {
void clang::EmitClangBuiltins(const RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("List of builtins that Clang recognizes", OS);
- OS << R"c++(
-#if defined(BUILTIN) && !defined(LIBBUILTIN)
-# define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-#if defined(BUILTIN) && !defined(LANGBUILTIN)
-# define LANGBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-// Some of our atomics builtins are handled by AtomicExpr rather than
-// as normal builtin CallExprs. This macro is used for such builtins.
-#ifndef ATOMIC_BUILTIN
-# define ATOMIC_BUILTIN(ID, TYPE, ATTRS) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-#if defined(BUILTIN) && !defined(TARGET_BUILTIN)
-# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS)
-#endif
-
-#if defined(BUILTIN) && !defined(TARGET_HEADER_BUILTIN)
-# define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANG, FEATURE) BUILTIN(ID, TYPE, ATTRS)
-#endif
-)c++";
+ SmallVector<Builtin> Builtins;
+ // AtomicBuiltins are order dependent. Emit them first to make manual checking
+ // easier and so we can build a special atomic builtin X-macro.
+ for (const auto *BuiltinRecord :
+ Records.getAllDerivedDefinitions("AtomicBuiltin"))
+ collectBuiltins(BuiltinRecord, Builtins);
- // AtomicBuiltins are order dependent
- // emit them first to make manual checking easier
- for (const auto *Builtin : Records.getAllDerivedDefinitions("AtomicBuiltin"))
- EmitBuiltin(OS, Builtin);
+ unsigned NumAtomicBuiltins = Builtins.size();
- for (const auto *Builtin : Records.getAllDerivedDefinitions("Builtin")) {
- if (Builtin->isSubClassOf("AtomicBuiltin"))
+ for (const auto *BuiltinRecord :
+ Records.getAllDerivedDefinitions("Builtin")) {
+ if (BuiltinRecord->isSubClassOf("AtomicBuiltin"))
continue;
- EmitBuiltin(OS, Builtin);
+ collectBuiltins(BuiltinRecord, Builtins);
+ }
+
+ auto AtomicBuiltins = ArrayRef(Builtins).slice(0, NumAtomicBuiltins);
+
+ // Collect strings into a table.
+ StringToOffsetTable Table;
+ Table.GetOrAddStringOffset("");
+ for (const auto &B : Builtins) {
+ Table.GetOrAddStringOffset(B.Name);
+ Table.GetOrAddStringOffset(B.Type);
+ Table.GetOrAddStringOffset(B.Attributes);
+ if (B.BT == BuiltinType::TargetBuiltin)
+ Table.GetOrAddStringOffset(B.BuiltinRecord->getValueAsString("Features"));
}
+ // Emit enumerators.
+ OS << R"c++(
+#ifdef GET_BUILTIN_ENUMERATORS
+)c++";
+ for (const auto &B : Builtins)
+ B.EmitEnumerator(OS);
+ OS << R"c++(
+#endif // GET_BUILTIN_ENUMERATORS
+)c++";
+
+ // Emit a string table that can be referenced for these builtins.
+ OS << R"c++(
+#ifdef GET_BUILTIN_STR_TABLE
+)c++";
+ Table.EmitStringLiteralDef(
+ OS, "static constexpr llvm::StringTable BuiltinStrings", /*Indent=*/"");
+ OS << R"c++(
+#endif // GET_BUILTIN_STR_TABLE
+)c++";
+
+ // Emit a direct set of `Builtin::Info` initializers.
+ OS << R"c++(
+#ifdef GET_BUILTIN_INFOS
+)c++";
+ for (const auto &B : Builtins)
+ B.EmitInfo(OS, Table);
+ OS << R"c++(
+#endif // GET_BUILTIN_INFOS
+)c++";
+
+ // Emit X-macros for the atomic builtins to support various custome patterns
+ // used exclusively with those builtins.
+ //
+ // FIXME: We should eventually move this to a separate file so that users
+ // don't need to include the full set of builtins.
+ OS << R"c++(
+#ifdef ATOMIC_BUILTIN
+)c++";
+ for (const auto &Builtin : AtomicBuiltins) {
+ Builtin.EmitXMacro(OS);
+ }
OS << R"c++(
+#endif // ATOMIC_BUILTIN
#undef ATOMIC_BUILTIN
-#undef BUILTIN
-#undef LIBBUILTIN
-#undef LANGBUILTIN
-#undef TARGET_BUILTIN
-#undef TARGET_HEADER_BUILTIN
)c++";
}
>From a0e36f0c3126a49dd4681718a006b7261b7d4bb2 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Wed, 18 Dec 2024 07:11:02 +0000
Subject: [PATCH 7/9] Switch Neon, SVE, SME, and RVV builtins to use a prefix
This avoids repeating this part of the name in every string, shrinking
the string tables. For SVE in particular, which is by-far the largest
builtin string table, this gets us well under 200KiB. Others shrink by
30% - 50% depending on how long the rest of the strings end up.
Overall, this completes restructuring the builtin string tables to try
and minimize their size and hopefully avoid both toolchain bugs and
compile-time memory overheads of the full sized string tables.
---
clang/include/clang/Basic/Builtins.h | 14 ++++++-
clang/lib/Basic/Builtins.cpp | 39 ++++++++++++-------
clang/lib/Basic/Targets/AArch64.cpp | 9 +++--
clang/lib/Basic/Targets/ARM.cpp | 5 ++-
clang/lib/Basic/Targets/RISCV.cpp | 5 +--
clang/lib/CodeGen/CGBuiltin.cpp | 10 +++--
clang/lib/CodeGen/CodeGenModule.cpp | 3 +-
clang/lib/Sema/SemaChecking.cpp | 16 ++++----
clang/lib/Sema/SemaExpr.cpp | 2 +-
.../StaticAnalyzer/Core/CheckerContext.cpp | 2 +-
clang/utils/TableGen/NeonEmitter.cpp | 10 ++---
clang/utils/TableGen/RISCVVEmitter.cpp | 10 ++---
clang/utils/TableGen/SveEmitter.cpp | 32 ++++++---------
13 files changed, 83 insertions(+), 74 deletions(-)
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
index 4bbb210d7b5246..5ebe4c03fadccd 100644
--- a/clang/include/clang/Basic/Builtins.h
+++ b/clang/include/clang/Basic/Builtins.h
@@ -71,6 +71,8 @@ enum ID {
FirstTSBuiltin
};
+struct InfosShard;
+
/// The info used to represent each builtin.
struct Info {
// Rather than store pointers to the string literals describing these four
@@ -84,6 +86,11 @@ struct Info {
HeaderDesc Header = HeaderDesc::NO_HEADER;
LanguageID Langs = ALL_LANGUAGES;
+
+ /// Get the name for the builtin represented by this `Info` object.
+ ///
+ /// Must be provided the `Shard` for this `Info` object.
+ std::string getName(const InfosShard &Shard) const;
};
/// A constexpr function to construct an infos array from X-macros.
@@ -121,6 +128,8 @@ static constexpr std::array<Info, N> MakeInfos(std::array<Info, N> Infos) {
struct InfosShard {
const llvm::StringTable *Strings;
llvm::ArrayRef<Info> Infos;
+
+ llvm::StringLiteral NamePrefix = "";
};
// A detail macro used below to emit a string literal that, after string literal
@@ -236,9 +245,10 @@ class Context {
/// Return the identifier name for the specified builtin,
/// e.g. "__builtin_abs".
- llvm::StringRef getName(unsigned ID) const;
+ std::string getName(unsigned ID) const;
- /// Return a quoted name for the specified builtin for use in diagnostics.
+ /// Return the identifier name for the specified builtin inside single quotes
+ /// for a diagnostic, e.g. "'__builtin_abs'".
std::string getQuotedName(unsigned ID) const;
/// Get the type descriptor string for the specified builtin.
diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
index 16a83cd689db41..e7829a461bbc53 100644
--- a/clang/lib/Basic/Builtins.cpp
+++ b/clang/lib/Basic/Builtins.cpp
@@ -71,11 +71,22 @@ Builtin::Context::getShardAndInfo(unsigned ID) const {
llvm_unreachable("Invalid target builtin shard structure!");
}
+std::string Builtin::Info::getName(const Builtin::InfosShard &Shard) const {
+ return (Twine(Shard.NamePrefix) + (*Shard.Strings)[Offsets.Name]).str();
+}
+
/// Return the identifier name for the specified builtin,
/// e.g. "__builtin_abs".
-llvm::StringRef Builtin::Context::getName(unsigned ID) const {
+std::string Builtin::Context::getName(unsigned ID) const {
const auto &[Shard, I] = getShardAndInfo(ID);
- return (*Shard.Strings)[I.Offsets.Name];
+ return I.getName(Shard);
+}
+
+std::string Builtin::Context::getQuotedName(unsigned ID) const {
+ const auto &[Shard, I] = getShardAndInfo(ID);
+ return (Twine("'") + Shard.NamePrefix + (*Shard.Strings)[I.Offsets.Name] +
+ "'")
+ .str();
}
const char *Builtin::Context::getTypeString(unsigned ID) const {
@@ -112,12 +123,14 @@ void Builtin::Context::InitializeTarget(const TargetInfo &Target,
bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
bool InStdNamespace = FuncName.consume_front("std-");
for (const auto &Shard : {InfosShard{&BuiltinStrings, BuiltinInfos}})
- for (const auto &I : Shard.Infos)
- if (FuncName == (*Shard.Strings)[I.Offsets.Name] &&
- (bool)strchr((*Shard.Strings)[I.Offsets.Attributes].data(), 'z') ==
- InStdNamespace)
- return strchr((*Shard.Strings)[I.Offsets.Attributes].data(), 'f') !=
- nullptr;
+ if (llvm::StringRef FuncNameSuffix = FuncName;
+ FuncNameSuffix.consume_front(Shard.NamePrefix))
+ for (const auto &I : Shard.Infos)
+ if (FuncNameSuffix == (*Shard.Strings)[I.Offsets.Name] &&
+ (bool)strchr((*Shard.Strings)[I.Offsets.Attributes].data(), 'z') ==
+ InStdNamespace)
+ return strchr((*Shard.Strings)[I.Offsets.Attributes].data(), 'f') !=
+ nullptr;
return false;
}
@@ -193,7 +206,7 @@ void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
for (const auto &I : Shard.Infos) {
// If this is a real builtin (ID != 0) and is supported, add it.
if (ID != 0 && builtinIsSupported(*Shard.Strings, I, LangOpts))
- Table.get((*Shard.Strings)[I.Offsets.Name]).setBuiltinID(ID);
+ Table.get(I.getName(Shard)).setBuiltinID(ID);
++ID;
}
assert(ID == FirstTSBuiltin && "Should have added all non-target IDs!");
@@ -202,14 +215,14 @@ void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
for (const auto &Shard : TargetShards)
for (const auto &I : Shard.Infos) {
if (builtinIsSupported(*Shard.Strings, I, LangOpts))
- Table.get((*Shard.Strings)[I.Offsets.Name]).setBuiltinID(ID);
+ Table.get(I.getName(Shard)).setBuiltinID(ID);
++ID;
}
// Step #3: Register target-specific builtins for AuxTarget.
for (const auto &Shard : AuxTargetShards)
for (const auto &I : Shard.Infos) {
- Table.get((*Shard.Strings)[I.Offsets.Name]).setBuiltinID(ID);
+ Table.get(I.getName(Shard)).setBuiltinID(ID);
++ID;
}
}
@@ -228,10 +241,6 @@ void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
}
}
-std::string Builtin::Context::getQuotedName(unsigned ID) const {
- return (llvm::Twine("'") + getName(ID) + "'").str();
-}
-
unsigned Builtin::Context::getRequiredVectorWidth(unsigned ID) const {
const char *WidthPos = ::strchr(getAttributesString(ID), 'V');
if (!WidthPos)
diff --git a/clang/lib/Basic/Targets/AArch64.cpp b/clang/lib/Basic/Targets/AArch64.cpp
index a23cdc5734e49d..c1220ea47de1fd 100644
--- a/clang/lib/Basic/Targets/AArch64.cpp
+++ b/clang/lib/Basic/Targets/AArch64.cpp
@@ -770,11 +770,12 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
llvm::SmallVector<Builtin::InfosShard>
AArch64TargetInfo::getTargetBuiltins() const {
return {
- {&NEON::BuiltinStrings, NEON::BuiltinInfos},
- {&NEON::FP16::BuiltinStrings, NEON::FP16::BuiltinInfos},
- {&SVE::BuiltinStrings, SVE::BuiltinInfos},
+ {&NEON::BuiltinStrings, NEON::BuiltinInfos, "__builtin_neon_"},
+ {&NEON::FP16::BuiltinStrings, NEON::FP16::BuiltinInfos,
+ "__builtin_neon_"},
+ {&SVE::BuiltinStrings, SVE::BuiltinInfos, "__builtin_sve_"},
{&BuiltinSVENeonBridgeStrings, BuiltinSVENeonBridgeInfos},
- {&SME::BuiltinStrings, SME::BuiltinInfos},
+ {&SME::BuiltinStrings, SME::BuiltinInfos, "__builtin_sme_"},
{&BuiltinAArch64Strings, BuiltinAArch64Infos},
};
}
diff --git a/clang/lib/Basic/Targets/ARM.cpp b/clang/lib/Basic/Targets/ARM.cpp
index 92428908fe4a61..045d35f418e343 100644
--- a/clang/lib/Basic/Targets/ARM.cpp
+++ b/clang/lib/Basic/Targets/ARM.cpp
@@ -1126,8 +1126,9 @@ static constexpr auto BuiltinInfos = Builtin::MakeInfos<NumARMBuiltins>({
llvm::SmallVector<Builtin::InfosShard>
ARMTargetInfo::getTargetBuiltins() const {
return {
- {&NEON::BuiltinStrings, NEON::BuiltinInfos},
- {&NEON::FP16::BuiltinStrings, NEON::FP16::BuiltinInfos},
+ {&NEON::BuiltinStrings, NEON::BuiltinInfos, "__builtin_neon_"},
+ {&NEON::FP16::BuiltinStrings, NEON::FP16::BuiltinInfos,
+ "__builtin_neon_"},
{&BuiltinStrings, BuiltinInfos},
};
}
diff --git a/clang/lib/Basic/Targets/RISCV.cpp b/clang/lib/Basic/Targets/RISCV.cpp
index 079ddc3c5d6e13..ee25598395d789 100644
--- a/clang/lib/Basic/Targets/RISCV.cpp
+++ b/clang/lib/Basic/Targets/RISCV.cpp
@@ -255,7 +255,6 @@ namespace RVV {
#define GET_RISCVV_BUILTIN_STR_TABLE
#include "clang/Basic/riscv_vector_builtins.inc"
#undef GET_RISCVV_BUILTIN_STR_TABLE
-static_assert(BuiltinStrings.size() < 100'000);
static constexpr std::array<Builtin::Info, NumRVVBuiltins> BuiltinInfos = {
#define GET_RISCVV_BUILTIN_INFOS
@@ -291,8 +290,8 @@ static_assert(std::size(BuiltinInfos) == NumRISCVBuiltins);
llvm::SmallVector<Builtin::InfosShard>
RISCVTargetInfo::getTargetBuiltins() const {
return {
- {&RVV::BuiltinStrings, RVV::BuiltinInfos},
- {&RVVSiFive::BuiltinStrings, RVVSiFive::BuiltinInfos},
+ {&RVV::BuiltinStrings, RVV::BuiltinInfos, "__builtin_rvv_"},
+ {&RVVSiFive::BuiltinStrings, RVVSiFive::BuiltinInfos, "__builtin_rvv_"},
{&BuiltinStrings, BuiltinInfos},
};
}
diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
index 4d4b7428abd505..42409ba5ae5be4 100644
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -263,8 +263,10 @@ llvm::Constant *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
unsigned BuiltinID) {
assert(Context.BuiltinInfo.isLibFunction(BuiltinID));
- // Get the name, skip over the __builtin_ prefix (if necessary).
- StringRef Name;
+ // Get the name, skip over the __builtin_ prefix (if necessary). We may have
+ // to build this up so provide a small stack buffer to handle the vast
+ // majority of names.
+ llvm::SmallString<64> Name;
GlobalDecl D(FD);
// TODO: This list should be expanded or refactored after all GCC-compatible
@@ -6566,7 +6568,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
LargestVectorWidth = std::max(LargestVectorWidth, VectorWidth);
// See if we have a target specific intrinsic.
- StringRef Name = getContext().BuiltinInfo.getName(BuiltinID);
+ std::string Name = getContext().BuiltinInfo.getName(BuiltinID);
Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic;
StringRef Prefix =
llvm::Triple::getArchTypePrefix(getTarget().getTriple().getArch());
@@ -21213,7 +21215,7 @@ static Value *MakeHalfType(unsigned IntrinsicID, unsigned BuiltinID,
auto &C = CGF.CGM.getContext();
if (!(C.getLangOpts().NativeHalfType ||
!C.getTargetInfo().useFP16ConversionIntrinsics())) {
- CGF.CGM.Error(E->getExprLoc(), C.BuiltinInfo.getName(BuiltinID).str() +
+ CGF.CGM.Error(E->getExprLoc(), C.BuiltinInfo.getQuotedName(BuiltinID) +
" requires native half type support.");
return nullptr;
}
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index c49f7631488285..51c23ce6dca5a5 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -3983,7 +3983,8 @@ namespace {
unsigned BuiltinID = FD->getBuiltinID();
if (!BuiltinID || !BI.isLibFunction(BuiltinID))
return false;
- StringRef BuiltinName = BI.getName(BuiltinID);
+ std::string BuiltinNameStr = BI.getName(BuiltinID);
+ StringRef BuiltinName = BuiltinNameStr;
if (BuiltinName.starts_with("__builtin_") &&
Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
return true;
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index cb79a224018faa..849e167a6edff6 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -1235,7 +1235,9 @@ void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD,
bool IsChkVariant = false;
auto GetFunctionName = [&]() {
- StringRef FunctionName = getASTContext().BuiltinInfo.getName(BuiltinID);
+ std::string FunctionNameStr =
+ getASTContext().BuiltinInfo.getName(BuiltinID);
+ llvm::StringRef FunctionName = FunctionNameStr;
// Skim off the details of whichever builtin was called to produce a better
// diagnostic, as it's unlikely that the user wrote the __builtin
// explicitly.
@@ -1245,7 +1247,7 @@ void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD,
} else {
FunctionName.consume_front("__builtin_");
}
- return FunctionName;
+ return FunctionName.str();
};
switch (BuiltinID) {
@@ -1289,7 +1291,7 @@ void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD,
unsigned SourceSize) {
DiagID = diag::warn_fortify_scanf_overflow;
unsigned Index = ArgIndex + DataIndex;
- StringRef FunctionName = GetFunctionName();
+ std::string FunctionName = GetFunctionName();
DiagRuntimeBehavior(TheCall->getArg(Index)->getBeginLoc(), TheCall,
PDiag(DiagID) << FunctionName << (Index + 1)
<< DestSize << SourceSize);
@@ -1438,7 +1440,7 @@ void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD,
llvm::APSInt::compareValues(*SourceSize, *DestinationSize) <= 0)
return;
- StringRef FunctionName = GetFunctionName();
+ std::string FunctionName = GetFunctionName();
SmallString<16> DestinationStr;
SmallString<16> SourceStr;
@@ -4545,7 +4547,7 @@ ExprResult Sema::BuiltinAtomicOverloaded(ExprResult TheCallResult) {
// Get the decl for the concrete builtin from this, we can tell what the
// concrete integer type we should convert to is.
unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
- StringRef NewBuiltinName = Context.BuiltinInfo.getName(NewBuiltinID);
+ std::string NewBuiltinName = Context.BuiltinInfo.getName(NewBuiltinID);
FunctionDecl *NewBuiltinDecl;
if (NewBuiltinID == BuiltinID)
NewBuiltinDecl = FDecl;
@@ -8340,7 +8342,7 @@ static void emitReplacement(Sema &S, SourceLocation Loc, SourceRange Range,
unsigned AbsKind, QualType ArgType) {
bool EmitHeaderHint = true;
const char *HeaderName = nullptr;
- StringRef FunctionName;
+ std::string FunctionName;
if (S.getLangOpts().CPlusPlus && !ArgType->isAnyComplexType()) {
FunctionName = "std::abs";
if (ArgType->isIntegralOrEnumerationType()) {
@@ -8489,7 +8491,7 @@ void Sema::CheckAbsoluteValueFunction(const CallExpr *Call,
// Unsigned types cannot be negative. Suggest removing the absolute value
// function call.
if (ArgType->isUnsignedIntegerType()) {
- StringRef FunctionName =
+ std::string FunctionName =
IsStdAbs ? "std::abs" : Context.BuiltinInfo.getName(AbsKind);
Diag(Call->getExprLoc(), diag::warn_unsigned_abs) << ArgType << ParamType;
Diag(Call->getExprLoc(), diag::note_remove_abs)
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 562c98c6babe04..0bc7114fa6e59c 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -6681,7 +6681,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
Expr *Sema::BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,
MultiExprArg CallArgs) {
- StringRef Name = Context.BuiltinInfo.getName(Id);
+ std::string Name = Context.BuiltinInfo.getName(Id);
LookupResult R(*this, &Context.Idents.get(Name), Loc,
Sema::LookupOrdinaryName);
LookupName(R, TUScope, /*AllowBuiltinCreation=*/true);
diff --git a/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp b/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp
index 96464b30c078f4..d0145293fa3e52 100644
--- a/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp
+++ b/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp
@@ -55,7 +55,7 @@ bool CheckerContext::isCLibraryFunction(const FunctionDecl *FD,
if (BId != 0) {
if (Name.empty())
return true;
- StringRef BName = FD->getASTContext().BuiltinInfo.getName(BId);
+ std::string BName = FD->getASTContext().BuiltinInfo.getName(BId);
size_t start = BName.find(Name);
if (start != StringRef::npos) {
// Accept exact match.
diff --git a/clang/utils/TableGen/NeonEmitter.cpp b/clang/utils/TableGen/NeonEmitter.cpp
index e371fa9e8c8a0c..8e1246f86cc885 100644
--- a/clang/utils/TableGen/NeonEmitter.cpp
+++ b/clang/utils/TableGen/NeonEmitter.cpp
@@ -2068,16 +2068,12 @@ void NeonEmitter::genBuiltinsDef(raw_ostream &OS,
Table.GetOrAddStringOffset("");
Table.GetOrAddStringOffset("n");
- auto PrefixName = [](Intrinsic *Def) -> std::string {
- return (llvm::Twine("__builtin_neon_") + Def->getMangledName()).str();
- };
-
for (auto *Def : Defs) {
if (Def->hasBody())
continue;
if (Builtins.insert({Def->getMangledName(), Def}).second) {
- Table.GetOrAddStringOffset(PrefixName(Def));
+ Table.GetOrAddStringOffset(Def->getMangledName());
Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
Table.GetOrAddStringOffset(Def->getTargetGuard());
}
@@ -2097,8 +2093,8 @@ void NeonEmitter::genBuiltinsDef(raw_ostream &OS,
OS << "#ifdef GET_NEON_BUILTIN_INFOS\n";
for (const auto &[Name, Def] : Builtins) {
OS << " Builtin::Info{Builtin::Info::StrOffsets{"
- << Table.GetStringOffset(PrefixName(Def)) << " /* " << PrefixName(Def)
- << " */, ";
+ << Table.GetStringOffset(Def->getMangledName()) << " /* "
+ << Def->getMangledName() << " */, ";
OS << Table.GetStringOffset(Def->getBuiltinTypeStr()) << " /* "
<< Def->getBuiltinTypeStr() << " */, ";
OS << Table.GetStringOffset("n") << " /* n */, ";
diff --git a/clang/utils/TableGen/RISCVVEmitter.cpp b/clang/utils/TableGen/RISCVVEmitter.cpp
index 077854f71d236d..4a36a255c46b74 100644
--- a/clang/utils/TableGen/RISCVVEmitter.cpp
+++ b/clang/utils/TableGen/RISCVVEmitter.cpp
@@ -507,17 +507,13 @@ void RVVEmitter::createBuiltins(raw_ostream &OS) {
Table.GetOrAddStringOffset("n");
Table.GetOrAddStringOffset("zve32x");
- auto PrefixName = [](RVVIntrinsic *Def) -> std::string {
- return ("__builtin_rvv_" + Def->getBuiltinName()).str();
- };
-
// Map to unique the builtin names.
StringMap<RVVIntrinsic *> BuiltinMap;
std::vector<RVVIntrinsic *> UniqueDefs;
for (auto &Def : Defs) {
auto P = BuiltinMap.insert({Def->getBuiltinName(), Def.get()});
if (P.second) {
- Table.GetOrAddStringOffset(PrefixName(Def.get()));
+ Table.GetOrAddStringOffset(Def->getBuiltinName());
if (!Def->hasBuiltinAlias())
Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
UniqueDefs.push_back(Def.get());
@@ -553,8 +549,8 @@ void RVVEmitter::createBuiltins(raw_ostream &OS) {
OS << "#ifdef GET_RISCVV_BUILTIN_INFOS\n";
for (RVVIntrinsic *Def : UniqueDefs) {
OS << " Builtin::Info{Builtin::Info::StrOffsets{"
- << Table.GetStringOffset(PrefixName(Def)) << " /* " << PrefixName(Def)
- << " */, ";
+ << Table.GetStringOffset(Def->getBuiltinName()) << " /* "
+ << Def->getBuiltinName() << " */, ";
if (Def->hasBuiltinAlias()) {
OS << "0, ";
} else {
diff --git a/clang/utils/TableGen/SveEmitter.cpp b/clang/utils/TableGen/SveEmitter.cpp
index c9cbbb73580c00..12b5c986d4e9b8 100644
--- a/clang/utils/TableGen/SveEmitter.cpp
+++ b/clang/utils/TableGen/SveEmitter.cpp
@@ -1480,13 +1480,9 @@ void SVEEmitter::createBuiltins(raw_ostream &OS) {
Table.GetOrAddStringOffset("");
Table.GetOrAddStringOffset("n");
- auto PrefixName = [](Intrinsic *Def) -> std::string {
- return (llvm::Twine("__builtin_sve_") + Def->getMangledName()).str();
- };
-
for (const auto &Def : Defs)
if (Def->getClassKind() != ClassG) {
- Table.GetOrAddStringOffset(PrefixName(Def.get()));
+ Table.GetOrAddStringOffset(Def->getMangledName());
Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
Table.GetOrAddStringOffset(Def->getGuard());
}
@@ -1500,9 +1496,9 @@ void SVEEmitter::createBuiltins(raw_ostream &OS) {
SVEType ToV(To.BaseType, N);
for (const ReinterpretTypeInfo &From : Reinterprets) {
SVEType FromV(From.BaseType, N);
- std::string Name = (Twine("__builtin_sve_reinterpret_") + To.Suffix +
- "_" + From.Suffix + Suffix)
- .str();
+ std::string Name =
+ (Twine("reinterpret_") + To.Suffix + "_" + From.Suffix + Suffix)
+ .str();
std::string Type = ToV.builtin_str() + FromV.builtin_str();
Table.GetOrAddStringOffset(Name);
Table.GetOrAddStringOffset(Type);
@@ -1514,9 +1510,9 @@ void SVEEmitter::createBuiltins(raw_ostream &OS) {
OS << "#ifdef GET_SVE_BUILTIN_ENUMERATORS\n";
for (const auto &Def : Defs)
if (Def->getClassKind() != ClassG)
- OS << " BI" << PrefixName(Def.get()) << ",\n";
+ OS << " BI__builtin_sve_" << Def->getMangledName() << ",\n";
for (const auto &[Name, _] : ReinterpretBuiltins)
- OS << " BI" << Name << ",\n";
+ OS << " BI__builtin_sve_" << Name << ",\n";
OS << "#endif // GET_SVE_BUILTIN_ENUMERATORS\n\n";
OS << "#ifdef GET_SVE_BUILTIN_STR_TABLE\n";
@@ -1530,8 +1526,8 @@ void SVEEmitter::createBuiltins(raw_ostream &OS) {
// declarations only live in the header file.
if (Def->getClassKind() != ClassG) {
OS << " Builtin::Info{Builtin::Info::StrOffsets{"
- << Table.GetStringOffset(PrefixName(Def.get())) << " /* "
- << PrefixName(Def.get()) << " */, ";
+ << Table.GetStringOffset(Def->getMangledName()) << " /* "
+ << Def->getMangledName() << " */, ";
OS << Table.GetStringOffset(Def->getBuiltinTypeStr()) << " /* "
<< Def->getBuiltinTypeStr() << " */, ";
OS << Table.GetStringOffset("n") << " /* n */, ";
@@ -1732,13 +1728,9 @@ void SVEEmitter::createSMEBuiltins(raw_ostream &OS) {
Table.GetOrAddStringOffset("");
Table.GetOrAddStringOffset("n");
- auto PrefixName = [](Intrinsic *Def) -> std::string {
- return (llvm::Twine("__builtin_sme_") + Def->getMangledName()).str();
- };
-
for (const auto &Def : Defs)
if (Def->getClassKind() != ClassG) {
- Table.GetOrAddStringOffset(PrefixName(Def.get()));
+ Table.GetOrAddStringOffset(Def->getMangledName());
Table.GetOrAddStringOffset(Def->getBuiltinTypeStr());
Table.GetOrAddStringOffset(Def->getGuard());
}
@@ -1746,7 +1738,7 @@ void SVEEmitter::createSMEBuiltins(raw_ostream &OS) {
OS << "#ifdef GET_SME_BUILTIN_ENUMERATORS\n";
for (const auto &Def : Defs)
if (Def->getClassKind() != ClassG)
- OS << " BI" << PrefixName(Def.get()) << ",\n";
+ OS << " BI__builtin_sme_" << Def->getMangledName() << ",\n";
OS << "#endif // GET_SME_BUILTIN_ENUMERATORS\n\n";
OS << "#ifdef GET_SME_BUILTIN_STR_TABLE\n";
@@ -1760,8 +1752,8 @@ void SVEEmitter::createSMEBuiltins(raw_ostream &OS) {
// declarations only live in the header file.
if (Def->getClassKind() != ClassG) {
OS << " Builtin::Info{Builtin::Info::StrOffsets{"
- << Table.GetStringOffset(PrefixName(Def.get())) << " /* "
- << PrefixName(Def.get()) << " */, ";
+ << Table.GetStringOffset(Def->getMangledName()) << " /* "
+ << Def->getMangledName() << " */, ";
OS << Table.GetStringOffset(Def->getBuiltinTypeStr()) << " /* "
<< Def->getBuiltinTypeStr() << " */, ";
OS << Table.GetStringOffset("n") << " /* n */, ";
>From e85281eef42e134f68e4cabc30b79112d3b6f8ab Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Sun, 5 Jan 2025 15:01:37 +0000
Subject: [PATCH 8/9] Add prefixes for x86 builtins
This requires adding support to the general builtins emission for
producing prefixed builtin infos separately from un-prefixed which is
a bit rough. We don't currently have any good way of having a more
refined model than a single hard-coded prefix string per TableGen
emission. Something more powerful and/or elegant is possible, but this
is a fairly minimal first step that at least allows factoring out the
builtin prefix for something like X86.
---
clang/include/clang/Basic/BuiltinsBase.td | 10 ++++
clang/include/clang/Basic/BuiltinsX86Base.td | 5 +-
clang/lib/Basic/Targets/X86.cpp | 25 ++++++++--
clang/utils/TableGen/ClangBuiltinsEmitter.cpp | 50 +++++++++++++++++--
4 files changed, 82 insertions(+), 8 deletions(-)
diff --git a/clang/include/clang/Basic/BuiltinsBase.td b/clang/include/clang/Basic/BuiltinsBase.td
index 6180a94aa4b5c7..cf15a31235e7ea 100644
--- a/clang/include/clang/Basic/BuiltinsBase.td
+++ b/clang/include/clang/Basic/BuiltinsBase.td
@@ -86,6 +86,13 @@ def Consteval : Attribute<"EG">;
// indicated by the remaining indices.
class Callback<list<int> ArgIndices> : MultiIndexAttribute<"C", ArgIndices>;
+// Prefixes
+// ========
+
+class NamePrefix<string spelling> {
+ string Spelling = spelling;
+}
+
// Builtin kinds
// =============
@@ -99,6 +106,9 @@ class Builtin {
bit RequiresUndef = 0;
// Enables builtins to generate `long long` outside of OpenCL and `long` inside.
bit EnableOpenCLLong = 0;
+ // Requires a common prefix to be prepended. Each generated set of builtins
+ // can optionally extract one common prefix that is handled separately.
+ NamePrefix RequiredNamePrefix;
}
class AtomicBuiltin : Builtin;
diff --git a/clang/include/clang/Basic/BuiltinsX86Base.td b/clang/include/clang/Basic/BuiltinsX86Base.td
index aca39c204516ae..0d739ee0b0b69e 100644
--- a/clang/include/clang/Basic/BuiltinsX86Base.td
+++ b/clang/include/clang/Basic/BuiltinsX86Base.td
@@ -12,10 +12,13 @@
include "clang/Basic/BuiltinsBase.td"
+def X86Prefix : NamePrefix<"__builtin_ia32_">;
+
class X86Builtin<string prototype> : TargetBuiltin {
- let Spellings = ["__builtin_ia32_" # NAME];
+ let Spellings = [NAME];
let Prototype = prototype;
let EnableOpenCLLong = 1;
+ let RequiredNamePrefix = X86Prefix; // Adds a prefix to the name.
}
class X86NoPrefixBuiltin<string prototype> : TargetBuiltin {
diff --git a/clang/lib/Basic/Targets/X86.cpp b/clang/lib/Basic/Targets/X86.cpp
index dacadec27e1ea0..70d37025c553ae 100644
--- a/clang/lib/Basic/Targets/X86.cpp
+++ b/clang/lib/Basic/Targets/X86.cpp
@@ -41,7 +41,14 @@ static constexpr Builtin::Info BuiltinInfos[] = {
#include "clang/Basic/BuiltinsX86.inc"
#undef GET_BUILTIN_INFOS
};
-static_assert(std::size(BuiltinInfos) == NumX86Builtins);
+
+static constexpr Builtin::Info PrefixedBuiltinInfos[] = {
+#define GET_BUILTIN_PREFIXED_INFOS
+#include "clang/Basic/BuiltinsX86.inc"
+#undef GET_BUILTIN_PREFIXED_INFOS
+};
+static_assert((std::size(BuiltinInfos) + std::size(PrefixedBuiltinInfos)) ==
+ NumX86Builtins);
} // namespace X86
namespace X86_64 {
@@ -54,7 +61,14 @@ static constexpr Builtin::Info BuiltinInfos[] = {
#include "clang/Basic/BuiltinsX86_64.inc"
#undef GET_BUILTIN_INFOS
};
-static_assert(std::size(BuiltinInfos) == NumX86_64Builtins);
+
+static constexpr Builtin::Info PrefixedBuiltinInfos[] = {
+#define GET_BUILTIN_PREFIXED_INFOS
+#include "clang/Basic/BuiltinsX86_64.inc"
+#undef GET_BUILTIN_PREFIXED_INFOS
+};
+static_assert((std::size(BuiltinInfos) + std::size(PrefixedBuiltinInfos)) ==
+ NumX86_64Builtins);
} // namespace X86_64
static const char *const GCCRegNames[] = {
@@ -1874,13 +1888,18 @@ ArrayRef<TargetInfo::AddlRegName> X86TargetInfo::getGCCAddlRegNames() const {
llvm::SmallVector<Builtin::InfosShard>
X86_32TargetInfo::getTargetBuiltins() const {
- return {{&X86::BuiltinStrings, X86::BuiltinInfos}};
+ return {
+ {&X86::BuiltinStrings, X86::BuiltinInfos},
+ {&X86::BuiltinStrings, X86::PrefixedBuiltinInfos, "__builtin_ia32_"},
+ };
}
llvm::SmallVector<Builtin::InfosShard>
X86_64TargetInfo::getTargetBuiltins() const {
return {
{&X86::BuiltinStrings, X86::BuiltinInfos},
+ {&X86::BuiltinStrings, X86::PrefixedBuiltinInfos, "__builtin_ia32_"},
{&X86_64::BuiltinStrings, X86_64::BuiltinInfos},
+ {&X86_64::BuiltinStrings, X86_64::PrefixedBuiltinInfos, "__builtin_ia32_"},
};
}
diff --git a/clang/utils/TableGen/ClangBuiltinsEmitter.cpp b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
index acdfffb534cb29..2aad3e95e7011c 100644
--- a/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
+++ b/clang/utils/TableGen/ClangBuiltinsEmitter.cpp
@@ -59,7 +59,13 @@ struct Builtin {
const Record *BuiltinRecord;
void EmitEnumerator(llvm::raw_ostream &OS) const {
- OS << " BI" << Name << ",\n";
+ OS << " BI";
+ // If there is a required name prefix, include its spelling in the
+ // enumerator.
+ if (auto *PrefixRecord =
+ BuiltinRecord->getValueAsOptionalDef("RequiredNamePrefix"))
+ OS << PrefixRecord->getValueAsString("Spelling");
+ OS << Name << ",\n";
}
void EmitInfo(llvm::raw_ostream &OS, const StringToOffsetTable &Table) const {
@@ -445,17 +451,43 @@ void clang::EmitClangBuiltins(const RecordKeeper &Records, raw_ostream &OS) {
for (const auto *BuiltinRecord :
Records.getAllDerivedDefinitions("AtomicBuiltin"))
collectBuiltins(BuiltinRecord, Builtins);
-
unsigned NumAtomicBuiltins = Builtins.size();
+
for (const auto *BuiltinRecord :
Records.getAllDerivedDefinitions("Builtin")) {
if (BuiltinRecord->isSubClassOf("AtomicBuiltin"))
continue;
+ // Prefixed builtins are also special and we emit them last so they can have
+ // their own representation that skips the prefix.
+ if (BuiltinRecord->getValueAsOptionalDef("RequiredNamePrefix"))
+ continue;
+
+ collectBuiltins(BuiltinRecord, Builtins);
+ }
+
+ // Now collect (and count) the prefixed builtins.
+ unsigned NumPrefixedBuiltins = Builtins.size();
+ const Record* first_prefix = nullptr;
+ for (const auto *BuiltinRecord :
+ Records.getAllDerivedDefinitions("Builtin")) {
+ auto *prefix = BuiltinRecord->getValueAsOptionalDef("RequiredNamePrefix");
+ if (!prefix)
+ continue;
+
+ if (!first_prefix)
+ first_prefix = prefix;
+ assert(prefix == first_prefix &&
+ "Multiple distinct prefixes which is not currently supported!");
+ assert(!BuiltinRecord->isSubClassOf("AtomicBuiltin") &&
+ "Cannot require a name prefix for an atomic builtin.");
collectBuiltins(BuiltinRecord, Builtins);
}
+ NumPrefixedBuiltins = Builtins.size() - NumPrefixedBuiltins;
auto AtomicBuiltins = ArrayRef(Builtins).slice(0, NumAtomicBuiltins);
+ auto UnprefixedBuiltins = ArrayRef(Builtins).drop_back(NumPrefixedBuiltins);
+ auto PrefixedBuiltins = ArrayRef(Builtins).take_back(NumPrefixedBuiltins);
// Collect strings into a table.
StringToOffsetTable Table;
@@ -488,14 +520,24 @@ void clang::EmitClangBuiltins(const RecordKeeper &Records, raw_ostream &OS) {
#endif // GET_BUILTIN_STR_TABLE
)c++";
- // Emit a direct set of `Builtin::Info` initializers.
+ // Emit a direct set of `Builtin::Info` initializers, first for the unprefixed
+ // builtins and then for the prefixed builtins.
OS << R"c++(
#ifdef GET_BUILTIN_INFOS
)c++";
- for (const auto &B : Builtins)
+ for (const auto &B : UnprefixedBuiltins)
B.EmitInfo(OS, Table);
OS << R"c++(
#endif // GET_BUILTIN_INFOS
+)c++";
+
+ OS << R"c++(
+#ifdef GET_BUILTIN_PREFIXED_INFOS
+)c++";
+ for (const auto &B : PrefixedBuiltins)
+ B.EmitInfo(OS, Table);
+ OS << R"c++(
+#endif // GET_BUILTIN_PREFIXED_INFOS
)c++";
// Emit X-macros for the atomic builtins to support various custome patterns
>From 2ec750d0105e1d4d52791f85293d16d28f6ccbd8 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc at gmail.com>
Date: Sun, 5 Jan 2025 15:25:31 +0000
Subject: [PATCH 9/9] DO NOT MERGE: debug hacks for builtins
---
clang/include/clang/Basic/Builtins.h | 4 ++++
clang/lib/Basic/Builtins.cpp | 19 +++++++++++++++++++
2 files changed, 23 insertions(+)
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
index 5ebe4c03fadccd..419cd23b0b6edf 100644
--- a/clang/include/clang/Basic/Builtins.h
+++ b/clang/include/clang/Basic/Builtins.h
@@ -231,6 +231,10 @@ class Context {
unsigned NumTargetBuiltins = 0;
unsigned NumAuxTargetBuiltins = 0;
+ // FIXME: HACK FOR DEBUG
+ bool DebugHackTargetIsX86 = false;
+ bool DebugHackTargetIsNVPTX = false;
+
public:
Context();
diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
index e7829a461bbc53..5606fe2d4bf6d2 100644
--- a/clang/lib/Basic/Builtins.cpp
+++ b/clang/lib/Basic/Builtins.cpp
@@ -14,6 +14,7 @@
#include "BuiltinTargetFeatures.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/TargetBuiltins.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/StringRef.h"
using namespace clang;
@@ -118,6 +119,12 @@ void Builtin::Context::InitializeTarget(const TargetInfo &Target,
for (const auto &Shard : AuxTargetShards)
NumAuxTargetBuiltins += Shard.Infos.size();
}
+
+ // FIXME: HACK FOR DEBUG
+ if (Target.getTriple().isX86())
+ DebugHackTargetIsX86 = true;
+ else if (Target.getTriple().isNVPTX())
+ DebugHackTargetIsNVPTX = true;
}
bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
@@ -214,6 +221,18 @@ void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
// Step #2: Register target-specific builtins.
for (const auto &Shard : TargetShards)
for (const auto &I : Shard.Infos) {
+ // FIXME: Hacks for debugging
+ if (DebugHackTargetIsX86 && ID == X86::BI__builtin_ia32_packsswb128) {
+ if (I.getName(Shard) != "__builtin_ia32_packsswb128")
+ llvm::report_fatal_error(
+ llvm::Twine("Name for __builtin_ia32_packsswb128 is: '") +
+ I.getName(Shard) + "'!!!");
+ } else if (DebugHackTargetIsNVPTX && ID == NVPTX::BI__nvvm_vote_all) {
+ if (I.getName(Shard) != "__nvvm_vote_all")
+ llvm::report_fatal_error(
+ llvm::Twine("Name for __nvvm_vote_all is: '") +
+ I.getName(Shard) + "'!!!");
+ }
if (builtinIsSupported(*Shard.Strings, I, LangOpts))
Table.get(I.getName(Shard)).setBuiltinID(ID);
++ID;
More information about the cfe-commits
mailing list