[llvm] a961210 - Revert "RuntimeLibcalls: Add methods to recognize libcall names (#149001)"
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Fri Jul 18 01:15:26 PDT 2025
Author: Nikita Popov
Date: 2025-07-18T10:15:19+02:00
New Revision: a96121089b9c94e08c6632f91f2dffc73c0ffa28
URL: https://github.com/llvm/llvm-project/commit/a96121089b9c94e08c6632f91f2dffc73c0ffa28
DIFF: https://github.com/llvm/llvm-project/commit/a96121089b9c94e08c6632f91f2dffc73c0ffa28.diff
LOG: Revert "RuntimeLibcalls: Add methods to recognize libcall names (#149001)"
This reverts commit 45477add8dfe9851605697bd908b49f0ec244625.
This causes a significant LTO compile-time regression.
Added:
Modified:
llvm/include/llvm/ADT/StringTable.h
llvm/include/llvm/IR/RuntimeLibcalls.h
llvm/lib/IR/RuntimeLibcalls.cpp
llvm/lib/Object/IRSymtab.cpp
llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ADT/StringTable.h b/llvm/include/llvm/ADT/StringTable.h
index 575b3c929e40c..c089a070d4b57 100644
--- a/llvm/include/llvm/ADT/StringTable.h
+++ b/llvm/include/llvm/ADT/StringTable.h
@@ -118,13 +118,6 @@ class StringTable {
constexpr Iterator(const Iterator &RHS) = default;
constexpr Iterator(Iterator &&RHS) = default;
- Iterator &operator=(const Iterator &RHS) {
- Table = RHS.Table;
- O = RHS.O;
- S = RHS.S;
- return *this;
- }
-
bool operator==(const Iterator &RHS) const {
assert(Table == RHS.Table && "Compared iterators for unrelated tables!");
return O == RHS.O;
@@ -139,8 +132,6 @@ class StringTable {
O = O.value() + (*Table)[O].size() + 1;
return *this;
}
-
- Offset offset() const { return O; }
};
constexpr Iterator begin() const { return Iterator(*this, 0); }
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h b/llvm/include/llvm/IR/RuntimeLibcalls.h
index 89ad4e5bc6ca4..8058c8a4c5510 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -132,10 +132,6 @@ struct RuntimeLibcallsInfo {
return ImplToLibcall[Impl];
}
- /// Check if this is valid libcall for the current module, otherwise
- /// RTLIB::Unsupported.
- RTLIB::LibcallImpl getSupportedLibcallImpl(StringRef FuncName) const;
-
private:
static const RTLIB::LibcallImpl
DefaultLibcallImpls[RTLIB::UNKNOWN_LIBCALL + 1];
@@ -160,14 +156,6 @@ struct RuntimeLibcallsInfo {
/// Map from a concrete LibcallImpl implementation to its RTLIB::Libcall kind.
LLVM_ABI static const RTLIB::Libcall ImplToLibcall[RTLIB::NumLibcallImpls];
- /// Check if a function name is a recognized runtime call of any kind. This
- /// does not consider if this call is available for any current compilation,
- /// just that it is a known call somewhere. This returns the set of all
- /// LibcallImpls which match the name; multiple implementations with the same
- /// name may exist but
diff er in interpretation based on the target context.
- LLVM_ABI static iterator_range<ArrayRef<uint16_t>::const_iterator>
- getRecognizedLibcallImpls(StringRef FuncName);
-
static bool darwinHasSinCosStret(const Triple &TT) {
if (!TT.isOSDarwin())
return false;
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index 5936ac7d0287f..b1864897dafa6 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -135,51 +135,6 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
}
}
-RTLIB::LibcallImpl
-RuntimeLibcallsInfo::getSupportedLibcallImpl(StringRef FuncName) const {
- const ArrayRef<uint16_t> RuntimeLibcallNameOffsets(
- RuntimeLibcallNameOffsetTable);
-
- iterator_range<ArrayRef<uint16_t>::const_iterator> Range =
- getRecognizedLibcallImpls(FuncName);
-
- for (auto I = Range.begin(); I != Range.end(); ++I) {
- RTLIB::LibcallImpl Impl =
- static_cast<RTLIB::LibcallImpl>(I - RuntimeLibcallNameOffsets.begin());
-
- // FIXME: This should not depend on looking up ImplToLibcall, only the list
- // of libcalls for the module.
- RTLIB::LibcallImpl Recognized = LibcallImpls[ImplToLibcall[Impl]];
- if (Recognized != RTLIB::Unsupported)
- return Recognized;
- }
-
- return RTLIB::Unsupported;
-}
-
-iterator_range<ArrayRef<uint16_t>::const_iterator>
-RuntimeLibcallsInfo::getRecognizedLibcallImpls(StringRef FuncName) {
- StringTable::Iterator It = lower_bound(RuntimeLibcallImplNameTable, FuncName);
- if (It == RuntimeLibcallImplNameTable.end() || *It != FuncName)
- return iterator_range(ArrayRef<uint16_t>());
-
- uint16_t IndexVal = It.offset().value();
- const ArrayRef<uint16_t> TableRef(RuntimeLibcallNameOffsetTable);
-
- ArrayRef<uint16_t>::const_iterator E = TableRef.end();
- ArrayRef<uint16_t>::const_iterator EntriesBegin =
- std::lower_bound(TableRef.begin(), E, IndexVal);
- ArrayRef<uint16_t>::const_iterator EntriesEnd = EntriesBegin;
-
- while (EntriesEnd != E && *EntriesEnd == IndexVal)
- ++EntriesEnd;
-
- assert(EntriesBegin != E &&
- "libcall found in name table but not offset table");
-
- return make_range(EntriesBegin, EntriesEnd);
-}
-
bool RuntimeLibcallsInfo::darwinHasExp10(const Triple &TT) {
switch (TT.getOS()) {
case Triple::MacOSX:
diff --git a/llvm/lib/Object/IRSymtab.cpp b/llvm/lib/Object/IRSymtab.cpp
index 79eeb08cddeef..2579fa37935f0 100644
--- a/llvm/lib/Object/IRSymtab.cpp
+++ b/llvm/lib/Object/IRSymtab.cpp
@@ -54,11 +54,6 @@ static const char *PreservedSymbols[] = {
"__stack_chk_guard",
};
-static bool isPreservedGlobalVarName(StringRef Name) {
- return StringRef(PreservedSymbols[0]) == Name ||
- StringRef(PreservedSymbols[1]) == Name;
-}
-
namespace {
const char *getExpectedProducerName() {
@@ -86,16 +81,12 @@ struct Builder {
// The StringTableBuilder does not create a copy of any strings added to it,
// so this provides somewhere to store any strings that we create.
Builder(SmallVector<char, 0> &Symtab, StringTableBuilder &StrtabBuilder,
- BumpPtrAllocator &Alloc, const Triple &TT)
- : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc), TT(TT),
- Libcalls(TT) {}
+ BumpPtrAllocator &Alloc)
+ : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc) {}
DenseMap<const Comdat *, int> ComdatMap;
Mangler Mang;
- const Triple &TT;
-
- // FIXME: This shouldn't be here.
- RTLIB::RuntimeLibcallsInfo Libcalls;
+ Triple TT;
std::vector<storage::Comdat> Comdats;
std::vector<storage::Module> Mods;
@@ -107,10 +98,6 @@ struct Builder {
std::vector<storage::Str> DependentLibraries;
- bool isPreservedLibFuncName(StringRef Name) {
- return Libcalls.getSupportedLibcallImpl(Name) != RTLIB::Unsupported;
- }
-
void setStr(storage::Str &S, StringRef Value) {
S.Offset = StrtabBuilder.add(Value);
S.Size = Value.size();
@@ -226,6 +213,18 @@ Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {
return P.first->second;
}
+static DenseSet<StringRef> buildPreservedSymbolsSet(const Triple &TT) {
+ DenseSet<StringRef> PreservedSymbolSet(std::begin(PreservedSymbols),
+ std::end(PreservedSymbols));
+ // FIXME: Do we need to pass in ABI fields from TargetOptions?
+ RTLIB::RuntimeLibcallsInfo Libcalls(TT);
+ for (RTLIB::LibcallImpl Impl : Libcalls.getLibcallImpls()) {
+ if (Impl != RTLIB::Unsupported)
+ PreservedSymbolSet.insert(Libcalls.getLibcallImplName(Impl));
+ }
+ return PreservedSymbolSet;
+}
+
Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
const SmallPtrSet<GlobalValue *, 4> &Used,
ModuleSymbolTable::Symbol Msym) {
@@ -279,11 +278,13 @@ Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
return Error::success();
}
- StringRef GVName = GV->getName();
- setStr(Sym.IRName, GVName);
+ setStr(Sym.IRName, GV->getName());
+
+ static const DenseSet<StringRef> PreservedSymbolsSet =
+ buildPreservedSymbolsSet(GV->getParent()->getTargetTriple());
+ bool IsPreservedSymbol = PreservedSymbolsSet.contains(GV->getName());
- if (Used.count(GV) || isPreservedLibFuncName(GVName) ||
- isPreservedGlobalVarName(GVName))
+ if (Used.count(GV) || IsPreservedSymbol)
Sym.Flags |= 1 << storage::Symbol::FB_used;
if (GV->isThreadLocal())
Sym.Flags |= 1 << storage::Symbol::FB_tls;
@@ -350,6 +351,7 @@ Error Builder::build(ArrayRef<Module *> IRMods) {
setStr(Hdr.Producer, kExpectedProducerName);
setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple().str());
setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
+ TT = IRMods[0]->getTargetTriple();
for (auto *M : IRMods)
if (Error Err = addModule(M))
@@ -375,8 +377,7 @@ Error Builder::build(ArrayRef<Module *> IRMods) {
Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
StringTableBuilder &StrtabBuilder,
BumpPtrAllocator &Alloc) {
- const Triple &TT = Mods[0]->getTargetTriple();
- return Builder(Symtab, StrtabBuilder, Alloc, TT).build(Mods);
+ return Builder(Symtab, StrtabBuilder, Alloc).build(Mods);
}
// Upgrade a vector of bitcode modules created by an old version of LLVM by
diff --git a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
index 7f90d6b4fdacc..652bea9dc7f65 100644
--- a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
+++ b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
@@ -236,19 +236,8 @@ class RuntimeLibcallEmitter {
for (RuntimeLibcall &LibCall : RuntimeLibcallDefList)
Def2RuntimeLibcall[LibCall.getDef()] = &LibCall;
- ArrayRef<const Record *> AllRuntimeLibcallImplsRaw =
+ ArrayRef<const Record *> AllRuntimeLibcallImpls =
Records.getAllDerivedDefinitions("RuntimeLibcallImpl");
-
- SmallVector<const Record *, 1024> AllRuntimeLibcallImpls(
- AllRuntimeLibcallImplsRaw);
-
- // Sort by libcall impl name, not the enum name. This keeps the order
- // suitable for using the name table for libcall recognition binary search.
- llvm::sort(AllRuntimeLibcallImpls, [](const Record *A, const Record *B) {
- return A->getValueAsString("LibCallFuncName") <
- B->getValueAsString("LibCallFuncName");
- });
-
RuntimeLibcallImplDefList.reserve(AllRuntimeLibcallImpls.size());
size_t LibCallImplEnumVal = 1;
More information about the llvm-commits
mailing list