intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-18 16:50:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

[BOLT][DWARF] Remove option to write to DWP (#100771)

Browse Source 
Remove the --write-dwp option as well as related code and tests.
This commit is contained in:
Sayhaan Siddiqui
2024-07-30 16:58:01 -07:00
committed by GitHub
parent 546e4a210c
commit 79dcd93b70
10 changed files with 18 additions and 529 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
bolt/include/bolt/Rewrite/DWARFRewriter.h
View File

@@ -15,7 +15,6 @@
#include "bolt/Core/GDBIndex.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/CodeGen/DIE.h"
#include "llvm/DWP/DWP.h"
#include "llvm/MC/MCContext.h"
#include "llvm/Support/ToolOutputFile.h"
#include <cstdint>
@@ -41,13 +40,6 @@ public:
uint64_t TypeHash;
uint64_t TypeDIERelativeOffset;
};
/// Contains information for CU or TU so we can output correct {cu, tu}-index.
struct UnitMeta {
uint64_t Offset;
uint64_t Length;
uint64_t TUHash;
};
using UnitMetaVectorType = std::vector<UnitMeta>;
private:
BinaryContext &BC;
@@ -194,35 +186,6 @@ public:
const std::string &, DebugLocWriter &,
DebugStrOffsetsWriter &, DebugStrWriter &);
using KnownSectionsEntry = std::pair<MCSection *, DWARFSectionKind>;
struct DWPState {
std::unique_ptr<ToolOutputFile> Out;
std::unique_ptr<BinaryContext> TmpBC;
std::unique_ptr<MCStreamer> Streamer;
std::unique_ptr<DWPStringPool> Strings;
/// Used to store String sections for .dwo files if they are being modified.
std::vector<std::unique_ptr<DebugBufferVector>> StrSections;
const MCObjectFileInfo *MCOFI = nullptr;
const DWARFUnitIndex *CUIndex = nullptr;
std::deque<SmallString<32>> UncompressedSections;
MapVector<uint64_t, UnitIndexEntry> IndexEntries;
MapVector<uint64_t, UnitIndexEntry> TypeIndexEntries;
StringMap<KnownSectionsEntry> KnownSections;
uint32_t ContributionOffsets[8] = {};
uint32_t IndexVersion = 2;
uint64_t DebugInfoSize = 0;
uint16_t Version = 0;
bool IsDWP = false;
};
/// Init .dwp file
void initDWPState(DWPState &);
/// Write out .dwp File
void finalizeDWP(DWPState &);
/// add content of dwo to .dwp file.
void updateDWP(DWARFUnit &, const OverriddenSectionsMap &, const UnitMeta &,
UnitMetaVectorType &, DWPState &, DebugLocWriter &,
DebugStrOffsetsWriter &, DebugStrWriter &);
};
} // namespace bolt

1
bolt/lib/Rewrite/CMakeLists.txt
View File

