[clang] [lld] [llvm] Reland "[LTO][LLD] Prevent invalid LTO libfunc transforms (#164916)" (PR #190642)
via cfe-commits
cfe-commits at lists.llvm.org
Mon Apr 6 11:42:14 PDT 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-lld
@llvm/pr-subscribers-clang-codegen
Author: Daniel Thornburgh (mysterymath)
<details>
<summary>Changes</summary>
This reverts commit 1ec7e86b3a779df2a0af3f37e58c8f5b3a398d7f after issue #<!-- -->190072 was fixed.
---
Patch is 45.27 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/190642.diff
25 Files Affected:
- (modified) clang/lib/CodeGen/BackendUtil.cpp (+7-5)
- (modified) lld/COFF/InputFiles.cpp (+1-4)
- (modified) lld/COFF/LTO.cpp (+4)
- (modified) lld/COFF/LTO.h (+1)
- (modified) lld/COFF/SymbolTable.cpp (+24)
- (modified) lld/ELF/Driver.cpp (+19)
- (modified) lld/ELF/LTO.cpp (+4)
- (modified) lld/ELF/LTO.h (+1)
- (added) lld/test/COFF/lto-libcall-archive-bitcode.test (+51)
- (added) lld/test/ELF/lto/libcall-archive-bitcode.test (+54)
- (added) lld/test/wasm/lto/libcall-archive-bitcode.ll (+56)
- (modified) lld/wasm/LTO.cpp (+4)
- (modified) lld/wasm/LTO.h (+1)
- (modified) lld/wasm/SymbolTable.cpp (+23)
- (modified) llvm/docs/ReleaseNotes.md (+7)
- (modified) llvm/include/llvm/LTO/LTO.h (+25-4)
- (modified) llvm/include/llvm/LTO/LTOBackend.h (+12-10)
- (modified) llvm/lib/LTO/LTO.cpp (+52-19)
- (modified) llvm/lib/LTO/LTOBackend.cpp (+27-7)
- (modified) llvm/lib/LTO/LTOCodeGenerator.cpp (+2-2)
- (modified) llvm/lib/LTO/ThinLTOCodeGenerator.cpp (+3-1)
- (added) llvm/test/LTO/Resolution/X86/libcall-external.ll (+25)
- (added) llvm/test/LTO/Resolution/X86/libcall-in-thin-link.ll (+35)
- (added) llvm/test/LTO/Resolution/X86/libcall-in-tu.ll (+34)
- (modified) llvm/tools/llvm-lto2/llvm-lto2.cpp (+16)
``````````diff
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
index 5b8b4083c2ac0..74c8bf1c670da 100644
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -1410,12 +1410,14 @@ runThinLTOBackend(CompilerInstance &CI, ModuleSummaryIndex *CombinedIndex,
// FIXME: Both ExecuteAction and thinBackend set up optimization remarks for
// the same context.
+ // FIXME: This does not yet set the list of bitcode libfuncs that it isn't
+ // safe to call. This precludes bitcode libc in distributed ThinLTO.
finalizeLLVMOptimizationRemarks(M->getContext());
- if (Error E =
- thinBackend(Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
- ModuleToDefinedGVSummaries[M->getModuleIdentifier()],
- /*ModuleMap=*/nullptr, Conf.CodeGenOnly,
- /*IRAddStream=*/nullptr, CGOpts.CmdArgs)) {
+ if (Error E = thinBackend(
+ Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
+ ModuleToDefinedGVSummaries[M->getModuleIdentifier()],
+ /*ModuleMap=*/nullptr, Conf.CodeGenOnly, /*BitcodeLibFuncs=*/{},
+ /*IRAddStream=*/nullptr, CGOpts.CmdArgs)) {
handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
errs() << "Error running ThinLTO backend: " << EIB.message() << '\n';
});
diff --git a/lld/COFF/InputFiles.cpp b/lld/COFF/InputFiles.cpp
index e797da6effb35..9040d9653d2b2 100644
--- a/lld/COFF/InputFiles.cpp
+++ b/lld/COFF/InputFiles.cpp
@@ -25,7 +25,6 @@
#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
#include "llvm/IR/Mangler.h"
-#include "llvm/IR/RuntimeLibcalls.h"
#include "llvm/LTO/LTO.h"
#include "llvm/Object/Binary.h"
#include "llvm/Object/COFF.h"
@@ -1394,8 +1393,6 @@ void BitcodeFile::parse() {
// FIXME: Check nodeduplicate
comdat[i] =
symtab.addComdat(this, saver.save(obj->getComdatTable()[i].first));
- Triple tt(obj->getTargetTriple());
- RTLIB::RuntimeLibcallsInfo libcalls(tt);
for (const lto::InputFile::Symbol &objSym : obj->symbols()) {
StringRef symName = saver.save(objSym.getName());
int comdatIndex = objSym.getComdatIndex();
@@ -1445,7 +1442,7 @@ void BitcodeFile::parse() {
symtab.addRegular(this, symName, nullptr, fakeSC, 0, objSym.isWeak());
}
symbols.push_back(sym);
- if (objSym.isUsed() || objSym.isLibcall(libcalls))
+ if (objSym.isUsed())
symtab.ctx.config.gcroot.push_back(sym);
}
directives = saver.save(obj->getCOFFLinkerOpts());
diff --git a/lld/COFF/LTO.cpp b/lld/COFF/LTO.cpp
index 2d38a13830dad..445ea52e995da 100644
--- a/lld/COFF/LTO.cpp
+++ b/lld/COFF/LTO.cpp
@@ -288,3 +288,7 @@ std::vector<InputFile *> BitcodeCompiler::compile() {
return ret;
}
+
+void BitcodeCompiler::setBitcodeLibFuncs(ArrayRef<StringRef> bitcodeLibFuncs) {
+ ltoObj->setBitcodeLibFuncs(bitcodeLibFuncs);
+}
diff --git a/lld/COFF/LTO.h b/lld/COFF/LTO.h
index 6826251b5ffa7..73e855e567b09 100644
--- a/lld/COFF/LTO.h
+++ b/lld/COFF/LTO.h
@@ -45,6 +45,7 @@ class BitcodeCompiler {
void add(BitcodeFile &f);
std::vector<InputFile *> compile();
+ void setBitcodeLibFuncs(ArrayRef<StringRef> bitcodeLibFuncs);
private:
std::unique_ptr<llvm::lto::LTO> ltoObj;
diff --git a/lld/COFF/SymbolTable.cpp b/lld/COFF/SymbolTable.cpp
index 38a43390c15ab..fef9bc54fd8a6 100644
--- a/lld/COFF/SymbolTable.cpp
+++ b/lld/COFF/SymbolTable.cpp
@@ -1437,13 +1437,37 @@ void SymbolTable::compileBitcodeFiles() {
if (bitcodeFileInstances.empty())
return;
+ // Collect the bitcode library functions that are not safe to call because
+ // they were not yet brought in the link. (Such symbols are lazy.)
+ llvm::BumpPtrAllocator alloc;
+ llvm::StringSaver saver(alloc);
+ SmallVector<StringRef> bitcodeLibFuncs;
+ // Triple must be captured before the bitcode is moved into the compiler.
+ // Note that the below assumes that the set of possible libfuncs is roughly
+ // equivalent for all bitcode translation units.
+ llvm::Triple tt =
+ llvm::Triple(bitcodeFileInstances.front()->obj->getTargetTriple());
+ for (StringRef libFunc : lto::LTO::getLibFuncSymbols(tt, saver)) {
+ if (Symbol *sym = find(libFunc)) {
+ if (auto *l = dyn_cast<LazyArchive>(sym)) {
+ if (isBitcode(l->getMemberBuffer()))
+ bitcodeLibFuncs.push_back(libFunc);
+ } else if (auto *o = dyn_cast<LazyObject>(sym)) {
+ if (isBitcode(o->file->mb))
+ bitcodeLibFuncs.push_back(libFunc);
+ }
+ }
+ }
+
ScopedTimer t(ctx.ltoTimer);
lto.reset(new BitcodeCompiler(ctx));
+ lto->setBitcodeLibFuncs(bitcodeLibFuncs);
{
llvm::TimeTraceScope addScope("Add bitcode file instances");
for (BitcodeFile *f : bitcodeFileInstances)
lto->add(*f);
}
+
for (InputFile *newObj : lto->compile()) {
ObjFile *obj = cast<ObjFile>(newObj);
obj->parse();
diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
index 949314fd70ed2..09aa6af5ee2c7 100644
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -2774,8 +2774,27 @@ static void markBuffersAsDontNeed(Ctx &ctx, bool skipLinkedOutput) {
template <class ELFT>
void LinkerDriver::compileBitcodeFiles(bool skipLinkedOutput) {
llvm::TimeTraceScope timeScope("LTO");
+
+ // Collect the bitcode library functions that are not safe to call because
+ // they were not yet brought in the link. (Such symbols are lazy.)
+ llvm::BumpPtrAllocator alloc;
+ llvm::StringSaver saver(alloc);
+ SmallVector<StringRef> bitcodeLibFuncs;
+ if (!ctx.bitcodeFiles.empty()) {
+ // Triple must be captured before the bitcode is moved into the compiler.
+ // Note that the below assumes that the set of possible libfuncs is roughly
+ // equivalent for all bitcode translation units.
+ llvm::Triple tt =
+ llvm::Triple(ctx.bitcodeFiles.front()->obj->getTargetTriple());
+ for (StringRef libFunc : lto::LTO::getLibFuncSymbols(tt, saver))
+ if (Symbol *sym = ctx.symtab->find(libFunc);
+ sym && sym->isLazy() && isa<BitcodeFile>(sym->file))
+ bitcodeLibFuncs.push_back(libFunc);
+ }
+
// Compile bitcode files and replace bitcode symbols.
lto.reset(new BitcodeCompiler(ctx));
+ lto->setBitcodeLibFuncs(bitcodeLibFuncs);
for (BitcodeFile *file : ctx.bitcodeFiles)
lto->add(*file);
diff --git a/lld/ELF/LTO.cpp b/lld/ELF/LTO.cpp
index 352848af1551d..7b0fe2001439e 100644
--- a/lld/ELF/LTO.cpp
+++ b/lld/ELF/LTO.cpp
@@ -436,3 +436,7 @@ SmallVector<std::unique_ptr<InputFile>, 0> BitcodeCompiler::compile() {
}
return ret;
}
+
+void BitcodeCompiler::setBitcodeLibFuncs(ArrayRef<StringRef> bitcodeLibFuncs) {
+ ltoObj->setBitcodeLibFuncs(bitcodeLibFuncs);
+}
diff --git a/lld/ELF/LTO.h b/lld/ELF/LTO.h
index acf3bcff7f2f1..c8cb2156d90ca 100644
--- a/lld/ELF/LTO.h
+++ b/lld/ELF/LTO.h
@@ -43,6 +43,7 @@ class BitcodeCompiler {
void add(BitcodeFile &f);
SmallVector<std::unique_ptr<InputFile>, 0> compile();
+ void setBitcodeLibFuncs(ArrayRef<StringRef> bitcodeLibFuncs);
private:
Ctx &ctx;
diff --git a/lld/test/COFF/lto-libcall-archive-bitcode.test b/lld/test/COFF/lto-libcall-archive-bitcode.test
new file mode 100644
index 0000000000000..bd172f1ff3955
--- /dev/null
+++ b/lld/test/COFF/lto-libcall-archive-bitcode.test
@@ -0,0 +1,51 @@
+; REQUIRES: x86
+
+; RUN: rm -rf %t && split-file %s %t && cd %t
+; RUN: llvm-as main.ll -o main.obj
+; RUN: llvm-as puts.ll -o puts.obj
+; RUN: llvm-mc -filetype=obj -triple=x86_64-pc-windows-msvc printf.s -o printf.obj
+; RUN: llvm-ar rcs libc.lib puts.obj printf.obj
+
+;; Ensure that no printf->puts translation occurs during LTO because puts is in
+;; bitcode, but was not brought into the link. This would fail the link by
+;; extracting bitcode after LTO.
+; RUN: lld-link -out:out.exe -entry:main -subsystem:console -lldmap:- -nodefaultlib main.obj libc.lib | FileCheck %s
+
+;; Test the same behavior with lazy objects.
+; RUN: lld-link -out:out-lazy.exe -entry:main -subsystem:console -lldmap:- -nodefaultlib main.obj /start-lib puts.obj /end-lib printf.obj | FileCheck %s
+
+;; Test that translation DOES occur when puts is extracted and brought into the link.
+; RUN: lld-link -out:out-extracted.exe -entry:main -subsystem:console -lldmap:- -nodefaultlib main.obj puts.obj printf.obj | FileCheck %s --check-prefix=EXTRACTED
+
+; CHECK-NOT: puts
+; CHECK: printf
+
+; EXTRACTED: printf
+; EXTRACTED: puts
+
+;--- puts.ll
+target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+define i32 @puts(ptr nocapture readonly %0) noinline {
+ call void asm sideeffect "", ""()
+ ret i32 0
+}
+
+;--- printf.s
+.globl printf
+printf:
+ ret
+
+;--- main.ll
+target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+ at str = constant [5 x i8] c"foo\0A\00"
+
+define i32 @main() {
+ %call = call i32 (ptr, ...) @printf(ptr @str)
+ ret i32 0
+}
+
+declare i32 @printf(ptr, ...)
diff --git a/lld/test/ELF/lto/libcall-archive-bitcode.test b/lld/test/ELF/lto/libcall-archive-bitcode.test
new file mode 100644
index 0000000000000..00726a2e6aeb5
--- /dev/null
+++ b/lld/test/ELF/lto/libcall-archive-bitcode.test
@@ -0,0 +1,54 @@
+; REQUIRES: x86
+
+; RUN: rm -rf %t && split-file %s %t && cd %t
+; RUN: llvm-as main.ll -o main.o
+; RUN: llvm-as puts.ll -o puts.o
+; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux-gnu printf.s -o printf.o
+; RUN: llvm-ar rcs libc.a puts.o printf.o
+
+;; Ensure that no printf->puts translation occurs during LTO because puts is in
+;; bitcode, but was not brought into the link. This would fail the link by
+;; extracting bitcode after LTO.
+; RUN: ld.lld -o out main.o libc.a
+; RUN: llvm-nm out | FileCheck %s
+
+;; Test the same behavior with lazy objects.
+; RUN: ld.lld -o out-lazy main.o --start-lib puts.o --end-lib printf.o
+; RUN: llvm-nm out-lazy | FileCheck %s
+
+;; Test that translation DOES occur when puts is extracted and brought into the link.
+; RUN: ld.lld -o out-extracted main.o puts.o printf.o
+; RUN: llvm-nm out-extracted | FileCheck %s --check-prefix=EXTRACTED
+
+; CHECK-NOT: puts
+; CHECK: printf
+
+; EXTRACTED: printf
+; EXTRACTED: puts
+
+;--- puts.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define i32 @puts(ptr nocapture readonly %0) noinline {
+ call void asm sideeffect "", ""()
+ ret i32 0
+}
+
+;--- printf.s
+.globl printf
+printf:
+ ret
+
+;--- main.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+ at str = constant [5 x i8] c"foo\0A\00"
+
+define i32 @_start() {
+ %call = call i32 (ptr, ...) @printf(ptr @str)
+ ret i32 0
+}
+
+declare i32 @printf(ptr, ...)
diff --git a/lld/test/wasm/lto/libcall-archive-bitcode.ll b/lld/test/wasm/lto/libcall-archive-bitcode.ll
new file mode 100644
index 0000000000000..3b640efc1091f
--- /dev/null
+++ b/lld/test/wasm/lto/libcall-archive-bitcode.ll
@@ -0,0 +1,56 @@
+; REQUIRES: x86
+
+; RUN: rm -rf %t && split-file %s %t && cd %t
+; RUN: llvm-as main.ll -o main.o
+; RUN: llvm-as puts.ll -o puts.o
+; RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown printf.s -o printf.o
+; RUN: llvm-ar rcs libc.a puts.o printf.o
+
+;; Ensure that no printf->puts translation occurs during LTO because puts is in
+;; bitcode, but was not brought into the link. This would fail the link by
+;; extracting bitcode after LTO.
+; RUN: wasm-ld -o out.wasm main.o libc.a
+; RUN: obj2yaml out.wasm | FileCheck %s
+
+;; Test the same behavior with lazy objects.
+; RUN: wasm-ld -o out-lazy.wasm main.o --start-lib puts.o --end-lib printf.o
+; RUN: obj2yaml out-lazy.wasm | FileCheck %s
+
+;; Test that translation DOES occur when puts is extracted and brought into the link.
+; RUN: wasm-ld -o out-extracted.wasm main.o puts.o printf.o
+; RUN: obj2yaml out-extracted.wasm | FileCheck %s --check-prefix=EXTRACTED
+
+; CHECK-NOT: Name: puts
+; CHECK: Name: printf
+
+; EXTRACTED: Name: puts
+; EXTRACTED-NOT: Name: printf
+
+;--- puts.ll
+target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
+target triple = "wasm32-unknown-unknown"
+
+define i32 @puts(ptr nocapture readonly %0) noinline {
+ call void asm sideeffect "", ""()
+ ret i32 0
+}
+
+;--- printf.s
+.globl printf
+printf:
+ .functype printf (i32, i32) -> (i32)
+ i32.const 0
+ end_function
+
+;--- main.ll
+target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
+target triple = "wasm32-unknown-unknown"
+
+ at str = constant [5 x i8] c"foo\0A\00"
+
+define i32 @_start() {
+ %call = call i32 (ptr, ...) @printf(ptr @str)
+ ret i32 0
+}
+
+declare i32 @printf(ptr, ...)
\ No newline at end of file
diff --git a/lld/wasm/LTO.cpp b/lld/wasm/LTO.cpp
index 9fcb95b84b545..2c068bf518905 100644
--- a/lld/wasm/LTO.cpp
+++ b/lld/wasm/LTO.cpp
@@ -195,6 +195,10 @@ static void thinLTOCreateEmptyIndexFiles() {
}
}
+void BitcodeCompiler::setBitcodeLibFuncs(ArrayRef<StringRef> bitcodeLibFuncs) {
+ ltoObj->setBitcodeLibFuncs(bitcodeLibFuncs);
+}
+
// Merge all the bitcode files we have seen, codegen the result
// and return the resulting objects.
SmallVector<InputFile *, 0> BitcodeCompiler::compile() {
diff --git a/lld/wasm/LTO.h b/lld/wasm/LTO.h
index 21b1d59024663..6fa110d6099bf 100644
--- a/lld/wasm/LTO.h
+++ b/lld/wasm/LTO.h
@@ -46,6 +46,7 @@ class BitcodeCompiler {
void add(BitcodeFile &f);
SmallVector<InputFile *, 0> compile();
+ void setBitcodeLibFuncs(ArrayRef<StringRef> bitcodeLibFuncs);
private:
std::unique_ptr<llvm::lto::LTO> ltoObj;
diff --git a/lld/wasm/SymbolTable.cpp b/lld/wasm/SymbolTable.cpp
index 05e653ea23eda..93d3e5f71a3e5 100644
--- a/lld/wasm/SymbolTable.cpp
+++ b/lld/wasm/SymbolTable.cpp
@@ -82,8 +82,31 @@ void SymbolTable::compileBitcodeFiles() {
// Prevent further LTO objects being included
BitcodeFile::doneLTO = true;
+ // Collect the bitcode library functions that are not safe to call because
+ // they were not yet brought in the link. (Such symbols are lazy.)
+ llvm::BumpPtrAllocator alloc;
+ llvm::StringSaver saver(alloc);
+ SmallVector<StringRef> bitcodeLibFuncs;
+ if (!ctx.bitcodeFiles.empty()) {
+ // Triple must be captured before the bitcode is moved into the compiler.
+ // Note that the below assumes that the set of possible libfuncs is
+ // equivalent for all bitcode translation units.
+ llvm::Triple tt =
+ llvm::Triple(ctx.bitcodeFiles.front()->obj->getTargetTriple());
+ for (StringRef libFunc : llvm::lto::LTO::getLibFuncSymbols(tt, saver)) {
+ if (Symbol *sym = find(libFunc)) {
+ if (auto *lazy = dyn_cast<LazySymbol>(sym)) {
+ if (isa<BitcodeFile>(lazy->getFile()))
+ bitcodeLibFuncs.push_back(libFunc);
+ }
+ }
+ }
+ }
+
// Compile bitcode files and replace bitcode symbols.
lto.reset(new BitcodeCompiler);
+ lto->setBitcodeLibFuncs(bitcodeLibFuncs);
+
for (BitcodeFile *f : ctx.bitcodeFiles)
lto->add(*f);
diff --git a/llvm/docs/ReleaseNotes.md b/llvm/docs/ReleaseNotes.md
index d0d8b9f4ddabc..701b386dba73e 100644
--- a/llvm/docs/ReleaseNotes.md
+++ b/llvm/docs/ReleaseNotes.md
@@ -101,6 +101,13 @@ Changes to LLVM infrastructure
this may fail if symlink permissions are not available.
* Added ``readlink``, which reads the target of a symbolic link.
+* Bitcode libraries can now implement compiler-managed library functions
+ (libcalls) without causing incorrect API manipulation or undefined references
+ ([#177046](https://github.com/llvm/llvm-project/pull/125687)). Note that
+ there are still issues with invalid compiler reasoning about some functions
+ in bitcode, e.g. `malloc`. Not yet supported on MachO or when using
+ distributed ThinLTO.
+
Changes to building LLVM
------------------------
diff --git a/llvm/include/llvm/LTO/LTO.h b/llvm/include/llvm/LTO/LTO.h
index 3fec06b8bd78d..aba2661e81c47 100644
--- a/llvm/include/llvm/LTO/LTO.h
+++ b/llvm/include/llvm/LTO/LTO.h
@@ -179,7 +179,8 @@ class InputFile {
// may emit references to. Such symbols must be considered external, as
// removing them or modifying their interfaces would invalidate the code
// generator's knowledge about them.
- bool isLibcall(const RTLIB::RuntimeLibcallsInfo &Libcalls) const;
+ bool isLibcall(const TargetLibraryInfo &TLI,
+ const RTLIB::RuntimeLibcallsInfo &Libcalls) const;
};
/// A range over the symbols in this InputFile.
@@ -308,7 +309,8 @@ class ThinBackendProc {
using ThinBackendFunction = std::function<std::unique_ptr<ThinBackendProc>(
const Config &C, ModuleSummaryIndex &CombinedIndex,
const DenseMap<StringRef, GVSummaryMapTy> &ModuleToDefinedGVSummaries,
- AddStreamFn AddStream, FileCache Cache)>;
+ AddStreamFn AddStream, FileCache Cache,
+ ArrayRef<StringRef> BitcodeLibFuncs)>;
/// This type defines the behavior following the thin-link phase during ThinLTO.
/// It encapsulates a backend function and a strategy for thread pool
@@ -323,10 +325,11 @@ struct ThinBackend {
std::unique_ptr<ThinBackendProc> operator()(
const Config &Conf, ModuleSummaryIndex &CombinedIndex,
const DenseMap<StringRef, GVSummaryMapTy> &ModuleToDefinedGVSummaries,
- AddStreamFn AddStream, FileCache Cache) {
+ AddStreamFn AddStream, FileCache Cache,
+ ArrayRef<StringRef> BitcodeLibFuncs) {
assert(isValid() && "Invalid backend function");
return Func(Conf, CombinedIndex, ModuleToDefinedGVSummaries,
- std::move(AddStream), std::move(Cache));
+ std::move(AddStream), std::move(Cache), BitcodeLibFuncs);
}
ThreadPoolStrategy getParallelism() const { return Parallelism; }
bool isValid() const { return static_cast<bool>(Func); }
@@ -446,6 +449,11 @@ class LTO {
LLVM_ABI Error add(std::unique_ptr<InputFile> Obj,
ArrayRef<SymbolResolution> Res);
+ /// Set the list of functions implemented in bitcode that were not extracted
+ /// from an archive. Such functions may not be referenced, as they have
+ /// lost their opportunity to be defined.
+ LLVM_ABI void setBitcodeLibFuncs(ArrayRef<StringRef> BitcodeLibFuncs);
+
/// Returns an upper bound on the number of tasks that the client may expect.
/// This may only be called after all IR object files have been added. For a
/// full description of tasks see LTOBackend.h.
@@ -466,6 +474,14 @@ class LTO {
LLVM_ABI static SmallVector<const char *>
getRuntimeLibcallSymbols(const Triple &TT);
+ /// Static method that returns a list of library function symbols that can be
+ /// generated by LTO but might not be visible from bitcode symbol table.
+ /// Unlike the runtime libcalls, the linker can report to the code generator
+ /// which of these are actually available in the link, and the code generator
+ /// can then only reference that set of symbols.
+ LLVM_ABI static SmallVector<StringRef>
+ getLibFuncSymbols(const Triple &TT, llvm::StringSaver &Saver);
+
protected:
// Called at the start of run().
virtual Error serializeInputsForDistribution() { return Error::success(); }
@@ -657,6 +673,11 @@ class LTO {
// Setup optimization remarks according to the provided configuration.
Error setupOptimizationRemarks();
+ // LibFuncs that were implemented in bitcode but were not extracted
+ // from their libraries. Such functions cannot safely be called, since
+ // they have lost their opportunity to be defined.
+ SmallVector<StringRef> BitcodeLibFuncs;
+
public:
/// Helper to emit an optimization remark during the LTO link when outside of
/// the standard optimization pass pipeline.
diff --git a/llvm/include/llvm/LTO/LTOBackend.h b/llvm/include/llvm/LTO/LTOBackend.h
index 48ad5aa64f61f..4bb38529ec754 100644
--- a/llvm/include/llvm/LTO/LTOBackend.h
+++ b/llvm/include/llvm/LTO/LTOBackend.h
@@ -39,13 +39,15 @@ LLVM_ABI bool opt(const Config &Conf, TargetMachine *TM, unsigned Task,
Module &Mod, bool IsThinLTO,
ModuleSummaryIndex *ExportSummary,
const ModuleSummaryIndex *ImportSummary,
- const std::vector<uint8_t> &CmdArgs);
+ con...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/190642
More information about the cfe-commits
mailing list