[lld] [llvm] [dyndbg][LLD][ELF] Initial LLD support for dynamic debugging (PR #214188)
Andrew Ng via llvm-commits
llvm-commits at lists.llvm.org
Wed Aug 5 03:20:43 PDT 2026
https://github.com/nga888 created https://github.com/llvm/llvm-project/pull/214188
The key changes are:
* Enable the nested "inner" unoptimized dynamic debugging relocatable link within the "outer" optimized link.
* Handle the dependencies between the "inner" unoptimized objects and the "outer" optimized objects.
* Make the "inner" unoptimized relocatable link more like a final executable link (to reduce output size overheads) except when the "outer" is itself a relocatable link.
RFC: https://discourse.llvm.org/t/90113
>From edcd2afb978f0fb99f743be2ae17744bfd48e1d7 Mon Sep 17 00:00:00 2001
From: Andrew Ng <andrew.ng at sony.com>
Date: Tue, 4 Aug 2026 16:53:52 +0100
Subject: [PATCH] [dyndbg][LLD][ELF] Initial LLD support for dynamic debugging
The key changes are:
* Enable the nested "inner" unoptimized dynamic debugging relocatable
link within the "outer" optimized link.
* Handle the dependencies between the "inner" unoptimized objects and
the "outer" optimized objects.
* Make the "inner" unoptimized relocatable link more like a final
executable link (to reduce output size overheads) except when the
"outer" is itself a relocatable link.
RFC: https://discourse.llvm.org/t/90113
---
lld/Common/CommonLinkerContext.cpp | 14 +
lld/ELF/Config.h | 19 +-
lld/ELF/Driver.cpp | 79 +++-
lld/ELF/InputFiles.cpp | 91 +++-
lld/ELF/InputFiles.h | 6 +
lld/ELF/LinkerScript.cpp | 4 +-
lld/ELF/MarkLive.cpp | 15 +-
lld/ELF/Symbols.h | 5 +
lld/ELF/SyntheticSections.cpp | 37 ++
lld/ELF/SyntheticSections.h | 14 +
lld/ELF/Writer.cpp | 43 +-
.../ELF/Inputs/trace-symbols-dyndbg-opt.s | 4 +
.../ELF/Inputs/trace-symbols-dyndbg-unopt.s | 5 +
lld/test/ELF/dynamic-debug.test | 401 ++++++++++++++++++
lld/test/ELF/trace-symbols.s | 51 ++-
llvm/include/llvm/BinaryFormat/ELF.h | 1 +
16 files changed, 747 insertions(+), 42 deletions(-)
create mode 100644 lld/test/ELF/Inputs/trace-symbols-dyndbg-opt.s
create mode 100644 lld/test/ELF/Inputs/trace-symbols-dyndbg-unopt.s
create mode 100644 lld/test/ELF/dynamic-debug.test
diff --git a/lld/Common/CommonLinkerContext.cpp b/lld/Common/CommonLinkerContext.cpp
index 12f56bc10ec96..cafd78df4a2ba 100644
--- a/lld/Common/CommonLinkerContext.cpp
+++ b/lld/Common/CommonLinkerContext.cpp
@@ -22,7 +22,14 @@ using namespace lld;
// state.
static CommonLinkerContext *lctx;
+static uint32_t numNestedCtx;
+
CommonLinkerContext::CommonLinkerContext() {
+ if (lctx) {
+ ++numNestedCtx;
+ return;
+ }
+
lctx = this;
// Fire off the static initializations in CGF's constructor.
codegen::RegisterCodeGenFlags CGF;
@@ -34,6 +41,13 @@ CommonLinkerContext::~CommonLinkerContext() {
// new in SpecificAlloc::create().
for (auto &it : instances)
it.second->~SpecificAllocBase();
+
+ if (numNestedCtx) {
+ assert(lctx != this);
+ --numNestedCtx;
+ return;
+ }
+
lctx = nullptr;
}
diff --git a/lld/ELF/Config.h b/lld/ELF/Config.h
index 54e0aa58591ad..de61f3674d4ef 100644
--- a/lld/ELF/Config.h
+++ b/lld/ELF/Config.h
@@ -209,6 +209,7 @@ class LinkerDriver {
void linkerMain(ArrayRef<const char *> args);
void addFile(StringRef path, bool withLOption);
void addLibrary(StringRef name);
+ void addFile(std::unique_ptr<ELFFileBase> ef);
private:
Ctx &ctx;
@@ -233,8 +234,8 @@ class LinkerDriver {
public:
// See InputFile::groupId.
- uint32_t nextGroupId;
- bool isInGroup;
+ uint32_t nextGroupId = 0;
+ bool isInGroup = false;
std::unique_ptr<InputFile> armCmseImpLib;
SmallVector<std::pair<StringRef, unsigned>, 0> archiveFiles;
};
@@ -646,6 +647,8 @@ struct InStruct {
std::unique_ptr<SymtabShndxSection> symTabShndx;
std::unique_ptr<SyntheticSection> hexagonAttributes;
std::unique_ptr<SyntheticSection> riscvAttributes;
+ std::unique_ptr<SyntheticSection> dynDbg;
+ std::unique_ptr<SyntheticSection> dynDbgNote;
};
struct Ctx : CommonLinkerContext {
@@ -784,6 +787,18 @@ struct Ctx : CommonLinkerContext {
llvm::raw_fd_ostream openAuxiliaryFile(llvm::StringRef, std::error_code &);
std::optional<AArch64PauthAbiCoreInfo> aarch64PauthAbiCoreInfo;
+
+ // True if performing the embedded unoptimized dynamic debugging relocatable
+ // link.
+ bool inDynDbgLink = false;
+ // True if performing dynamic debugging style relocatable link rather than a
+ // regular relocatable link.
+ bool dynDbgRelocatable = false;
+ // True if the link contains dynamic debugging.
+ bool hasDynDbg = false;
+ // Pointer to the output of the embedded unoptimized dynamic debugging
+ // relocatable link.
+ std::unique_ptr<llvm::FileOutputBuffer> dynDbgOutput;
};
// The first two elements of versionDefinitions represent VER_NDX_LOCAL and
diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
index 0393410b35d4d..7130da9608e61 100644
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -113,6 +113,22 @@ llvm::raw_fd_ostream Ctx::openAuxiliaryFile(llvm::StringRef filename,
return {filename, ec, flags};
}
+static void initContext(Ctx &ctx, LinkerScript &script, StringRef arg0,
+ llvm::raw_ostream &stdoutOS,
+ llvm::raw_ostream &stderrOS, bool exitEarly,
+ bool disableOutput) {
+ ErrorHandler &e = ctx.e;
+ e.initialize(stdoutOS, stderrOS, exitEarly, disableOutput);
+ e.logName = args::getFilenameWithoutExe(arg0);
+ e.errorLimitExceededMsg = "too many errors emitted, stopping now (use "
+ "--error-limit=0 to see all errors)";
+ ctx.script = &script;
+ ctx.symAux.emplace_back();
+ ctx.symtab = std::make_unique<SymbolTable>(ctx);
+
+ ctx.arg.progName = arg0;
+}
+
namespace lld {
namespace elf {
bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
@@ -120,19 +136,9 @@ bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
// This driver-specific context will be freed later by unsafeLldMain().
auto *context = new Ctx;
Ctx &ctx = *context;
-
- context->e.initialize(stdoutOS, stderrOS, exitEarly, disableOutput);
- context->e.logName = args::getFilenameWithoutExe(args[0]);
- context->e.errorLimitExceededMsg =
- "too many errors emitted, stopping now (use "
- "--error-limit=0 to see all errors)";
-
LinkerScript script(ctx);
- ctx.script = &script;
- ctx.symAux.emplace_back();
- ctx.symtab = std::make_unique<SymbolTable>(ctx);
-
- ctx.arg.progName = args[0];
+ initContext(ctx, script, args[0], stdoutOS, stderrOS, exitEarly,
+ disableOutput);
ctx.driver.linkerMain(args);
@@ -301,6 +307,11 @@ void LinkerDriver::addLibrary(StringRef name) {
{name});
}
+// Add an ELF input file directly.
+void LinkerDriver::addFile(std::unique_ptr<ELFFileBase> ef) {
+ files.push_back(std::move(ef));
+}
+
// This function is called on startup. We need this for LTO since
// LTO calls LLVM functions to compile bitcode files to native code.
// Technically this can be delayed until we read bitcode files, but
@@ -2230,8 +2241,6 @@ void LinkerDriver::createFiles(opt::InputArgList &args) {
// Iterate over argv to process input files and positional arguments.
std::optional<MemoryBufferRef> defaultScript;
- nextGroupId = 0;
- isInGroup = false;
bool hasInput = false, hasScript = false;
for (auto *arg : args) {
switch (arg->getOption().getID()) {
@@ -3240,6 +3249,41 @@ static void postParseObjectFile(ELFFileBase *file) {
}
}
+template <class ELFT> static void linkDynamicDebug(Ctx &ctx) {
+ Ctx dc;
+ LinkerScript script(dc);
+ initContext(dc, script, ctx.arg.progName, ctx.e.outs(), ctx.e.errs(),
+ ctx.e.exitEarly, ctx.e.disableOutput);
+ dc.inDynDbgLink = true;
+ dc.dynDbgRelocatable = !ctx.arg.relocatable;
+
+ for (auto *file : ctx.objectFiles) {
+ auto *obj = cast<ObjFile<ELFT>>(file);
+ if (obj->dynDbgSec) {
+ auto content = obj->dynDbgSec->content();
+ MemoryBufferRef mb({(const char *)content.data(), content.size()},
+ obj->mb.getBufferIdentifier());
+ dc.driver.addFile(createObjFile(dc, mb));
+ }
+ }
+
+ if (errCount(ctx))
+ return;
+
+ std::vector<const char *> args{
+ dc.arg.progName.data(), "-r", "-o", "-",
+ dc.saver.save(Twine("-O") + Twine(ctx.arg.optimize)).data()};
+ if (ctx.arg.resolveGroups)
+ args.push_back("--force-group-allocation");
+ dc.driver.linkerMain(args);
+ if (errCount(dc) > 0 || !dc.dynDbgOutput) {
+ Err(ctx) << "Failed to create relocatable dynamic debug object";
+ return;
+ }
+
+ ctx.dynDbgOutput.swap(dc.dynDbgOutput);
+}
+
// Do actual linking. Note that when this function is called,
// all linker scripts have already been parsed.
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
@@ -3533,6 +3577,13 @@ template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
createTaggedSymbols(ctx);
}
+ if (ctx.hasDynDbg) {
+ llvm::TimeTraceScope timeScope("Link dynamic debugging");
+ linkDynamicDebug<ELFT>(ctx);
+ if (errCount(ctx))
+ return;
+ }
+
// Create synthesized sections such as .got and .plt. This is called before
// processSectionCommands() so that they can be placed by SECTIONS commands.
createSyntheticSections<ELFT>(ctx);
diff --git a/lld/ELF/InputFiles.cpp b/lld/ELF/InputFiles.cpp
index 05c0f3f1c445b..31c22472519d5 100644
--- a/lld/ELF/InputFiles.cpp
+++ b/lld/ELF/InputFiles.cpp
@@ -588,6 +588,7 @@ template <class ELFT> void ObjFile<ELFT>::parse(bool ignoreComdats) {
if (LLVM_LIKELY(sec.sh_type == SHT_PROGBITS))
continue;
+
if (LLVM_LIKELY(sec.sh_type == SHT_GROUP)) {
StringRef signature = getShtGroupSignature(objSections, sec);
ArrayRef<Elf_Word> entries =
@@ -640,6 +641,26 @@ template <class ELFT> void ObjFile<ELFT>::parse(bool ignoreComdats) {
continue;
}
+ if (sec.sh_type == SHT_LLVM_DYNDBG_ELF) {
+ // Check for presence of dynamic debugging section and create the input
+ // section but mark for discard.
+ StringRef name = check(obj.getSectionName(sec, shstrtab));
+ if (name == dynDbgSecName) {
+ sections[i] = &InputSection::discarded;
+ dynDbgSec = std::make_unique<InputSection>(*this, sec, name);
+ ctx.hasDynDbg = true;
+
+ // If ICF is enabled, warn and disable it because it's incompatible with
+ // dynamic debugging.
+ if (ctx.arg.icf != ICFLevel::None) {
+ Warn(ctx) << "ICF disabled because it is incompatible with dynamic "
+ "debugging";
+ ctx.arg.icf = ICFLevel::None;
+ }
+ }
+ continue;
+ }
+
switch (ctx.arg.emachine) {
case EM_ARM:
if (sec.sh_type == SHT_ARM_ATTRIBUTES) {
@@ -827,7 +848,9 @@ void ObjFile<ELFT>::initializeSections(bool ignoreComdats,
}
switch (type) {
case SHT_GROUP: {
- if (!ctx.arg.relocatable)
+ // Discard groups for the embedded unoptimized dynamic debugging
+ // relocatable link.
+ if (!ctx.arg.relocatable || ctx.dynDbgRelocatable)
sections[i] = &InputSection::discarded;
// Use the verdict parse() recorded for this group instead of repeating
// the signature hashing and comdatGroups lookup.
@@ -1246,6 +1269,72 @@ void ObjFile<ELFT>::initializeSymbols(const object::ELFFile<ELFT> &obj) {
sym->isUsedInRegularObj = true;
sym->referenced = true;
}
+
+ // Process the undefined symbols of the "inner" embedded unoptimized dynamic
+ // debugging object to ensure that the "outer" ELF contains the dependencies
+ // of the "inner" ELF. Also tag which "outer" global symbols are dynamic
+ // debugging references, i.e. used in an "inner" relocation for a SHT_PROGBITS
+ // and SHF_ALLOC section, via the `isDynDbgRef` flag.
+ if (dynDbgSec) {
+ auto content = dynDbgSec->content();
+ MemoryBufferRef dbgMb({(const char *)content.data(), content.size()},
+ mb.getBufferIdentifier());
+ std::unique_ptr<ELFFileBase> efb = createObjFile(ctx, dbgMb);
+ ObjFile<ELFT> *dbgObj = dyn_cast<ObjFile<ELFT>>(efb.get());
+ if (dbgObj) {
+ SmallVector<bool, 0> globalUsed(dbgObj->numSymbols - dbgObj->firstGlobal);
+ ArrayRef<Elf_Shdr> shdrs = dbgObj->template getELFShdrs<ELFT>();
+ for (size_t i = 0, end = shdrs.size(); i != end; ++i) {
+ const Elf_Shdr &sh = shdrs[i];
+ if (!isStaticRelSecType(sh.sh_type))
+ continue;
+
+ const Elf_Shdr &target = shdrs[sh.sh_info];
+ if (target.sh_type != SHT_PROGBITS ||
+ (target.sh_flags & SHF_ALLOC) == 0)
+ continue;
+
+ auto setSymUsed = [&,
+ firstGlobal = dbgObj->firstGlobal](uint32_t symIdx) {
+ if (symIdx >= firstGlobal)
+ globalUsed[symIdx - firstGlobal] = true;
+ };
+
+ auto isec = std::make_unique<InputSection>(*dbgObj, sh, StringRef());
+ isec->relSecIdx = i;
+ auto relocs = isec->template relsOrRelas<ELFT>(/*supportsCrel=*/false);
+ if (relocs.areRelocsRel()) {
+ for (auto const &r : relocs.rels)
+ setSymUsed(r.getSymbol(ctx.arg.isMips64EL));
+ } else {
+ for (auto const &r : relocs.relas)
+ setSymUsed(r.getSymbol(ctx.arg.isMips64EL));
+ }
+ }
+
+ ArrayRef<Elf_Sym> dbgSyms = dbgObj->template getGlobalELFSyms<ELFT>();
+ assert(dbgSyms.size() == globalUsed.size());
+ for (size_t i = 0, end = dbgSyms.size(); i != end; ++i) {
+ const Elf_Sym &s = dbgSyms[i];
+ if (s.st_shndx != SHN_UNDEF)
+ continue;
+
+ StringRef name = CHECK2(s.getName(dbgObj->stringTable), this);
+ Symbol *sym = symtab->addSymbol(
+ Undefined{this, name, s.getBinding(), s.st_other, s.getType()});
+ sym->isUsedInRegularObj = true;
+ sym->referenced = true;
+ if (globalUsed[i]) {
+ sym->isDynDbgRef = true;
+ if (sym->traced)
+ Msg(ctx) << this << ": dynamic debugging reference to " << name;
+ }
+ }
+ } else {
+ Err(ctx) << this << ": " << dynDbgSecName
+ << " contains an incompatible ELF type";
+ }
+ }
}
template <class ELFT>
diff --git a/lld/ELF/InputFiles.h b/lld/ELF/InputFiles.h
index 0ded9b2fa38e2..22c29f9ea7909 100644
--- a/lld/ELF/InputFiles.h
+++ b/lld/ELF/InputFiles.h
@@ -268,6 +268,9 @@ template <class ELFT> class ObjFile : public ELFFileBase {
// Pointer to this input file's .llvm_addrsig section, if it has one.
const Elf_Shdr *addrsigSec = nullptr;
+ // Embedded unoptimized dynamic debug input section.
+ std::unique_ptr<InputSection> dynDbgSec;
+
// SHT_LLVM_CALL_GRAPH_PROFILE section index.
uint32_t cgProfileSectionIndex = 0;
@@ -389,6 +392,9 @@ std::unique_ptr<ELFFileBase> createObjFile(Ctx &, MemoryBufferRef mb,
std::string replaceThinLTOSuffix(Ctx &, StringRef path);
+// Name of embedded unoptimized dynamic debug input/output section.
+constexpr StringRef dynDbgSecName = ".debug_llvm_dyndbg";
+
} // namespace elf
} // namespace lld
diff --git a/lld/ELF/LinkerScript.cpp b/lld/ELF/LinkerScript.cpp
index 64fb717e17d9d..d7a057c1915b0 100644
--- a/lld/ELF/LinkerScript.cpp
+++ b/lld/ELF/LinkerScript.cpp
@@ -67,7 +67,9 @@ StringRef LinkerScript::getOutputSectionName(const InputSectionBase *s) const {
return ss.save(".rela" + out->name);
return ss.save(".rel" + out->name);
}
- if (ctx.arg.relocatable)
+ // Use default LLD behavior for the embedded unoptimized dynamic debugging
+ // relocatable link.
+ if (ctx.arg.relocatable && !ctx.dynDbgRelocatable)
return s->name;
}
diff --git a/lld/ELF/MarkLive.cpp b/lld/ELF/MarkLive.cpp
index 2820818133d5c..8e5071cdc0073 100644
--- a/lld/ELF/MarkLive.cpp
+++ b/lld/ELF/MarkLive.cpp
@@ -363,11 +363,20 @@ template <class ELFT, bool TrackWhyLive>
void MarkLive<ELFT, TrackWhyLive>::run() {
// Add GC root symbols.
- // Preserve externally-visible symbols if the symbols defined by this
- // file can interpose other ELF file's symbols at runtime.
- for (Symbol *sym : ctx.symtab->getSymbols())
+ for (Symbol *sym : ctx.symtab->getSymbols()) {
+ // For now, preserve all symbols required by the embedded unoptimized part
+ // of dynamic debugging. TODO: better support for `--gc-sections`.
+ if (sym->isDynDbgRef) {
+ markSymbol(sym, "dynamic debugging");
+ sym->setFlags(USED);
+ continue;
+ }
+
+ // Preserve externally-visible symbols if the symbols defined by this
+ // file can interpose other ELF file's symbols at runtime.
if (sym->isExported)
markSymbol(sym, "externally visible symbol");
+ }
markSymbol(ctx.symtab->find(ctx.arg.entry), "entry point");
markSymbol(ctx.symtab->find(ctx.arg.init), "initializer function");
diff --git a/lld/ELF/Symbols.h b/lld/ELF/Symbols.h
index 0893776882dc6..9a0909037f51e 100644
--- a/lld/ELF/Symbols.h
+++ b/lld/ELF/Symbols.h
@@ -341,6 +341,11 @@ class Symbol {
LLVM_PREFERRED_TYPE(bool)
uint8_t referencedAfterWrap : 1;
+ // True if this symbol is referenced by the embedded unoptimized part of
+ // dynamic debugging.
+ LLVM_PREFERRED_TYPE(bool)
+ uint8_t isDynDbgRef : 1;
+
void setFlags(uint16_t bits) {
flags.fetch_or(bits, std::memory_order_relaxed);
}
diff --git a/lld/ELF/SyntheticSections.cpp b/lld/ELF/SyntheticSections.cpp
index 6bac881446fd0..84099e6e7503c 100644
--- a/lld/ELF/SyntheticSections.cpp
+++ b/lld/ELF/SyntheticSections.cpp
@@ -4411,6 +4411,36 @@ size_t MemtagGlobalDescriptors::getSize() const {
return createMemtagGlobalDescriptors(ctx, symbols);
}
+DynamicDebugSection::DynamicDebugSection(Ctx &ctx)
+ : SyntheticSection(ctx, dynDbgSecName, SHT_LLVM_DYNDBG_ELF, 0, 8) {
+ assert(ctx.dynDbgOutput);
+}
+
+size_t DynamicDebugSection::getSize() const {
+ return ctx.dynDbgOutput->getBufferSize();
+}
+
+void DynamicDebugSection::writeTo(uint8_t *buf) {
+ memcpy(buf, ctx.dynDbgOutput->getBufferStart(),
+ ctx.dynDbgOutput->getBufferSize());
+}
+
+DynamicDebugNote::DynamicDebugNote(Ctx &ctx)
+ : SyntheticSection(ctx, ".note.llvm.dyndbg", SHT_NOTE, 0, 4) {}
+
+size_t DynamicDebugNote::getSize() const {
+ return /*hdrsz=*/12 + /*namesz=*/8 + /*descsz=*/sizeof(uint32_t);
+}
+
+void DynamicDebugNote::writeTo(uint8_t *buf) {
+ write32(ctx, buf, 5); // Name size
+ write32(ctx, buf + 4, sizeof(uint32_t)); // Content size
+ write32(ctx, buf + 8, NT_LLVM_DYNAMIC_DEBUGGING); // Type
+ memcpy(buf + 12, "LLVM", 5); // Name string
+ uint32_t version = 0;
+ write32(ctx, buf + 20, version);
+}
+
static OutputSection *findSection(Ctx &ctx, StringRef name) {
for (SectionCommand *cmd : ctx.script->sectionCommands)
if (auto *osd = dyn_cast<OutputDesc>(cmd))
@@ -4635,6 +4665,13 @@ template <class ELFT> void elf::createSyntheticSections(Ctx &ctx) {
add(*ctx.in.shStrTab);
if (ctx.in.strTab)
add(*ctx.in.strTab);
+
+ if (ctx.dynDbgOutput) {
+ ctx.in.dynDbg = std::make_unique<DynamicDebugSection>(ctx);
+ add(*ctx.in.dynDbg);
+ ctx.in.dynDbgNote = std::make_unique<DynamicDebugNote>(ctx);
+ add(*ctx.in.dynDbgNote);
+ }
}
template void elf::splitSections<ELF32LE>(Ctx &);
diff --git a/lld/ELF/SyntheticSections.h b/lld/ELF/SyntheticSections.h
index 19d4461348f3f..fefd21b336e24 100644
--- a/lld/ELF/SyntheticSections.h
+++ b/lld/ELF/SyntheticSections.h
@@ -1317,6 +1317,20 @@ class MemtagGlobalDescriptors final : public SyntheticSection {
SmallVector<const Symbol *, 0> symbols;
};
+class DynamicDebugSection final : public SyntheticSection {
+public:
+ DynamicDebugSection(Ctx &);
+ size_t getSize() const override;
+ void writeTo(uint8_t *buf) override;
+};
+
+class DynamicDebugNote final : public SyntheticSection {
+public:
+ DynamicDebugNote(Ctx &);
+ size_t getSize() const override;
+ void writeTo(uint8_t *buf) override;
+};
+
template <class ELFT> void createSyntheticSections(Ctx &);
InputSection *createInterpSection(Ctx &);
MergeInputSection *createCommentSection(Ctx &);
diff --git a/lld/ELF/Writer.cpp b/lld/ELF/Writer.cpp
index 8cf88cd99cf8a..bd0d394386aac 100644
--- a/lld/ELF/Writer.cpp
+++ b/lld/ELF/Writer.cpp
@@ -365,10 +365,14 @@ template <class ELFT> void Writer<ELFT>::run() {
if (errCount(ctx))
return;
- // With -o -, write to lld::outs() (the stdoutOS argument of
+ // Capture output for the embedded unoptimized dynamic debugging relocatable
+ // link.
+ // Otherwise, with -o -, write to lld::outs() (the stdoutOS argument of
// link()) instead of committing the buffer, which would write to the
// process's stdout.
- if (ctx.arg.outputFile == "-") {
+ if (ctx.inDynDbgLink)
+ ctx.dynDbgOutput.swap(buffer);
+ else if (ctx.arg.outputFile == "-") {
ctx.e.outs() << StringRef(
reinterpret_cast<const char *>(buffer->getBufferStart()),
buffer->getBufferSize());
@@ -1914,6 +1918,41 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
// called after processSymbolAssignments() because it needs to know whether
// a linker-script-defined symbol is absolute.
scanRelocations<ELFT>(ctx);
+
+ // Process symbols referenced by the embedded unoptimized part of dynamic
+ // debugging.
+ if (ctx.hasDynDbg) {
+ bool ignoreUnresolved =
+ (ctx.arg.unresolvedSymbols == UnresolvedPolicy::Ignore);
+ bool warnOnly = (ctx.arg.unresolvedSymbols == UnresolvedPolicy::Warn);
+ for (Symbol *sym : ctx.symtab->getSymbols()) {
+ if (!sym->isDynDbgRef)
+ continue;
+
+ if (sym->isUndefined()) {
+ if (ignoreUnresolved || sym->isWeak())
+ continue;
+
+ static InputSection dummy(ctx.internalFile, dynDbgSecName, 0, 0, 0, 0,
+ ArrayRef<uint8_t>());
+ ObjFile<ELFT> *dbgObj = dyn_cast<ObjFile<ELFT>>(sym->file);
+ InputSectionBase *isec =
+ dbgObj && dbgObj->dynDbgSec ? dbgObj->dynDbgSec.get() : &dummy;
+ ctx.undefErrs.push_back(
+ {cast<Undefined>(sym), {{isec, 0}}, warnOnly});
+ continue;
+ }
+
+ // Ensure there are PLT/GOT entries for references to shared symbols.
+ if (sym->isShared() && sym->isUsedInRegularObj && sym->dsoDefined) {
+ if (sym->isFunc())
+ sym->setFlags(NEEDS_PLT);
+ else if (sym->isObject())
+ sym->setFlags(NEEDS_GOT);
+ }
+ }
+ }
+
reportUndefinedSymbols(ctx);
postScanRelocations(ctx);
diff --git a/lld/test/ELF/Inputs/trace-symbols-dyndbg-opt.s b/lld/test/ELF/Inputs/trace-symbols-dyndbg-opt.s
new file mode 100644
index 0000000000000..1fba360bb54ab
--- /dev/null
+++ b/lld/test/ELF/Inputs/trace-symbols-dyndbg-opt.s
@@ -0,0 +1,4 @@
+.globl baz
+.type baz, @function
+baz:
+nop
diff --git a/lld/test/ELF/Inputs/trace-symbols-dyndbg-unopt.s b/lld/test/ELF/Inputs/trace-symbols-dyndbg-unopt.s
new file mode 100644
index 0000000000000..7688e526340d9
--- /dev/null
+++ b/lld/test/ELF/Inputs/trace-symbols-dyndbg-unopt.s
@@ -0,0 +1,5 @@
+.globl __dyndbg.baz
+.hidden __dyndbg.baz
+.type __dyndbg.baz, @function
+__dyndbg.baz:
+callq foo
diff --git a/lld/test/ELF/dynamic-debug.test b/lld/test/ELF/dynamic-debug.test
new file mode 100644
index 0000000000000..19a99619e95e7
--- /dev/null
+++ b/lld/test/ELF/dynamic-debug.test
@@ -0,0 +1,401 @@
+REQUIRES: x86
+
+## This test simulates the input from dynamic debugging objects to test ELF LLD's handling
+## of various specific situations that can arise with such objects. These are mainly
+## related to dependencies from the "inner" unoptimized objects.
+
+RUN: rm -rf %t && split-file %s %t
+
+## Create the "outer" optimized objects.
+RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t/main.s -o %t/main.o
+RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t/foo.s -o %t/foo.o
+
+## Link only the "outer" optimized objects using `--gc-sections`.
+RUN: ld.lld -e main --gc-sections -o %t/out %t/main.o %t/foo.o
+RUN: llvm-readelf -s %t/out | FileCheck %s
+
+CHECK: Symbol table '.symtab' contains 12 entries:
+CHECK-DAG: {{.*}} 0 FUNC LOCAL DEFAULT [[#]] static_func
+CHECK-DAG: {{.*}} 0 OBJECT LOCAL DEFAULT [[#]] static_data
+CHECK-DAG: {{.*}} 0 FUNC LOCAL HIDDEN [[#]] static_func.dyndbg.main
+CHECK-DAG: {{.*}} 0 OBJECT LOCAL HIDDEN [[#]] static_data.dyndbg.main
+CHECK-DAG: {{.*}} 0 FUNC LOCAL DEFAULT [[#]] static_func
+CHECK-DAG: {{.*}} 0 OBJECT LOCAL DEFAULT [[#]] static_data
+CHECK-DAG: {{.*}} 0 FUNC LOCAL HIDDEN [[#]] static_func.dyndbg.foo
+CHECK-DAG: {{.*}} 0 OBJECT LOCAL HIDDEN [[#]] static_data.dyndbg.foo
+CHECK-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] func
+CHECK-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] main
+CHECK-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] foo
+
+## Create and embed the "inner" unoptimized objects to simulate dynamic debugging objects.
+## Note that the embedded `.debug_llvm_dyndbg` section should be aligned to 8.
+RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t/main-unopt.s -o %t/main-unopt.o
+RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t/foo-unopt.s -o %t/foo-unopt.o
+RUN: llvm-objcopy --add-section=.debug_llvm_dyndbg=%t/main-unopt.o %t/main.o
+RUN: llvm-objcopy --set-section-type=.debug_llvm_dyndbg=0x6fff4c10 \
+RUN: --set-section-alignment=.debug_llvm_dyndbg=8 %t/main.o
+RUN: llvm-objcopy --add-section=.debug_llvm_dyndbg=%t/foo-unopt.o %t/foo.o
+RUN: llvm-objcopy --set-section-type=.debug_llvm_dyndbg=0x6fff4c10 \
+RUN: --set-section-alignment=.debug_llvm_dyndbg=8 %t/foo.o
+
+## Create shared object to test handling of "inner" only dependencies.
+RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t/shared.s -o %t/shared.o
+RUN: ld.lld -shared -o %t/shared.so %t/shared.o
+
+## Link simulated dynamic debugging objects.
+RUN: ld.lld -e main -o %t/out-dd %t/main.o %t/foo.o %t/shared.so
+RUN: llvm-readelf -Srsn %t/out-dd | FileCheck -DNSYM=21 --check-prefixes=DD,NO-GC %s
+
+## Link simulated dynamic debugging objects using `--gc-sections`.
+## Note that `--gc-sections` is not yet supported for the "inner" unoptimized relocatable
+## link.
+RUN: ld.lld -e main --gc-sections -o %t/out-dd-gc %t/main.o %t/foo.o %t/shared.so
+RUN: llvm-readelf -Srsn %t/out-dd-gc | FileCheck -DNSYM=19 --check-prefixes=DD,GC %s
+
+## Check dynamic debugging related sections.
+DD: There are 20 section headers, starting at offset {{.*}}:
+DD: Name Type Address Off Size ES Flg Lk Inf Al
+DD-DAG: .debug_llvm_dyndbg LLVM_DYNDBG_ELF 0000000000000000 {{.*}} {{.*}} 00 0 0 8
+DD-DAG: .note.llvm.dyndbg NOTE 0000000000000000 {{.*}} {{.*}} 00 0 0 4
+
+## Check GOT/PLT entries in "outer" ELF for shared symbols only referenced by "inner"
+## unoptimized objects.
+DD: Relocation section '.rela.dyn' at offset {{.*}} contains 1 entries:
+DD: {{.*}} {{.*}} R_X86_64_GLOB_DAT 0000000000000000 shared_data_for_unopt
+DD: Relocation section '.rela.plt' at offset {{.*}} contains 1 entries:
+DD: {{.*}} {{.*}} R_X86_64_JUMP_SLOT 0000000000000000 shared_func_for_unopt
+
+NO-GC: Symbol table '.dynsym' contains 4 entries:
+GC: Symbol table '.dynsym' contains 3 entries:
+DD-DAG: 0000000000000000 0 OBJECT GLOBAL DEFAULT UND shared_data_for_unopt
+DD-DAG: 0000000000000000 0 FUNC GLOBAL DEFAULT UND shared_func_for_unopt
+NO-GC-DAG: 0000000000000000 0 NOTYPE GLOBAL DEFAULT UND undef_used_by_non_alloc
+
+DD: Symbol table '.symtab' contains [[NSYM]] entries:
+DD-DAG: {{.*}} 0 FUNC LOCAL DEFAULT [[#]] static_func
+DD-DAG: {{.*}} 0 OBJECT LOCAL DEFAULT [[#]] static_data
+DD-DAG: {{.*}} 0 FUNC LOCAL HIDDEN [[#]] static_func.dyndbg.main
+DD-DAG: {{.*}} 0 OBJECT LOCAL HIDDEN [[#]] static_data.dyndbg.main
+DD-DAG: {{.*}} 0 FUNC LOCAL DEFAULT [[#]] static_func
+DD-DAG: {{.*}} 0 OBJECT LOCAL DEFAULT [[#]] static_data
+DD-DAG: {{.*}} 0 FUNC LOCAL HIDDEN [[#]] static_func.dyndbg.foo
+DD-DAG: {{.*}} 0 OBJECT LOCAL HIDDEN [[#]] static_data.dyndbg.foo
+DD-DAG: {{.*}} 0 NOTYPE LOCAL HIDDEN [[#]] _DYNAMIC
+DD-DAG: {{.*}} 0 FUNC WEAK DEFAULT [[#]] comdat_func
+DD-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] func
+DD-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] main
+DD-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] foo
+DD-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] inlined_in_opt
+NO-GC-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] unused_func
+DD-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] used_by_unused_func
+DD-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] inlined_for_unopt_and_non_alloc
+DD-DAG: {{.*}} 0 OBJECT GLOBAL DEFAULT UND shared_data_for_unopt
+DD-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT UND shared_func_for_unopt
+NO-GC-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND undef_used_by_non_alloc
+REL-DAG: {{.*}} 0 FILE LOCAL DEFAULT ABS main.o
+REL-DAG: {{.*}} 0 FILE LOCAL DEFAULT ABS foo.o
+REL-DAG: {{.*}} 0 FILE LOCAL DEFAULT ABS
+
+DD: LLVM 0x00000004 Unknown note type: (0x00000004)
+DD-NEXT: description data: 00 00 00 00
+
+## Extract and check "inner" ELF for the default link.
+RUN: llvm-objcopy --dump-section=.debug_llvm_dyndbg=%t/in-dd.o %t/out-dd /dev/null
+RUN: llvm-readelf -Ssg %t/in-dd.o | FileCheck --check-prefix=IN %s
+
+## Extract and check "inner" ELF for the `--gc-sections` link.
+RUN: llvm-objcopy --dump-section=.debug_llvm_dyndbg=%t/in-dd-gc.o %t/out-dd-gc /dev/null
+RUN: llvm-readelf -Ssg %t/in-dd-gc.o | FileCheck --check-prefix=IN %s
+
+IN: There are 9 section headers, starting at offset {{.*}}:
+IN: Name Type Address Off Size ES Flg Lk Inf Al
+IN: .text PROGBITS 0000000000000000 {{.*}} {{.*}} 00 AX 0 0 4
+IN-NEXT: .rela.text RELA 0000000000000000 {{.*}} {{.*}} 18 I [[#]] [[#]] 8
+IN-NEXT: .debug_xyz PROGBITS 0000000000000000 {{.*}} {{.*}} 00 0 0 1
+IN-NEXT: .rela.debug_xyz RELA 0000000000000000 {{.*}} {{.*}} 18 I [[#]] [[#]] 8
+IN-NEXT: .note.GNU-stack PROGBITS 0000000000000000 {{.*}} {{.*}} 00 0 0 1
+IN-NEXT: .symtab SYMTAB 0000000000000000 {{.*}} {{.*}} 18 [[#]] [[#]] 8
+IN-NEXT: .shstrtab STRTAB 0000000000000000 {{.*}} {{.*}} 00 0 0 1
+IN-NEXT: .strtab STRTAB 0000000000000000 {{.*}} {{.*}} 00 0 0 1
+
+IN: Symbol table '.symtab' contains 26 entries:
+IN-DAG: {{.*}} 0 SECTION LOCAL DEFAULT [[#]] .text
+IN-DAG: {{.*}} 0 SECTION LOCAL DEFAULT [[#]] .debug_xyz
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.static_func.dyndbg.main
+IN-DAG: {{.*}} 0 FUNC WEAK HIDDEN [[#]] __dyndbg.comdat_func
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.func
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND static_func.dyndbg.main
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND static_data.dyndbg.main
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND inlined_in_opt
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND comdat_func
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND inlined_for_unopt_and_non_alloc
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND shared_data_for_unopt
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.main
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND foo
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND func
+IN-DAG: {{.*}} 0 FUNC GLOBAL DEFAULT [[#]] __dyndbg.inlined_in_opt
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.unused_func
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND used_by_unused_func
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.inlined_for_unopt_and_non_alloc
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.static_func.dyndbg.foo
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.foo
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND static_func.dyndbg.foo
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND static_data.dyndbg.foo
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND shared_func_for_unopt
+IN-DAG: {{.*}} 0 FUNC GLOBAL HIDDEN [[#]] __dyndbg.used_by_unused_func
+IN-DAG: {{.*}} 0 NOTYPE GLOBAL DEFAULT UND undef_used_by_non_alloc
+## Groups have been resolved.
+IN: There are no section groups in this file.
+
+## Check disabling of incompatible ICF options.
+RUN: ld.lld -e main --icf=all -o %t/out-dd-icf-all %t/main.o %t/foo.o %t/shared.so 2>&1 \
+RUN: | FileCheck --check-prefix=ICF-WARN %s
+RUN: cmp %t/out-dd-icf-all %t/out-dd
+RUN: ld.lld -e main --icf=safe -o %t/out-dd-icf-safe %t/main.o %t/foo.o %t/shared.so 2>&1 \
+RUN: | FileCheck --check-prefix=ICF-WARN %s
+RUN: cmp %t/out-dd-icf-safe %t/out-dd
+
+ICF-WARN: ICF disabled because it is incompatible with dynamic debugging
+
+## Check relocatable link of simulated dynamic debugging objects.
+RUN: ld.lld -r -o %t/rel.o %t/main.o %t/foo.o
+RUN: llvm-objcopy --dump-section=.debug_llvm_dyndbg=%t/rel-dd.o %t/rel.o /dev/null
+RUN: ld.lld -r -o %t/rel-unopt.o %t/main-unopt.o %t/foo-unopt.o
+RUN: cmp %t/rel-dd.o %t/rel-unopt.o
+
+## Link the above relocatable link output with and without `--gc-sections`.
+RUN: ld.lld -e main -o %t/out-rel-dd %t/rel.o %t/shared.so
+RUN: llvm-readelf -Srsn %t/out-rel-dd | FileCheck -DNSYM=24 --check-prefixes=DD,NO-GC,REL %s
+RUN: ld.lld -e main --gc-sections -o %t/out-rel-dd-gc %t/rel.o %t/shared.so
+RUN: llvm-readelf -Srsn %t/out-rel-dd-gc | FileCheck -DNSYM=22 --check-prefixes=DD,GC,REL %s
+
+## Extract and check "inner" ELF for the above links.
+RUN: llvm-objcopy --dump-section=.debug_llvm_dyndbg=%t/in-rel-dd.o %t/out-rel-dd /dev/null
+RUN: llvm-readelf -Ssg %t/in-rel-dd.o | FileCheck --check-prefix=IN %s
+RUN: llvm-objcopy --dump-section=.debug_llvm_dyndbg=%t/in-rel-dd-gc.o %t/out-rel-dd-gc /dev/null
+RUN: llvm-readelf -Ssg %t/in-rel-dd-gc.o | FileCheck --check-prefix=IN %s
+
+#--- main.s
+# Optimized version of "main"
+
+.local static_func
+.type static_func, at function
+.section .text.static_func,"ax", at progbits
+static_func:
+ ret
+
+.global static_func.dyndbg.main
+.hidden static_func.dyndbg.main
+static_func.dyndbg.main = static_func
+
+.weak comdat_func
+.type comdat_func, at function
+.section .text.comdat_func,"axG", at progbits,comdat_func,comdat
+comdat_func:
+ ret
+
+.global func
+.type func, at function
+.section .text.func,"ax", at progbits
+func:
+ call static_func
+ mov static_data,%rax
+ ret
+
+.global main
+.type main, at function
+.section .text.main,"ax", at progbits
+main:
+ call foo
+ call func
+ ret
+
+.global inlined_in_opt
+.type inlined_in_opt, at function
+.section .text.inlined_in_opt,"ax", at progbits
+inlined_in_opt:
+ ret
+
+.global unused_func
+.type unused_func, at function
+.section .text.unused_func,"ax", at progbits
+unused_func:
+ call used_by_unused_func
+ ret
+
+.global inlined_for_unopt_and_non_alloc
+.type inlined_for_unopt_and_non_alloc, at function
+.section .text.inlined_for_unopt_and_non_alloc,"ax", at progbits
+inlined_for_unopt_and_non_alloc:
+ ret
+
+.local static_data
+.type static_data, at object
+.section .data.static_data,"aw", at progbits
+static_data:
+.asciz "main static data"
+
+.global static_data.dyndbg.main
+.hidden static_data.dyndbg.main
+static_data.dyndbg.main = static_data
+
+#--- main-unopt.s
+# Unoptimized version of "main"
+
+.global __dyndbg.static_func.dyndbg.main
+.hidden __dyndbg.static_func.dyndbg.main
+.type __dyndbg.static_func.dyndbg.main, at function
+.section .text.__dyndbg.static_func.dyndbg.main,"ax", at progbits
+__dyndbg.static_func.dyndbg.main:
+ ret
+
+.weak __dyndbg.comdat_func
+.hidden __dyndbg.comdat_func
+.type __dyndbg.comdat_func, at function
+.section .text.__dyndbg.comdat_func,"axG", at progbits,__dyndbg.comdat_func,comdat
+__dyndbg.comdat_func:
+ ret
+
+.global __dyndbg.func
+.hidden __dyndbg.func
+.type __dyndbg.func, at function
+.section .text.__dyndbg.func,"ax", at progbits
+__dyndbg.func:
+ call static_func.dyndbg.main
+ mov static_data.dyndbg.main,%rax
+
+ # The following is only in the unoptimized due to inlining in the optimized.
+ call inlined_in_opt
+ call comdat_func
+ call inlined_for_unopt_and_non_alloc
+ mov shared_data_for_unopt,%rax
+
+ ret
+
+.global __dyndbg.main
+.hidden __dyndbg.main
+.type __dyndbg.main, at function
+.section .text.__dyndbg.main,"ax", at progbits
+__dyndbg.main:
+ call foo
+ call func
+ ret
+
+.global __dyndbg.inlined_in_opt
+.type __dyndbg.inlined_in_opt, at function
+.section .text.__dyndbg.inlined_in_opt,"ax", at progbits
+__dyndbg.inlined_in_opt:
+ ret
+
+.global __dyndbg.unused_func
+.hidden __dyndbg.unused_func
+.type __dyndbg.unused_func, at function
+.section .text.__dyndbg.unused_func,"ax", at progbits
+__dyndbg.unused_func:
+ call used_by_unused_func
+ ret
+
+.global __dyndbg.inlined_for_unopt_and_non_alloc
+.hidden __dyndbg.inlined_for_unopt_and_non_alloc
+.type __dyndbg.inlined_for_unopt_and_non_alloc, at function
+.section .text.__dyndbg.inlined_for_unopt_and_non_alloc,"ax", at progbits
+__dyndbg.inlined_for_unopt_and_non_alloc:
+ ret
+
+#--- foo.s
+# Optimized version of "foo"
+
+.local static_func
+.type static_func, at function
+.section .text.static_func,"ax", at progbits
+static_func:
+ ret
+
+.global static_func.dyndbg.foo
+.hidden static_func.dyndbg.foo
+static_func.dyndbg.foo = static_func
+
+.weak comdat_func
+.type comdat_func, at function
+.section .text.comdat_func,"axG", at progbits,comdat_func,comdat
+comdat_func:
+ ret
+
+.global foo
+.type foo, at function
+.section .text.foo,"ax", at progbits
+foo:
+ call static_func
+ mov static_data,%rax
+ ret
+
+.global used_by_unused_func
+.type used_by_unused_func, at function
+.section .text.used_by_unused_func,"ax", at progbits
+used_by_unused_func:
+ ret
+
+.local static_data
+.type static_data, at object
+.section .data.static_data,"aw", at progbits
+static_data:
+.asciz "foo static data"
+
+.global static_data.dyndbg.foo
+.hidden static_data.dyndbg.foo
+static_data.dyndbg.foo = static_data
+
+#--- foo-unopt.s
+# Unoptimized version of "foo"
+
+.global __dyndbg.static_func.dyndbg.foo
+.hidden __dyndbg.static_func.dyndbg.foo
+.type __dyndbg.static_func.dyndbg.foo, at function
+.section .text.__dyndbg.static_func.dyndbg.foo,"ax", at progbits
+__dyndbg.static_func.dyndbg.foo:
+ ret
+
+.weak __dyndbg.comdat_func
+.hidden __dyndbg.comdat_func
+.type __dyndbg.comdat_func, at function
+.section .text.__dyndbg.comdat_func,"axG", at progbits,__dyndbg.comdat_func,comdat
+__dyndbg.comdat_func:
+ ret
+
+.global __dyndbg.foo
+.hidden __dyndbg.foo
+.type __dyndbg.foo, at function
+.section .text.__dyndbg.foo,"ax", at progbits
+__dyndbg.foo:
+ call static_func.dyndbg.foo
+ mov static_data.dyndbg.foo,%rax
+
+ # The following is only in the unoptimized due to inlining in the optimized.
+ call shared_func_for_unopt
+ call comdat_func
+
+ ret
+
+.global __dyndbg.used_by_unused_func
+.hidden __dyndbg.used_by_unused_func
+.type __dyndbg.used_by_unused_func, at function
+.section .text.__dyndbg.used_by_unused_func,"ax", at progbits
+__dyndbg.used_by_unused_func:
+ ret
+
+.section .debug_xyz,"", at progbits
+.quad undef_used_by_non_alloc
+.quad inlined_for_unopt_and_non_alloc
+
+#--- shared.s
+.global shared_func_for_unopt
+.type shared_func_for_unopt, at function
+shared_func_for_unopt:
+ ret
+
+.data
+
+.global shared_data_for_unopt
+.type shared_data_for_unopt, at object
+shared_data_for_unopt:
+.word 0xcafe
diff --git a/lld/test/ELF/trace-symbols.s b/lld/test/ELF/trace-symbols.s
index 785414e2bd5b5..ae17899588d31 100644
--- a/lld/test/ELF/trace-symbols.s
+++ b/lld/test/ELF/trace-symbols.s
@@ -3,15 +3,23 @@
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
-# RUN: %p/Inputs/trace-symbols-foo-weak.s -o %t1
+# RUN: %p/Inputs/trace-symbols-foo-weak.s -o %t1
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
-# RUN: %p/Inputs/trace-symbols-foo-strong.s -o %t2
+# RUN: %p/Inputs/trace-symbols-foo-strong.s -o %t2
# RUN: ld.lld -shared %t1 -o %t1.so
# RUN: ld.lld -shared %t2 -o %t2.so
# RUN: rm -f %t1.a
# RUN: llvm-ar rcs %t1.a %t1
# RUN: rm -f %t2.a
# RUN: llvm-ar rcs %t2.a %t2
+## Create dynamic debugging style object.
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
+# RUN: %p/Inputs/trace-symbols-dyndbg-opt.s -o %t3
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
+# RUN: %p/Inputs/trace-symbols-dyndbg-unopt.s -o %t-unopt
+# RUN: llvm-objcopy --add-section=.debug_llvm_dyndbg=%t-unopt %t3
+# RUN: llvm-objcopy --set-section-type=.debug_llvm_dyndbg=0x6fff4c10 \
+# RUN: --set-section-alignment=.debug_llvm_dyndbg=8 %t3
# RUN: ld.lld -y foo -shared %t1 %t1.so -o /dev/null | \
# RUN: FileCheck --check-prefix=PREEMPT %s --implicit-check-not=foo
@@ -19,75 +27,80 @@
# PREEMPT-NEXT: trace-symbols.s.tmp1.so: shared definition of foo
# RUN: ld.lld -y foo -trace-symbol common -trace-symbol=hsymbol \
-# RUN: %t %t1 %t2 -o %t3 | FileCheck -check-prefix=OBJECTRFOO %s
+# RUN: %t %t1 %t2 -o /dev/null | FileCheck -check-prefix=OBJECTRFOO %s
# OBJECTRFOO: trace-symbols.s.tmp: reference to foo
# RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol \
-# RUN: %t %t1 %t2 -o %t3 | FileCheck -check-prefix=OBJECTDCOMMON %s
+# RUN: %t %t1 %t2 -o /dev/null | FileCheck -check-prefix=OBJECTDCOMMON %s
# OBJECTDCOMMON: trace-symbols.s.tmp1: common definition of common
# RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol \
-# RUN: %t %t1 %t2 -o %t3 | FileCheck -check-prefix=OBJECTD1FOO %s
+# RUN: %t %t1 %t2 -o /dev/null | FileCheck -check-prefix=OBJECTD1FOO %s
# OBJECTD1FOO: trace-symbols.s.tmp: reference to foo
# OBJECTD1FOO: trace-symbols.s.tmp1: common definition of common
# OBJECTD1FOO: trace-symbols.s.tmp1: definition of foo
# OBJECTD1FOO: trace-symbols.s.tmp2: definition of foo
-# RUN: ld.lld -y foo %t1 %t2 %t -o %t3 | FileCheck -check-prefix=REFLAST %s
+# RUN: ld.lld -y foo %t1 %t2 %t -o /dev/null | FileCheck -check-prefix=REFLAST %s
# REFLAST: trace-symbols.s.tmp1: definition of foo
# REFLAST: trace-symbols.s.tmp2: definition of foo
# REFLAST: trace-symbols.s.tmp: reference to foo
# RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol \
-# RUN: %t %t1 %t2 -o %t3 | FileCheck -check-prefix=OBJECTD2FOO %s
+# RUN: %t %t1 %t2 -o /dev/null | FileCheck -check-prefix=OBJECTD2FOO %s
# RUN: ld.lld -y foo -y common --trace-symbol=hsymbol \
-# RUN: %t %t2 %t1 -o %t3 | FileCheck -check-prefix=OBJECTD2FOO %s
-# RUN: ld.lld -y foo -y common %t %t1.so %t2 -o %t3 | \
+# RUN: %t %t2 %t1 -o /dev/null | FileCheck -check-prefix=OBJECTD2FOO %s
+# RUN: ld.lld -y foo -y common %t %t1.so %t2 -o /dev/null | \
# RUN: FileCheck -check-prefix=OBJECTD2FOO %s
# OBJECTD2FOO: trace-symbols.s.tmp2: definition of foo
-# RUN: ld.lld -y foo -y common %t %t2 %t1.a -o %t3 | \
+# RUN: ld.lld -y foo -y common %t %t2 %t1.a -o /dev/null | \
# RUN: FileCheck -check-prefix=FOO_AND_COMMON %s
# FOO_AND_COMMON: trace-symbols.s.tmp: reference to foo
# FOO_AND_COMMON: trace-symbols.s.tmp2: definition of foo
# FOO_AND_COMMON: trace-symbols.s.tmp1.a({{.*}}.tmp1): lazy definition of common
-# RUN: ld.lld -y foo -y common %t %t1.so %t2 -o %t3 | \
+# RUN: ld.lld -y foo -y common %t %t1.so %t2 -o /dev/null | \
# RUN: FileCheck -check-prefix=SHLIBDCOMMON %s
# SHLIBDCOMMON: trace-symbols.s.tmp1.so: shared definition of common
-# RUN: ld.lld -y foo -y common %t %t2.so %t1.so -o %t3 | \
+# RUN: ld.lld -y foo -y common %t %t2.so %t1.so -o /dev/null | \
# RUN: FileCheck -check-prefix=SHLIBD2FOO %s
-# RUN: ld.lld -y foo %t %t1.a %t2.so -o %t3 | \
+# RUN: ld.lld -y foo %t %t1.a %t2.so -o /dev/null | \
# RUN: FileCheck -check-prefix=NO-SHLIBD2FOO %s
# SHLIBD2FOO: trace-symbols.s.tmp2.so: shared definition of foo
# NO-SHLIBD2FOO-NOT: trace-symbols.s.tmp2.so: definition of foo
-# RUN: ld.lld -y foo -y common %t %t2 %t1.a -o %t3 | \
+# RUN: ld.lld -y foo -y common %t %t2 %t1.a -o /dev/null | \
# RUN: FileCheck -check-prefix=ARCHIVEDCOMMON %s
# ARCHIVEDCOMMON-NOT: trace-symbols.s.tmp1.a(trace-symbols.s.tmp1): definition of \
# common
-# RUN: ld.lld -y foo %t %t1.a %t2.so -o %t3 | \
+# RUN: ld.lld -y foo %t %t1.a %t2.so -o /dev/null | \
# RUN: FileCheck -check-prefix=ARCHIVED1FOO %s
# ARCHIVED1FOO: trace-symbols.s.tmp1.a(trace-symbols.s.tmp1): definition of foo
-# RUN: ld.lld -y foo %t %t1.a %t2.a -o %t3 | \
+# RUN: ld.lld -y foo %t %t1.a %t2.a -o /dev/null | \
# RUN: FileCheck -check-prefix=ARCHIVED2FOO %s
# ARCHIVED2FOO: trace-symbols.s.tmp2.a(trace-symbols.s.tmp2): definition of foo
-# RUN: ld.lld -y bar %t %t1.so %t2.so -o %t3 | \
+# RUN: ld.lld -y bar %t %t1.so %t2.so -o /dev/null | \
# RUN: FileCheck -check-prefix=SHLIBDBAR %s
# SHLIBDBAR: trace-symbols.s.tmp2.so: shared definition of bar
-# RUN: ld.lld -y foo -y bar %t %t1.so %t2.so -o %t3 | \
+# RUN: ld.lld -y foo -y bar %t %t1.so %t2.so -o /dev/null | \
# RUN: FileCheck -check-prefix=SHLIBRBAR %s
# SHLIBRBAR: trace-symbols.s.tmp1.so: reference to bar
-# RUN: ld.lld -y foo -y bar %t -u bar --start-lib %t1 %t2 --end-lib -o %t3 | \
+# RUN: ld.lld -y foo -y bar %t -u bar --start-lib %t1 %t2 --end-lib -o /dev/null | \
# RUN: FileCheck -check-prefix=STARTLIB %s
# STARTLIB: trace-symbols.s.tmp1: reference to bar
+# RUN: ld.lld -y foo -shared %t2 %t3 -o /dev/null | FileCheck -check-prefix=DYNDBG %s
+# DYNDBG: trace-symbols.s.tmp2: definition of foo
+# DYNDBG: trace-symbols.s.tmp3: reference to foo
+# DYNDBG: trace-symbols.s.tmp3: dynamic debugging reference to foo
+
## Check we do not crash when trying to trace special symbol.
# RUN: ld.lld -trace-symbol=_end %t %t1 %t2 -o /dev/null
diff --git a/llvm/include/llvm/BinaryFormat/ELF.h b/llvm/include/llvm/BinaryFormat/ELF.h
index 8c429a8e1428f..c8e7b36a030d9 100644
--- a/llvm/include/llvm/BinaryFormat/ELF.h
+++ b/llvm/include/llvm/BinaryFormat/ELF.h
@@ -1809,6 +1809,7 @@ enum : unsigned {
// LLVM-specific notes.
enum {
NT_LLVM_HWASAN_GLOBALS = 3,
+ NT_LLVM_DYNAMIC_DEBUGGING = 4,
};
// GNU note types.
More information about the llvm-commits
mailing list