@@ -1,7 +1,6 @@
set(LLVM_LINK_COMPONENTS
Core
DebugInfoDWARF
DWP
JITLink
MC
Object

276
bolt/lib/Rewrite/DWARFRewriter.cpp
View File

@@ -331,14 +331,8 @@ static cl::opt<bool> KeepARanges(
static cl::opt<std::string> DwarfOutputPath(
"dwarf-output-path",
cl::desc("Path to where .dwo files or dwp file will be written out to."),
cl::init(""), cl::cat(BoltCategory));
static cl::opt<bool>
WriteDWP("write-dwp",
cl::desc("output a single dwarf package file (dwp) instead of "
"multiple non-relocatable dwarf object files (dwo)."),
cl::init(false), cl::cat(BoltCategory));
cl::desc("Path to where .dwo files will be written out to."), cl::init(""),
cl::cat(BoltCategory));
static cl::opt<bool> CreateDebugNames(
"create-debug-names-section",
@@ -470,23 +464,19 @@ createDIEStreamer(const Triple &TheTriple, raw_pwrite_stream &OutFile,
return Streamer;
}
static DWARFRewriter::UnitMeta
emitUnit(DIEBuilder &DIEBldr, DIEStreamer &Streamer, DWARFUnit &Unit) {
static void emitUnit(DIEBuilder &DIEBldr, DIEStreamer &Streamer,
DWARFUnit &Unit) {
DIE *UnitDIE = DIEBldr.getUnitDIEbyUnit(Unit);
const DIEBuilder::DWARFUnitInfo &U = DIEBldr.getUnitInfoByDwarfUnit(Unit);
Streamer.emitUnit(Unit, *UnitDIE);
uint64_t TypeHash = 0;
if (DWARFTypeUnit *DTU = dyn_cast_or_null<DWARFTypeUnit>(&Unit))
TypeHash = DTU->getTypeHash();
return {U.UnitOffset, U.UnitLength, TypeHash};
}
static void
emitDWOBuilder(const std::string &DWOName, DIEBuilder &DWODIEBuilder,
DWARFRewriter &Rewriter, DWARFUnit &SplitCU, DWARFUnit &CU,
DWARFRewriter::DWPState &State, DebugLocWriter &LocWriter,
DebugStrOffsetsWriter &StrOffstsWriter,
DebugStrWriter &StrWriter, GDBIndex &GDBIndexSection) {
static void emitDWOBuilder(const std::string &DWOName,
DIEBuilder &DWODIEBuilder, DWARFRewriter &Rewriter,
DWARFUnit &SplitCU, DWARFUnit &CU,
DebugLocWriter &LocWriter,
DebugStrOffsetsWriter &StrOffstsWriter,
DebugStrWriter &StrWriter,
GDBIndex &GDBIndexSection) {
// Populate debug_info and debug_abbrev for current dwo into StringRef.
DWODIEBuilder.generateAbbrevs();
DWODIEBuilder.finish();
@@ -499,28 +489,22 @@ emitDWOBuilder(const std::string &DWOName, DIEBuilder &DWODIEBuilder,
std::unique_ptr<DIEStreamer> Streamer =
createDIEStreamer(*TheTriple, *ObjOS, "DwoStreamerInitAug2",
DWODIEBuilder, GDBIndexSection);
DWARFRewriter::UnitMetaVectorType TUMetaVector;
DWARFRewriter::UnitMeta CUMI = {0, 0, 0};
if (SplitCU.getContext().getMaxDWOVersion() >= 5) {
for (std::unique_ptr<llvm::DWARFUnit> &CU :
SplitCU.getContext().dwo_info_section_units()) {
if (!CU->isTypeUnit())
continue;
DWARFRewriter::UnitMeta MI =
emitUnit(DWODIEBuilder, *Streamer, *CU.get());
TUMetaVector.emplace_back(MI);
emitUnit(DWODIEBuilder, *Streamer, *CU.get());
}
CUMI = emitUnit(DWODIEBuilder, *Streamer, SplitCU);
emitUnit(DWODIEBuilder, *Streamer, SplitCU);
} else {
for (std::unique_ptr<llvm::DWARFUnit> &CU :
SplitCU.getContext().dwo_compile_units())
emitUnit(DWODIEBuilder, *Streamer, *CU.get());
// emit debug_types sections for dwarf4
for (DWARFUnit *CU : DWODIEBuilder.getDWARF4TUVector()) {
DWARFRewriter::UnitMeta MI = emitUnit(DWODIEBuilder, *Streamer, *CU);
TUMetaVector.emplace_back(MI);
}
for (DWARFUnit *CU : DWODIEBuilder.getDWARF4TUVector())
emitUnit(DWODIEBuilder, *Streamer, *CU);
}
Streamer->emitAbbrevs(DWODIEBuilder.getAbbrevs(),
@@ -547,12 +531,8 @@ emitDWOBuilder(const std::string &DWOName, DIEBuilder &DWODIEBuilder,
continue;
OverriddenSections[Kind] = Contents;
}
if (opts::WriteDWP)
Rewriter.updateDWP(CU, OverriddenSections, CUMI, TUMetaVector, State,
LocWriter, StrOffstsWriter, StrWriter);
else
Rewriter.writeDWOFiles(CU, OverriddenSections, DWOName, LocWriter,
StrOffstsWriter, StrWriter);
Rewriter.writeDWOFiles(CU, OverriddenSections, DWOName, LocWriter,
StrOffstsWriter, StrWriter);
}
using DWARFUnitVec = std::vector<DWARFUnit *>;
@@ -665,9 +645,6 @@ void DWARFRewriter::updateDebugInfo() {
DWARF5AcceleratorTable DebugNamesTable(opts::CreateDebugNames, BC,
*StrWriter);
GDBIndex GDBIndexSection(BC);
DWPState State;
if (opts::WriteDWP)
initDWPState(State);
auto processSplitCU = [&](DWARFUnit &Unit, DWARFUnit &SplitCU,
DIEBuilder &DIEBlder,
DebugRangesSectionWriter &TempRangesSectionWriter,
@@ -691,7 +668,7 @@ void DWARFRewriter::updateDebugInfo() {
if (Unit.getVersion() >= 5)
TempRangesSectionWriter.finalizeSection();
emitDWOBuilder(DWOName, DWODIEBuilder, *this, SplitCU, Unit, State,
emitDWOBuilder(DWOName, DWODIEBuilder, *this, SplitCU, Unit,
DebugLocDWoWriter, DWOStrOffstsWriter, DWOStrWriter,
GDBIndexSection);
};
@@ -774,9 +751,6 @@ void DWARFRewriter::updateDebugInfo() {
DebugNamesTable.emitAccelTable();
if (opts::WriteDWP)
finalizeDWP(State);
finalizeDebugSections(DIEBlder, DebugNamesTable, *Streamer, *ObjOS, OffsetMap,
*FinalAddrWriter);
GDBIndexSection.updateGdbIndexSection(OffsetMap, CUIndex,
@@ -1822,220 +1796,6 @@ std::optional<StringRef> updateDebugData(
} // namespace
void DWARFRewriter::initDWPState(DWPState &State) {
SmallString<0> OutputNameStr;
StringRef OutputName;
if (opts::DwarfOutputPath.empty()) {
OutputName =
Twine(opts::OutputFilename).concat(".dwp").toStringRef(OutputNameStr);
} else {
StringRef ExeFileName = llvm::sys::path::filename(opts::OutputFilename);
OutputName = Twine(opts::DwarfOutputPath)
.concat("/")
.concat(ExeFileName)
.concat(".dwp")
.toStringRef(OutputNameStr);
errs() << "BOLT-WARNING: dwarf-output-path is in effect and .dwp file will "
"possibly be written to another location that is not the same as "
"the executable\n";
}
std::error_code EC;
State.Out =
std::make_unique<ToolOutputFile>(OutputName, EC, sys::fs::OF_None);
const object::ObjectFile *File = BC.DwCtx->getDWARFObj().getFile();
State.TmpBC = createDwarfOnlyBC(*File);
State.Streamer = State.TmpBC->createStreamer(State.Out->os());
State.MCOFI = State.Streamer->getContext().getObjectFileInfo();
State.KnownSections = createKnownSectionsMap(*State.MCOFI);
MCSection *const StrSection = State.MCOFI->getDwarfStrDWOSection();
// Data Structures for DWP book keeping
// Size of array corresponds to the number of sections supported by DWO format
// in DWARF4/5.
State.Strings = std::make_unique<DWPStringPool>(*State.Streamer, StrSection);
// Setup DWP code once.
DWARFContext *DWOCtx = BC.getDWOContext();
if (DWOCtx) {
State.CUIndex = &DWOCtx->getCUIndex();
State.IsDWP = !State.CUIndex->getRows().empty();
}
}
void DWARFRewriter::finalizeDWP(DWPState &State) {
if (State.Version < 5) {
// Lie about there being no info contributions so the TU index only includes
// the type unit contribution for DWARF < 5. In DWARFv5 the TU index has a
// contribution to the info section, so we do not want to lie about it.
State.ContributionOffsets[0] = 0;
}
writeIndex(*State.Streamer.get(), State.MCOFI->getDwarfTUIndexSection(),
State.ContributionOffsets, State.TypeIndexEntries,
State.IndexVersion);
if (State.Version < 5) {
// Lie about the type contribution for DWARF < 5. In DWARFv5 the type
// section does not exist, so no need to do anything about this.
State.ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)] = 0;
// Unlie about the info contribution
State.ContributionOffsets[0] = 1;
}
writeIndex(*State.Streamer.get(), State.MCOFI->getDwarfCUIndexSection(),
State.ContributionOffsets, State.IndexEntries, State.IndexVersion);
State.Streamer->finish();
State.Out->keep();
}
void DWARFRewriter::updateDWP(DWARFUnit &CU,
const OverriddenSectionsMap &OverridenSections,
const DWARFRewriter::UnitMeta &CUMI,
DWARFRewriter::UnitMetaVectorType &TUMetaVector,
DWPState &State, DebugLocWriter &LocWriter,
DebugStrOffsetsWriter &StrOffstsWriter,
DebugStrWriter &StrWriter) {
const uint64_t DWOId = *CU.getDWOId();
MCSection *const StrOffsetSection = State.MCOFI->getDwarfStrOffDWOSection();
assert(StrOffsetSection && "StrOffsetSection does not exist.");
// Skipping CUs that we failed to load.
std::optional<DWARFUnit *> DWOCU = BC.getDWOCU(DWOId);
if (!DWOCU)
return;
if (State.Version == 0) {
State.Version = CU.getVersion();
State.IndexVersion = State.Version < 5 ? 2 : 5;
} else if (State.Version != CU.getVersion()) {
errs() << "BOLT-ERROR: incompatible DWARF compile unit versions\n";
exit(1);
}
UnitIndexEntry CurEntry = {};
CurEntry.DWOName = dwarf::toString(
CU.getUnitDIE().find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}),
"");
const char *Name = CU.getUnitDIE().getShortName();
if (Name)
CurEntry.Name = Name;
StringRef CurStrSection;
StringRef CurStrOffsetSection;
// This maps each section contained in this file to its length.
// This information is later on used to calculate the contributions,
// i.e. offset and length, of each compile/type unit to a section.
std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLength;
const DWARFUnitIndex::Entry *CUDWOEntry = nullptr;
if (State.IsDWP)
CUDWOEntry = State.CUIndex->getFromHash(DWOId);
bool StrSectionWrittenOut = false;
const object::ObjectFile *DWOFile =
(*DWOCU)->getContext().getDWARFObj().getFile();
DebugRangeListsSectionWriter *RangeListssWriter = nullptr;
if (CU.getVersion() == 5) {
assert(RangeListsWritersByCU.count(DWOId) != 0 &&
"No RangeListsWriter for DWO ID.");
RangeListssWriter = RangeListsWritersByCU[DWOId].get();
}
auto AddType = [&](unsigned int Index, uint32_t IndexVersion, uint64_t Offset,
uint64_t Length, uint64_t Hash) -> void {
UnitIndexEntry TUEntry = CurEntry;
if (IndexVersion < 5)
TUEntry.Contributions[0] = {};
TUEntry.Contributions[Index].setOffset(Offset);
TUEntry.Contributions[Index].setLength(Length);
State.ContributionOffsets[Index] +=
TUEntry.Contributions[Index].getLength32();
State.TypeIndexEntries.insert(std::make_pair(Hash, TUEntry));
};
std::unique_ptr<DebugBufferVector> StrOffsetsOutputData;
std::unique_ptr<DebugBufferVector> StrOutputData;
for (const SectionRef &Section : DWOFile->sections()) {
std::unique_ptr<DebugBufferVector> OutputData = nullptr;
StringRef SectionName = getSectionName(Section);
Expected<StringRef> ContentsExp = Section.getContents();
assert(ContentsExp && "Invalid contents.");
std::optional<StringRef> TOutData =
updateDebugData((*DWOCU)->getContext(), SectionName, *ContentsExp,
State.KnownSections, *State.Streamer, *this, CUDWOEntry,
DWOId, OutputData, RangeListssWriter, LocWriter,
StrOffstsWriter, StrWriter, OverridenSections);
if (!TOutData)
continue;
StringRef OutData = *TOutData;
if (SectionName == "debug_types.dwo") {
State.Streamer->emitBytes(OutData);
continue;
}
if (SectionName == "debug_str.dwo") {
CurStrSection = OutData;
StrOutputData = std::move(OutputData);
} else {
// Since handleDebugDataPatching returned true, we already know this is
// a known section.
auto SectionIter = State.KnownSections.find(SectionName);
if (SectionIter->second.second == DWARFSectionKind::DW_SECT_STR_OFFSETS) {
CurStrOffsetSection = OutData;
StrOffsetsOutputData = std::move(OutputData);
} else {
State.Streamer->emitBytes(OutData);
}
unsigned int Index =
getContributionIndex(SectionIter->second.second, State.IndexVersion);
uint64_t Offset = State.ContributionOffsets[Index];
uint64_t Length = OutData.size();
if (CU.getVersion() >= 5 &&
SectionIter->second.second == DWARFSectionKind::DW_SECT_INFO) {
for (UnitMeta &MI : TUMetaVector)
MI.Offset += State.DebugInfoSize;
Offset = State.DebugInfoSize + CUMI.Offset;
Length = CUMI.Length;
State.DebugInfoSize += OutData.size();
}
CurEntry.Contributions[Index].setOffset(Offset);
CurEntry.Contributions[Index].setLength(Length);
State.ContributionOffsets[Index] +=
CurEntry.Contributions[Index].getLength32();
}
// Strings are combined in to a new string section, and de-duplicated
// based on hash.
if (!StrSectionWrittenOut && !CurStrOffsetSection.empty() &&
!CurStrSection.empty()) {
// If debug_str.dwo section was modified storing it until dwp is written
// out. DWPStringPool stores raw pointers to strings.
if (StrOutputData)
State.StrSections.push_back(std::move(StrOutputData));
writeStringsAndOffsets(*State.Streamer.get(), *State.Strings.get(),
StrOffsetSection, CurStrSection,
CurStrOffsetSection, CU.getVersion());
StrSectionWrittenOut = true;
}
}
CompileUnitIdentifiers CUI{DWOId, CurEntry.Name.c_str(),
CurEntry.DWOName.c_str()};
auto P = State.IndexEntries.insert(std::make_pair(CUI.Signature, CurEntry));
if (!P.second) {
Error Err = buildDuplicateError(*P.first, CUI, "");
errs() << "BOLT-ERROR: " << toString(std::move(Err)) << "\n";
return;
}
// Handling TU
const unsigned Index = getContributionIndex(
State.IndexVersion < 5 ? DW_SECT_EXT_TYPES : DW_SECT_INFO,
State.IndexVersion);
for (UnitMeta &MI : TUMetaVector)
AddType(Index, State.IndexVersion, MI.Offset, MI.Length, MI.TUHash);
}
void DWARFRewriter::writeDWOFiles(
DWARFUnit &CU, const OverriddenSectionsMap &OverridenSections,
const std::string &DWOName, DebugLocWriter &LocWriter,

13
bolt/test/X86/debug-fission-single-convert.s
View File

@@ -41,19 +41,6 @@
# CHECK-ADDR-SEC: 0x00000000: Addrs: [
# CHECK-ADDR-SEC: 0x0000000000601000
# RUN: llvm-bolt %t.exe --reorder-blocks=reverse --update-debug-sections --dwarf-output-path=%T -o %t.bolt.2.exe --write-dwp=true \
# RUN: --always-convert-to-ranges=true
# RUN: not llvm-dwarfdump --show-form --verbose --debug-info %t.bolt.2.exe.dwp &> %tAddrIndexTestDwp
# RUN: cat %tAddrIndexTestDwp | FileCheck %s --check-prefix=CHECK-DWP-DEBUG
# CHECK-DWP-DEBUG: DW_TAG_compile_unit [1] *
# CHECK-DWP-DEBUG: DW_AT_producer [DW_FORM_GNU_str_index] (indexed (0000000a) string = "clang version 13.0.0")
# CHECK-DWP-DEBUG: DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus)
# CHECK-DWP-DEBUG: DW_AT_name [DW_FORM_GNU_str_index] (indexed (0000000b) string = "foo")
# CHECK-DWP-DEBUG: DW_AT_GNU_dwo_name [DW_FORM_GNU_str_index] (indexed (0000000c) string = "foo")
# CHECK-DWP-DEBUG: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x06105e732fad3796)
//clang++ -ffunction-sections -fno-exceptions -g -gsplit-dwarf=split -S debug-fission-simple.cpp -o debug-fission-simple.s
static int foo = 2;
int doStuff(int val) {

12
bolt/test/X86/debug-fission-single.s
View File

@@ -42,18 +42,6 @@
# CHECK-ADDR-SEC: 0x00000000: Addrs: [
# CHECK-ADDR-SEC: 0x0000000000601000
# RUN: llvm-bolt %t.exe --reorder-blocks=reverse --update-debug-sections --dwarf-output-path=%T -o %t.bolt.2.exe --write-dwp=true
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt.2.exe.dwp &> %tAddrIndexTestDwp
# RUN: cat %tAddrIndexTestDwp | FileCheck %s --check-prefix=CHECK-DWP-DEBUG
# CHECK-DWP-DEBUG: DW_TAG_compile_unit [1] *
# CHECK-DWP-DEBUG: DW_AT_producer [DW_FORM_GNU_str_index] (indexed (0000000a) string = "clang version 13.0.0")
# CHECK-DWP-DEBUG: DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus)
# CHECK-DWP-DEBUG: DW_AT_name [DW_FORM_GNU_str_index] (indexed (0000000b) string = "foo")
# CHECK-DWP-DEBUG: DW_AT_GNU_dwo_name [DW_FORM_GNU_str_index] (indexed (0000000c) string = "foo")
# CHECK-DWP-DEBUG: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x06105e732fad3796)
//clang++ -ffunction-sections -fno-exceptions -g -gsplit-dwarf=split -S debug-fission-simple.cpp -o debug-fission-simple.s
static int foo = 2;
int doStuff(int val) {

30
bolt/test/X86/dwarf4-ftypes-dwo-input-dwp-output.test
View File

@@ -1,30 +0,0 @@
# REQUIRES: system-linux
; RUN: rm -rf %t
; RUN: mkdir %t
; RUN: cd %t
; RUN: llvm-mc --split-dwarf-file=main.dwo --triple=x86_64-unknown-linux-gnu \
; RUN: --filetype=obj %p/Inputs/dwarf4-ftypes-split-dwarf.s -o=main.o
; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o -o main.exe
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.dwo | FileCheck -check-prefix=PRE-BOLT %s
; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections --write-dwp
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.bolt.dwp | FileCheck -check-prefix=BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-TU-INDEX %s
;; Test input into bolt a .dwo file with TU Index.
;; Make sure the output .dwp file has a type information.
; PRE-BOLT: DW_TAG_type_unit
; PRE-BOLT: DW_TAG_type_unit
; PRE-BOLT-DWP-TU-INDEX: version = 2, units = 2, slots = 4
; PRE-BOLT-DWP-TU-INDEX: Index Signature
; PRE-BOLT-DWP-TU-INDEX: 0x675d23e4f33235f2
; PRE-BOLT-DWP-TU-INDEX-NEXT: 0x49dc260088be7e56
; BOLT: DW_TAG_type_unit
; BOLT: DW_TAG_type_unit
; BOLT-DWP-TU-INDEX: version = 2, units = 2, slots = 4
; BOLT-DWP-TU-INDEX: Index Signature
; BOLT-DWP-TU-INDEX: 0x675d23e4f33235f2
; BOLT-DWP-TU-INDEX-NEXT: 0x49dc260088be7e56

45
bolt/test/X86/dwarf4-ftypes-dwo-mono-input-dwp-output.test
View File

@@ -1,45 +0,0 @@
# REQUIRES: system-linux
; RUN: rm -rf %t
; RUN: mkdir %t
; RUN: cd %t
; RUN: llvm-mc --split-dwarf-file=main.dwo -dwarf-version=4 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf4-split-gdb-index-types-main.s -o main.o
; RUN: llvm-mc --split-dwarf-file=helper.dwo -dwarf-version=4 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf4-split-gdb-index-types-helper.s -o helper1.o
; RUN: llvm-mc -dwarf-version=4 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf4-types-helper2.s -o helper2.o
; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o helper1.o helper2.o -o main.exe
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.dwo | FileCheck -check-prefix=PRE-BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-types helper2.o | FileCheck -check-prefix=PRE-BOLT2 %s
; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections --write-dwp
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.bolt.dwp | FileCheck -check-prefix=BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-TU-INDEX %s
;; Test input into bolt a .dwo file with TU Index.
;; Test split-dwarf and monolithic TUs.
;; Make sure the output .dwp file has a type information.
; PRE-BOLT: 0x675d23e4f33235f2
; PRE-BOLT: DW_TAG_type_unit
; PRE-BOLT: 0x49dc260088be7e56
; PRE-BOLT: DW_TAG_type_unit
; PRE-BOLT2: 0x8f55ac73549bc003
; PRE-BOLT2: DW_TAG_type_unit
; PRE-BOLT2: 0xe7734af8fed0632e
; PRE-BOLT2: DW_TAG_type_unit
; BOLT: 0x675d23e4f33235f2
; BOLT: DW_TAG_type_unit
; BOLT: 0x49dc260088be7e56
; BOLT: DW_TAG_type_unit
; BOLT: 0x104ec427d2ebea6f
; BOLT: DW_TAG_type_unit
; BOLT: 0xb4580bc1535df1e4
; BOLT: DW_TAG_type_unit
; BOLT-NOT: 0x8f55ac73549bc003
; BOLT-NOT: 0xe7734af8fed0632e
; BOLT-DWP-TU-INDEX: version = 2, units = 4, slots = 8
; BOLT-DWP-TU-INDEX: Index Signature
; BOLT-DWP-TU-INDEX: 0x675d23e4f33235f2
; BOLT-DWP-TU-INDEX-NEXT: 0xb4580bc1535df1e4
; BOLT-DWP-TU-INDEX-NEXT: 0x49dc260088be7e56
; BOLT-DWP-TU-INDEX-NEXT: 0x104ec427d2ebea6f

53
bolt/test/X86/dwarf5-df-types-modify-dwo-name-mixed.test
View File

@@ -72,59 +72,6 @@
; BOLT-NEXT: "helper.cpp"
; BOLT-NEXT: "helper.dwo"
;; Tests that BOLT correctly handles updating DW_AT_dwo_name when it outputs a DWP file.
;; Currently skipping one of Type units because it is not being de-dupped.
;; In the tu-index this TU is not present.
; RUN: rm main.exe.bolt
; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections --write-dwp
; RUN: llvm-dwarfdump --debug-info -r 0 main.exe.bolt.dwp > logDWP.txt
; RUN: llvm-dwarfdump --debug-str-offsets main.exe.bolt.dwp >> logDWP.txt
; RUN: cat logDWP.txt | FileCheck -check-prefix=BOLT-DWP %s
; BOLT-DWP: DW_TAG_type_unit
; BOLT-DWP: DW_AT_comp_dir (".")
; BOLT-DWP: DW_AT_dwo_name ("main.dwo.dwo")
; BOLT-DWP: DW_TAG_type_unit
; BOLT-DWP: DW_AT_comp_dir (".")
; BOLT-DWP: DW_AT_dwo_name ("main.dwo.dwo")
; BOLT-DWP: DW_TAG_compile_unit
; BOLT-DWP: DW_AT_dwo_name ("main.dwo.dwo")
; BOLT-DWP: DW_TAG_type_unit
; BOLT-DWP-NOT: DW_AT_dwo_name
; BOLT-DWP: Contribution size = 68, Format = DWARF32, Version = 5
; BOLT-DWP-NEXT: "main"
; BOLT-DWP-NEXT: "int"
; BOLT-DWP-NEXT: "argc"
; BOLT-DWP-NEXT: "argv"
; BOLT-DWP-NEXT: "char"
; BOLT-DWP-NEXT: "f2"
; BOLT-DWP-NEXT: "."
; BOLT-DWP-NEXT: "main.dwo.dwo"
; BOLT-DWP-NEXT: "c1"
; BOLT-DWP-NEXT: "Foo2"
; BOLT-DWP-NEXT: "f3"
; BOLT-DWP-NEXT: "c2"
; BOLT-DWP-NEXT: "c3"
; BOLT-DWP-NEXT: "Foo2a"
; BOLT-DWP-NEXT: "clang version 18.0.0git (git@github.com:ayermolo/llvm-project.git db35fa8fc524127079662802c4735dbf397f86d0)"
; BOLT-DWP-NEXT: "main.cpp"
; BOLT-DWP-NEXT: Contribution size = 64, Format = DWARF32, Version = 5
; BOLT-DWP-NEXT: "fooint"
; BOLT-DWP-NEXT: "int"
; BOLT-DWP-NEXT: "_Z3foov"
; BOLT-DWP-NEXT: "foo"
; BOLT-DWP-NEXT: "fint"
; BOLT-DWP-NEXT: "c1"
; BOLT-DWP-NEXT: "c2"
; BOLT-DWP-NEXT: "Foo2Int"
; BOLT-DWP-NEXT: "f"
; BOLT-DWP-NEXT: "char"
; BOLT-DWP-NEXT: "c3"
; BOLT-DWP-NEXT: "Foo2a"
; BOLT-DWP-NEXT: "clang version 18.0.0"
; BOLT-DWP-NEXT: "helper.cpp"
; BOLT-DWP-NEXT: "helper.dwo
;; Tests that BOLT correctly handles updating DW_AT_comp_dir/DW_AT_dwo_name when outptut directory is specified.
; RUN: mkdir DWOOut

25
bolt/test/X86/dwarf5-df-types-modify-dwo-name.test
View File

@@ -73,31 +73,6 @@
; BOLT-NEXT: "clang version 18.0.0git (git@github.com:ayermolo/llvm-project.git db35fa8fc524127079662802c4735dbf397f86d0)"
; BOLT-NEXT: "helper.cpp"
;; Tests that BOLT correctly handles updating DW_AT_dwo_name when it outputs a DWP file.
;; Currently skipping one of Type units because it is not being de-dupped.
;; In the tu-index this TU is not present.
; RUN: rm main.exe.bolt
; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections --write-dwp
; RUN: llvm-dwarfdump --debug-info -r 0 main.exe.bolt.dwp > logDWP.txt
; RUN: llvm-dwarfdump --debug-str-offsets main.exe.bolt.dwp >> logDWP.txt
; RUN: cat logDWP.txt | FileCheck -check-prefix=BOLT-DWP %s
; BOLT-DWP: DW_TAG_type_unit
; BOLT-DWP: DW_AT_comp_dir (".")
; BOLT-DWP: DW_AT_dwo_name ("main.dwo.dwo")
; BOLT-DWP: DW_TAG_type_unit
; BOLT-DWP: DW_AT_comp_dir (".")
; BOLT-DWP: DW_AT_dwo_name ("main.dwo.dwo")
; BOLT-DWP: DW_TAG_compile_unit
; BOLT-DWP: DW_AT_dwo_name ("main.dwo.dwo")
; BOLT-DWP: DW_TAG_type_unit
; BOLT-DWP: DW_AT_comp_dir (".")
; BOLT-DWP: DW_AT_dwo_name ("helper.dwo.dwo")
; BOLT-DWP: DW_TAG_type_unit
; BOLT-DWP: DW_TAG_compile_unit
; BOLT-DWP: DW_AT_name ("helper.cpp")
; BOLT-DWP: DW_AT_dwo_name ("helper.dwo.dwo")
;; Tests that BOLT correctly handles updating DW_AT_comp_dir/DW_AT_dwo_name when outptut directory is specified.
; RUN: mkdir DWOOut

55
bolt/test/X86/dwarf5-ftypes-dwo-mono-input-dwp-output.test
View File

@@ -1,55 +0,0 @@
# REQUIRES: system-linux
; RUN: rm -rf %t
; RUN: mkdir %t
; RUN: cd %t
; RUN: llvm-mc --split-dwarf-file=main.dwo -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-split-gdb-index-types-main.s -o main.o
; RUN: llvm-mc --split-dwarf-file=helper.dwo -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-split-gdb-index-types-helper.s -o helper1.o
; RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-types-helper2.s -o helper2.o
; RUN: %clang %cflags -gdwarf-5 -gsplit-dwarf=split main.o helper1.o helper2.o -o main.exe
; RUN: llvm-dwarfdump --show-form --verbose --debug-info main.dwo | FileCheck -check-prefix=PRE-BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-info helper2.o | FileCheck -check-prefix=PRE-BOLT2 %s
; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections --write-dwp
; RUN: llvm-dwarfdump --show-form --verbose --debug-info -r 0 main.exe.bolt.dwp | FileCheck -check-prefix=BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-TU-INDEX %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-cu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-CU-INDEX %s
;; Test input into bolt a .dwo file with TU Index.
;; Test split-dwarf and monolithic TUs.
;; Make sure the output .dwp file has a type and cu information.
; PRE-BOLT: Type Unit
; PRE-BOLT-SAME: 0x675d23e4f33235f2
; PRE-BOLT: Type Unit
; PRE-BOLT-SAME: 0x49dc260088be7e56
; PRE-BOLT2: 0x8f55ac73549bc003
; PRE-BOLT2: DW_TAG_type_unit
; PRE-BOLT2: 0xe7734af8fed0632e
; PRE-BOLT2: DW_TAG_type_unit
; BOLT: 0x00000000: Type Unit: length = 0x00000047
; BOLT-SAME: 0x675d23e4f33235f2
; BOLT: 0x0000004b: Type Unit: length = 0x0000003e
; BOLT-SAME: 0x49dc260088be7e56
; BOLT: 0x0000008d: Compile Unit: length = 0x00000077
; BOLT-SAME: 0x4257354d8bb35644
; BOLT: 0x00000108: Type Unit: length = 0x00000047
; BOLT-SAME: 0x104ec427d2ebea6f
; BOLT: 0x00000153: Type Unit: length = 0x0000003e
; BOLT-SAME: 0xb4580bc1535df1e4
; BOLT: 0x00000195: Compile Unit: length = 0x00000054
; BOLT-SAME: 0x7738bfb5f3edfb73
; BOLT-NOT: 0x8f55ac73549bc003
; BOLT-NOT: 0xe7734af8fed0632e
; BOLT-DWP-TU-INDEX: version = 5, units = 4, slots = 8
; BOLT-DWP-TU-INDEX: Index Signature
; BOLT-DWP-TU-INDEX: 3 0x675d23e4f33235f2 [0x0000000000000000, 0x000000000000004b) [0x00000000, 0x00000083) [0x00000000, 0x00000056) [0x00000000, 0x00000044)
; BOLT-DWP-TU-INDEX: 5 0xb4580bc1535df1e4 [0x0000000000000153, 0x0000000000000195) [0x00000083, 0x000000f9) [0x00000056, 0x000000ae) [0x00000044, 0x00000084)
; BOLT-DWP-TU-INDEX: 7 0x49dc260088be7e56 [0x000000000000004b, 0x000000000000008d) [0x00000000, 0x00000083) [0x00000000, 0x00000056) [0x00000000, 0x00000044)
; BOLT-DWP-TU-INDEX: 8 0x104ec427d2ebea6f [0x0000000000000108, 0x0000000000000153) [0x00000083, 0x000000f9) [0x00000056, 0x000000ae) [0x00000044, 0x00000084)
; BOLT-DWP-CU-INDEX: version = 5, units = 2, slots = 4
; BOLT-DWP-CU-INDEX: Index Signature
; BOLT-DWP-CU-INDEX: 1 0x4257354d8bb35644 [0x000000000000008d, 0x0000000000000108) [0x00000000, 0x00000083) [0x00000000, 0x00000056) [0x00000000, 0x00000044)
; BOLT-DWP-CU-INDEX: 4 0x7738bfb5f3edfb73 [0x0000000000000195, 0x00000000000001ed) [0x00000083, 0x000000f9) [0x00000056, 0x000000ae) [0x00000044, 0x00000084)