33 #define DEBUG_TYPE "orc"
43 virtual void setTargetMemoryRange(
SectionRange Range) = 0;
48 template <
typename ELFT>
54 : Header(const_cast<typename ELFT::
Shdr *>(Header)) {}
64 bool isTextOrDataSection()
const;
67 template <
typename ELFT>
70 if (isTextOrDataSection())
75 template <
typename ELFT>
77 switch (Header->sh_type) {
85 template <
typename ELFT>
87 const char *
Name)
const {
90 const uint8_t *HeaderPtr =
reinterpret_cast<uint8_t *
>(Header);
91 if (HeaderPtr < Start || HeaderPtr +
sizeof(
typename ELFT::Shdr) > End)
92 return make_error<StringError>(
93 formatv(
"{0} section header at {1:x16} not within bounds of the "
94 "given debug object buffer [{2:x16} - {3:x16}]",
95 Name, &Header->sh_addr, Start, End),
97 if (Header->sh_offset + Header->sh_size > Buffer.
size())
98 return make_error<StringError>(
99 formatv(
"{0} section data [{1:x16} - {2:x16}] not within bounds of "
100 "the given debug object buffer [{3:x16} - {4:x16}]",
101 Name, Start + Header->sh_offset,
102 Start + Header->sh_offset + Header->sh_size, Start, End),
107 template <
typename ELFT>
130 : MemMgr(MemMgr), JD(JD), ES(ES) {}
141 std::vector<FinalizedAlloc> Allocs;
162 std::set<Requirement> Reqs;
170 assert(!Alloc &&
"Cannot finalize more than once");
172 if (
auto SimpleSegAlloc = finalizeWorkingMemory()) {
176 SimpleSegAlloc->finalize(
177 [
this, DebugObjRange,
181 OnFinalize(DebugObjRange);
186 OnFinalize(SimpleSegAlloc.takeError());
207 template <
typename ELFT>
213 template <
typename ELFT>
218 static std::unique_ptr<WritableMemoryBuffer>
225 set(Requirement::ReportFinalSectionLoadAddresses);
228 std::unique_ptr<WritableMemoryBuffer> Buffer;
233 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME, OPTION) \
235 #include "llvm/BinaryFormat/Dwarf.def"
236 #undef HANDLE_DWARF_SECTION
243 std::unique_ptr<WritableMemoryBuffer>
257 template <
typename ELFT>
258 Expected<std::unique_ptr<ELFDebugObject>>
259 ELFDebugObject::CreateArchType(MemoryBufferRef Buffer,
265 std::unique_ptr<ELFDebugObject> DebugObj(
266 new ELFDebugObject(CopyBuffer(Buffer, Err), MemMgr, JD, ES));
272 return ObjRef.takeError();
275 uint16_t TargetMachineArch = ObjRef->getHeader().e_machine;
279 Expected<ArrayRef<SectionHeader>> Sections = ObjRef->sections();
281 return Sections.takeError();
283 bool HasDwarfSection =
false;
284 for (
const SectionHeader &Header : *Sections) {
285 Expected<StringRef>
Name = ObjRef->getSectionName(Header);
287 return Name.takeError();
292 auto Wrapped = std::make_unique<ELFDebugObjectSection<ELFT>>(&Header);
293 if (Error Err = DebugObj->recordSection(*
Name,
std::move(Wrapped)))
297 if (!HasDwarfSection) {
298 LLVM_DEBUG(
dbgs() <<
"Aborting debug registration for LinkGraph \""
299 << DebugObj->Buffer->getBufferIdentifier()
300 <<
"\": input object contains no debug info\n");
307 Expected<std::unique_ptr<DebugObject>>
310 unsigned char Class, Endian;
336 dbgs() <<
"Section load-addresses in debug object for \""
337 << Buffer->getBufferIdentifier() <<
"\":\n";
338 for (
const auto &KV : Sections)
339 KV.second->dump(
dbgs(), KV.first());
344 size_t Size = Buffer->getBufferSize();
354 memcpy(SegInfo.WorkingMem.data(), Buffer->getBufferStart(), Size);
363 DebugObjSection->setTargetMemoryRange(TargetMem);
366 template <
typename ELFT>
367 Error ELFDebugObject::recordSection(
372 if (!ItInserted.second)
373 return make_error<StringError>(
"Duplicate section",
379 auto It = Sections.find(
Name);
380 return It == Sections.end() ? nullptr : It->second.get();
389 switch (
G.getTargetTriple().getObjectFormat()) {
391 return ELFDebugObject::Create(ObjBuffer, Ctx, ES);
400 DebugObjectManagerPlugin::DebugObjectManagerPlugin(
409 std::lock_guard<std::mutex>
Lock(PendingObjsLock);
410 assert(PendingObjs.count(&MR) == 0 &&
411 "Cannot have more than one pending debug object per "
412 "MaterializationResponsibility");
416 if (*DebugObj !=
nullptr)
419 ES.reportError(DebugObj.takeError());
427 std::lock_guard<std::mutex>
Lock(PendingObjsLock);
428 auto It = PendingObjs.find(&MR);
429 if (It == PendingObjs.end())
446 std::lock_guard<std::mutex>
Lock(PendingObjsLock);
447 auto It = PendingObjs.find(&MR);
448 if (It == PendingObjs.end())
455 std::promise<MSVCPError> FinalizePromise;
456 std::future<MSVCPError> FinalizeErr = FinalizePromise.get_future();
458 It->second->finalizeAsync(
462 FinalizePromise.set_value(TargetMem.
takeError());
465 if (
Error Err =
Target->registerDebugObject(*TargetMem)) {
466 FinalizePromise.set_value(std::move(Err));
473 assert(PendingObjs.count(&MR) &&
"We still hold PendingObjsLock");
474 std::lock_guard<std::mutex> Lock(RegisteredObjsLock);
475 RegisteredObjs[K].push_back(std::move(PendingObjs[&MR]));
476 PendingObjs.erase(&MR);
480 return FinalizeErr.get();
485 std::lock_guard<std::mutex>
Lock(PendingObjsLock);
486 PendingObjs.erase(&MR);
494 std::lock_guard<std::mutex>
Lock(RegisteredObjsLock);
495 auto SrcIt = RegisteredObjs.find(SrcKey);
496 if (SrcIt != RegisteredObjs.end()) {
499 for (std::unique_ptr<DebugObject> &DebugObj : SrcIt->second)
500 RegisteredObjs[DstKey].push_back(
std::move(DebugObj));
501 RegisteredObjs.erase(SrcIt);
508 std::lock_guard<std::mutex>
Lock(RegisteredObjsLock);
509 RegisteredObjs.erase(
Key);