Diff 434548

bolt/include/bolt/Core/DebugData.h

Show All 28 Lines

#include <vector> #include <vector>

#define DWARF2_FLAG_END_SEQUENCE (1 << 4) #define DWARF2_FLAG_END_SEQUENCE (1 << 4)

namespace llvm { namespace llvm {

namespace bolt { namespace bolt {

struct AttrInfo {

DWARFFormValue V;

const DWARFAbbreviationDeclaration *AbbrevDecl;

maksfbUnsubmitted

Done

Drop const here.

maksfb: Drop `const` here.

maksfbUnsubmitted

Done

I take it back.

maksfb: I take it back.

uint64_t Offset;

uint32_t Size; // Size of the attribute.

};

/// Finds attributes FormValue and Offset.

///

/// \param DIE die to look up in.

/// \param AbbrevDecl abbrev declaration for the die.

/// \param Index an index in Abbrev declaration entry.

Optional<AttrInfo>

findAttributeInfo(const DWARFDie DIE,

const DWARFAbbreviationDeclaration *AbbrevDecl,

uint32_t Index);

/// Finds attributes FormValue and Offset.

///

/// \param DIE die to look up in.

/// \param Attr the attribute to extract.

/// \return an optional AttrInfo with DWARFFormValue and Offset.

Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE, dwarf::Attribute Attr);

// DWARF5 Header in order of encoding. // DWARF5 Header in order of encoding.

// Types represent encodnig sizes. // Types represent encodnig sizes.

using UnitLengthType = uint32_t; using UnitLengthType = uint32_t;

using VersionType = uint16_t; using VersionType = uint16_t;

using AddressSizeType = uint8_t; using AddressSizeType = uint8_t;

using SegmentSelectorType = uint8_t; using SegmentSelectorType = uint8_t;

using OffsetEntryCountType = uint32_t; using OffsetEntryCountType = uint32_t;

/// Get DWARF5 Header size. /// Get DWARF5 Header size.

▲ Show 20 Lines • Show All 397 Lines • ▼ Show 20 Lines private:

void initialize(); void initialize();

/// Creats internal data stractures. /// Creats internal data stractures.

void create(); void create();

std::unique_ptr<DebugStrBufferVector> StrBuffer; std::unique_ptr<DebugStrBufferVector> StrBuffer;

std::unique_ptr<raw_svector_ostream> StrStream; std::unique_ptr<raw_svector_ostream> StrStream;

BinaryContext &BC; BinaryContext &BC;

}; };

class DebugInfoBinaryPatcher;

class DebugAbbrevWriter;

enum class LocWriterKind { DebugLocWriter, DebugLoclistWriter }; enum class LocWriterKind { DebugLocWriter, DebugLoclistWriter };

/// Serializes part of a .debug_loc DWARF section with LocationLists. /// Serializes part of a .debug_loc DWARF section with LocationLists.

class SimpleBinaryPatcher; class SimpleBinaryPatcher;

class DebugLocWriter { class DebugLocWriter {

protected:

DebugLocWriter(uint8_t DwarfVersion, LocWriterKind Kind)

: DwarfVersion(DwarfVersion), Kind(Kind) {

init();

}

public: public:

DebugLocWriter() = delete; DebugLocWriter() { init(); };

DebugLocWriter(BinaryContext *BC);

virtual ~DebugLocWriter(){}; virtual ~DebugLocWriter(){};

/// Writes out location lists and stores internal patches. /// Writes out location lists and stores internal patches.

virtual void addList(uint64_t AttrOffset, uint32_t LocListIndex, virtual void addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,

DebugLocationsVector &&LocList); DebugInfoBinaryPatcher &DebugInfoPatcher,

DebugAbbrevWriter &AbbrevWriter);

/// Writes out locations in to a local buffer, and adds Debug Info patches. /// Writes out locations in to a local buffer, and adds Debug Info patches.

virtual void finalize(uint64_t SectionOffset, virtual void finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,

SimpleBinaryPatcher &DebugInfoPatcher); DebugAbbrevWriter &AbbrevWriter);

/// Return internal buffer. /// Return internal buffer.

virtual std::unique_ptr<DebugBufferVector> getBuffer(); virtual std::unique_ptr<DebugBufferVector> getBuffer();

/// Returns DWARF version. /// Returns DWARF version.

uint8_t getDwarfVersion() const { return DwarfVersion; } uint8_t getDwarfVersion() const { return DwarfVersion; }

/// Offset of an empty location list. /// Offset of an empty location list.

static constexpr uint32_t EmptyListOffset = 0; static constexpr uint32_t EmptyListOffset = 0;

LocWriterKind getKind() const { return Kind; } LocWriterKind getKind() const { return Kind; }

static bool classof(const DebugLocWriter *Writer) { static bool classof(const DebugLocWriter *Writer) {

return Writer->getKind() == LocWriterKind::DebugLocWriter; return Writer->getKind() == LocWriterKind::DebugLocWriter;

} }

protected: protected:

std::unique_ptr<DebugBufferVector> LocBuffer; std::unique_ptr<DebugBufferVector> LocBuffer;

std::unique_ptr<raw_svector_ostream> LocStream; std::unique_ptr<raw_svector_ostream> LocStream;

/// Current offset in the section (updated as new entries are written). /// Current offset in the section (updated as new entries are written).

/// Starts with 0 here since this only writes part of a full location lists /// Starts with 0 here since this only writes part of a full location lists

/// section. In the final section, the first 16 bytes are reserved for an /// section. In the final section, for DWARF4, the first 16 bytes are reserved for an

/// empty list. /// empty list.

uint32_t SectionOffset{0}; static uint32_t LocSectionOffset;

uint8_t DwarfVersion{4}; uint8_t DwarfVersion{4};

LocWriterKind Kind{LocWriterKind::DebugLocWriter}; LocWriterKind Kind{LocWriterKind::DebugLocWriter};

private: private:

/// Inits all the relative data structures.

maksfbUnsubmitted

Done

s/relative/related/

maksfb: s/relative/related/

void init();

struct LocListDebugInfoPatchType { struct LocListDebugInfoPatchType {

uint64_t DebugInfoAttrOffset; uint64_t DebugInfoAttrOffset;

uint64_t LocListOffset; uint64_t LocListOffset;

}; };

using VectorLocListDebugInfoPatchType = using VectorLocListDebugInfoPatchType =

std::vector<LocListDebugInfoPatchType>; std::vector<LocListDebugInfoPatchType>;

/// The list of debug info patches to be made once individual /// The list of debug info patches to be made once individual

/// location list writers have been filled /// location list writers have been filled

VectorLocListDebugInfoPatchType LocListDebugInfoPatches; VectorLocListDebugInfoPatchType LocListDebugInfoPatches;

using VectorEmptyLocListAttributes = std::vector<uint64_t>;

/// Contains all the attributes pointing to empty location list.

VectorEmptyLocListAttributes EmptyAttrLists;

}; };

class DebugLoclistWriter : public DebugLocWriter { class DebugLoclistWriter : public DebugLocWriter {

public: public:

~DebugLoclistWriter() {} ~DebugLoclistWriter() {}

DebugLoclistWriter() = delete; DebugLoclistWriter() = delete;

DebugLoclistWriter(BinaryContext *BC, DWARFUnit &Unit, DebugLoclistWriter(DWARFUnit &Unit, uint8_t DV, bool SD)

uint32_t LocListsBaseAttrOffset, uint8_t DV, bool SD) : DebugLocWriter(DV, LocWriterKind::DebugLoclistWriter), CU(Unit),

: DebugLocWriter(BC), CU(Unit), IsSplitDwarf(SD) {

LocListsBaseAttrOffset(LocListsBaseAttrOffset), IsSplitDwarf(SD) {

Kind = LocWriterKind::DebugLoclistWriter;

DwarfVersion = DV;

assert(DebugLoclistWriter::AddrWriter && assert(DebugLoclistWriter::AddrWriter &&

"Please use SetAddressWriter to initialize " "Please use SetAddressWriter to initialize "

"DebugAddrWriter before instantiation."); "DebugAddrWriter before instantiation.");

if (DwarfVersion >= 5) {

LocBodyBuffer = std::make_unique<DebugBufferVector>();

LocBodyStream = std::make_unique<raw_svector_ostream>(*LocBodyBuffer);

} else {

// Writing out empty location list to which all references to empty

// location lists will point.

const char Zeroes[16] = {0};

*LocStream << StringRef(Zeroes, 16);

}

} }

static void setAddressWriter(DebugAddrWriter *AddrW) { AddrWriter = AddrW; } static void setAddressWriter(DebugAddrWriter *AddrW) { AddrWriter = AddrW; }

/// Stores location lists internally to be written out during finalize phase. /// Stores location lists internally to be written out during finalize phase.

virtual void addList(uint64_t AttrOffset, uint32_t LocListIndex, virtual void addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,

DebugLocationsVector &&LocList) override; DebugInfoBinaryPatcher &DebugInfoPatcher,

DebugAbbrevWriter &AbbrevWriter) override;

/// Writes out locations in to a local buffer and applies debug info patches. /// Writes out locations in to a local buffer and applies debug info patches.

void finalize(uint64_t SectionOffset, void finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,

SimpleBinaryPatcher &DebugInfoPatcher) override; DebugAbbrevWriter &AbbrevWriter) override;

/// Returns CU ID. /// Returns CU ID.

/// For Skelton CU it is a CU Offset. /// For Skelton CU it is a CU Offset.

/// For DWO CU it is a DWO ID. /// For DWO CU it is a DWO ID.

uint64_t getCUID() const { uint64_t getCUID() const {

return CU.isDWOUnit() ? *CU.getDWOId() : CU.getOffset(); return CU.isDWOUnit() ? *CU.getDWOId() : CU.getOffset();

} }

LocWriterKind getKind() const { return DebugLocWriter::getKind(); } LocWriterKind getKind() const { return DebugLocWriter::getKind(); }

static bool classof(const DebugLocWriter *Writer) { static bool classof(const DebugLocWriter *Writer) {

return Writer->getKind() == LocWriterKind::DebugLoclistWriter; return Writer->getKind() == LocWriterKind::DebugLoclistWriter;

} }

bool isSplitDwarf() const { return IsSplitDwarf; } bool isSplitDwarf() const { return IsSplitDwarf; }

constexpr static uint32_t InvalidIndex = UINT32_MAX; constexpr static uint32_t InvalidIndex = UINT32_MAX;

constexpr static uint32_t InvalidLocListsBaseAttrOffset = UINT32_MAX;

private: private:

/// Writes out locations in to a local buffer and applies debug info patches. /// Writes out locations in to a local buffer and applies debug info patches.

void finalizeDWARFLegacy(uint64_t SectionOffset, void finalizeDWARF5(DebugInfoBinaryPatcher &DebugInfoPatcher,

SimpleBinaryPatcher &DebugInfoPatcher); DebugAbbrevWriter &AbbrevWriter);

/// Writes out locations in to a local buffer and applies debug info patches.

void finalizeDWARF5(uint64_t SectionOffset,

SimpleBinaryPatcher &DebugInfoPatcher);

struct LocPatch {

uint64_t AttrOffset{0};

uint32_t Index;

DebugLocationsVector LocList;

};

using LocPatchVec = SmallVector<LocPatch, 4>;

LocPatchVec Patches;

class Patch {

public:

Patch() = delete;

Patch(uint64_t O, uint64_t A) : Offset(O), Address(A) {}

uint64_t Offset{0};

uint64_t Address{0};

};

static DebugAddrWriter *AddrWriter; static DebugAddrWriter *AddrWriter;

DWARFUnit &CU; DWARFUnit &CU;

uint32_t LocListsBaseAttrOffset{InvalidLocListsBaseAttrOffset};

bool IsSplitDwarf{false}; bool IsSplitDwarf{false};

// Used for DWARF5 to store location lists before being finalized.

std::unique_ptr<DebugBufferVector> LocBodyBuffer;

std::unique_ptr<raw_svector_ostream> LocBodyStream;

std::vector<uint32_t> RelativeLocListOffsets;

uint32_t NumberOfentries{0};

maksfbUnsubmitted

Done

std::vector<uint32_t> RelativeLocListOffsets;

- uint32_t NumberOfentries{0};

+ uint32_t NumberOfEntries{0};

static uint32_t LoclistBaseOffset;

Or NumEntries.

maksfb: Or `NumEntries`.

static uint32_t LoclistBaseOffset;

}; };

enum class PatcherKind { SimpleBinaryPatcher, DebugInfoBinaryPatcher }; enum class PatcherKind { SimpleBinaryPatcher, DebugInfoBinaryPatcher };

/// Abstract interface for classes that apply modifications to a binary string. /// Abstract interface for classes that apply modifications to a binary string.

class BinaryPatcher { class BinaryPatcher {

public: public:

virtual ~BinaryPatcher() {} virtual ~BinaryPatcher() {}

/// Applies modifications to the copy of binary string \p BinaryContents . /// Applies modifications to the copy of binary string \p BinaryContents .

▲ Show 20 Lines • Show All 562 Lines • ▼ Show 20 Lines public:

} }

/// Sets DWARF version for this line table. /// Sets DWARF version for this line table.

void setDwarfVersion(uint16_t V) { DwarfVersion = V; } void setDwarfVersion(uint16_t V) { DwarfVersion = V; }

// Returns DWARF Version for this line table. // Returns DWARF Version for this line table.

uint16_t getDwarfVersion() const { return DwarfVersion; } uint16_t getDwarfVersion() const { return DwarfVersion; }

}; };

struct AttrInfo {

DWARFFormValue V;

uint64_t Offset;

uint32_t Size; // Size of the attribute.

};

Optional<AttrInfo>

findAttributeInfo(const DWARFDie DIE,

const DWARFAbbreviationDeclaration *AbbrevDecl,

uint32_t Index);

} // namespace bolt } // namespace bolt

} // namespace llvm } // namespace llvm

#endif #endif

bolt/include/bolt/Rewrite/DWARFRewriter.h

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines	class DWARFRewriter {
/// attribute.		/// attribute.
void updateDWARFObjectAddressRanges(const DWARFDie DIE,		void updateDWARFObjectAddressRanges(const DWARFDie DIE,
uint64_t DebugRangesOffset,		uint64_t DebugRangesOffset,
SimpleBinaryPatcher &DebugInfoPatcher,		SimpleBinaryPatcher &DebugInfoPatcher,
DebugAbbrevWriter &AbbrevWriter,		DebugAbbrevWriter &AbbrevWriter,
Optional<uint64_t> RangesBase = None);		Optional<uint64_t> RangesBase = None);

std::unique_ptr<DebugBufferVector>		std::unique_ptr<DebugBufferVector>
makeFinalLocListsSection(SimpleBinaryPatcher &DebugInfoPatcher,		makeFinalLocListsSection(DebugInfoBinaryPatcher &DebugInfoPatcher,
DWARFVersion Version);		DWARFVersion Version);

/// Finalize debug sections in the main binary.		/// Finalize debug sections in the main binary.
CUOffsetMap finalizeDebugSections(DebugInfoBinaryPatcher &DebugInfoPatcher);		CUOffsetMap finalizeDebugSections(DebugInfoBinaryPatcher &DebugInfoPatcher);

/// Patches the binary for DWARF address ranges (e.g. in functions and lexical		/// Patches the binary for DWARF address ranges (e.g. in functions and lexical
/// blocks) to be updated.		/// blocks) to be updated.
void updateDebugAddressRanges();		void updateDebugAddressRanges();
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

bolt/lib/Core/DebugData.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines	if (ValSizeOpt) {
uint64_t NewOffset = Offset;		uint64_t NewOffset = Offset;
DWARFFormValue::skipValue(Value->getForm(), DebugInfoData, &NewOffset,		DWARFFormValue::skipValue(Value->getForm(), DebugInfoData, &NewOffset,
U.getFormParams());		U.getFormParams());
// This includes entire size of the entry, which might not be just the		// This includes entire size of the entry, which might not be just the
// encoding part. For example for DW_AT_loc it will include expression		// encoding part. For example for DW_AT_loc it will include expression
// location.		// location.
ValSize = NewOffset - Offset;		ValSize = NewOffset - Offset;
}		}
		return AttrInfo{*Value, DIE.getAbbreviationDeclarationPtr(), Offset, ValSize};
		}

return AttrInfo{*Value, Offset, ValSize};		/// Finds attributes FormValue and Offset.
		///
		/// \param DIE die to look up in.
		/// \param Attr the attribute to extract.
		/// \return an optional AttrInfo with DWARFFormValue and Offset.
		Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
		dwarf::Attribute Attr) {
		if (!DIE.isValid())
		return None;
		const DWARFAbbreviationDeclaration *AbbrevDecl =
		DIE.getAbbreviationDeclarationPtr();
		if (!AbbrevDecl)
		return None;
		Optional<uint32_t> Index = AbbrevDecl->findAttributeIndex(Attr);
		if (!Index)
		return None;
		return findAttributeInfo(DIE, AbbrevDecl, *Index);
}		}
		maksfbUnsubmitted Done Reply Inline Actions No need to duplicate comments from the header. maksfb: No need to duplicate comments from the header.

const DebugLineTableRowRef DebugLineTableRowRef::NULL_ROW{0, 0};		const DebugLineTableRowRef DebugLineTableRowRef::NULL_ROW{0, 0};

namespace {		namespace {

LLVM_ATTRIBUTE_UNUSED		LLVM_ATTRIBUTE_UNUSED
static void printLE64(const std::string &S) {		static void printLE64(const std::string &S) {
for (uint32_t I = 0, Size = S.size(); I < Size; ++I) {		for (uint32_t I = 0, Size = S.size(); I < Size; ++I) {
▲ Show 20 Lines • Show All 402 Lines • ▼ Show 20 Lines

uint64_t DebugAddrWriterDwarf5::getOffset(DWARFUnit &Unit) {		uint64_t DebugAddrWriterDwarf5::getOffset(DWARFUnit &Unit) {
auto Iter = DWOIdToOffsetMap.find(getCUID(Unit));		auto Iter = DWOIdToOffsetMap.find(getCUID(Unit));
assert(Iter != DWOIdToOffsetMap.end() &&		assert(Iter != DWOIdToOffsetMap.end() &&
"Offset in to.debug_addr was not found for CU ID.");		"Offset in to.debug_addr was not found for CU ID.");
return Iter->second;		return Iter->second;
}		}

DebugLocWriter::DebugLocWriter(BinaryContext *BC) {		void DebugLocWriter::init() {
LocBuffer = std::make_unique<DebugBufferVector>();		LocBuffer = std::make_unique<DebugBufferVector>();
LocStream = std::make_unique<raw_svector_ostream>(*LocBuffer);		LocStream = std::make_unique<raw_svector_ostream>(*LocBuffer);
		// Writing out empty location list to which all references to empty location
		// lists will point.
		if (!LocSectionOffset && DwarfVersion < 5) {
		const char Zeroes[16] = {0};
		*LocStream << StringRef(Zeroes, 16);
		LocSectionOffset += 16;
		}
}		}

void DebugLocWriter::addList(uint64_t AttrOffset, uint32_t LocListIndex,		uint32_t DebugLocWriter::LocSectionOffset = 0;
DebugLocationsVector &&LocList) {		void DebugLocWriter::addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
		DebugInfoBinaryPatcher &DebugInfoPatcher,
		DebugAbbrevWriter &AbbrevWriter) {
		const uint64_t AttrOffset = AttrVal.Offset;
if (LocList.empty()) {		if (LocList.empty()) {
EmptyAttrLists.push_back(AttrOffset);		DebugInfoPatcher.addLE32Patch(AttrOffset, DebugLocWriter::EmptyListOffset);
return;		return;
}		}
// Since there is a separate DebugLocWriter for each thread,		// Since there is a separate DebugLocWriter for each thread,
// we don't need a lock to read the SectionOffset and update it.		// we don't need a lock to read the SectionOffset and update it.
const uint32_t EntryOffset = SectionOffset;		const uint32_t EntryOffset = LocSectionOffset;

for (const DebugLocationEntry &Entry : LocList) {		for (const DebugLocationEntry &Entry : LocList) {
support::endian::write(*LocStream, static_cast<uint64_t>(Entry.LowPC),		support::endian::write(*LocStream, static_cast<uint64_t>(Entry.LowPC),
support::little);		support::little);
support::endian::write(*LocStream, static_cast<uint64_t>(Entry.HighPC),		support::endian::write(*LocStream, static_cast<uint64_t>(Entry.HighPC),
support::little);		support::little);
support::endian::write(*LocStream, static_cast<uint16_t>(Entry.Expr.size()),		support::endian::write(*LocStream, static_cast<uint16_t>(Entry.Expr.size()),
support::little);		support::little);
LocStream << StringRef(reinterpret_cast<const char >(Entry.Expr.data()),		LocStream << StringRef(reinterpret_cast<const char >(Entry.Expr.data()),
Entry.Expr.size());		Entry.Expr.size());
SectionOffset += 2 * 8 + 2 + Entry.Expr.size();		LocSectionOffset += 2 * 8 + 2 + Entry.Expr.size();
}		}
LocStream->write_zeros(16);		LocStream->write_zeros(16);
SectionOffset += 16;		LocSectionOffset += 16;
LocListDebugInfoPatches.push_back({AttrOffset, EntryOffset});		LocListDebugInfoPatches.push_back({AttrOffset, EntryOffset});
}		DebugInfoPatcher.addLE32Patch(AttrOffset, EntryOffset);

void DebugLoclistWriter::addList(uint64_t AttrOffset, uint32_t LocListIndex,
DebugLocationsVector &&LocList) {
Patches.push_back({AttrOffset, LocListIndex, std::move(LocList)});
}		}

std::unique_ptr<DebugBufferVector> DebugLocWriter::getBuffer() {		std::unique_ptr<DebugBufferVector> DebugLocWriter::getBuffer() {
return std::move(LocBuffer);		return std::move(LocBuffer);
}		}

// DWARF 4: 2.6.2		// DWARF 4: 2.6.2
void DebugLocWriter::finalize(uint64_t SectionOffset,		void DebugLocWriter::finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,
SimpleBinaryPatcher &DebugInfoPatcher) {		DebugAbbrevWriter &AbbrevWriter) {}
for (const auto LocListDebugInfoPatchType : LocListDebugInfoPatches) {
uint64_t Offset = SectionOffset + LocListDebugInfoPatchType.LocListOffset;
DebugInfoPatcher.addLE32Patch(LocListDebugInfoPatchType.DebugInfoAttrOffset,
Offset);
}

for (uint64_t DebugInfoAttrOffset : EmptyAttrLists)
DebugInfoPatcher.addLE32Patch(DebugInfoAttrOffset,
DebugLocWriter::EmptyListOffset);
}

static void writeEmptyListDwarf5(raw_svector_ostream &Stream) {		static void writeEmptyListDwarf5(raw_svector_ostream &Stream) {
support::endian::write(Stream, static_cast<uint32_t>(4), support::little);		support::endian::write(Stream, static_cast<uint32_t>(4), support::little);
support::endian::write(Stream, static_cast<uint8_t>(dwarf::DW_LLE_start_end),		support::endian::write(Stream, static_cast<uint8_t>(dwarf::DW_LLE_start_end),
support::little);		support::little);

const char Zeroes[16] = {0};		const char Zeroes[16] = {0};
Stream << StringRef(Zeroes, 16);		Stream << StringRef(Zeroes, 16);
encodeULEB128(0, Stream);		encodeULEB128(0, Stream);
support::endian::write(		support::endian::write(
Stream, static_cast<uint8_t>(dwarf::DW_LLE_end_of_list), support::little);		Stream, static_cast<uint8_t>(dwarf::DW_LLE_end_of_list), support::little);
}		}

void DebugLoclistWriter::finalizeDWARF5(uint64_t SectionOffset,		static void writeLegacyLocList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
SimpleBinaryPatcher &DebugInfoPatcher) {		DebugInfoBinaryPatcher &DebugInfoPatcher,
		DebugAddrWriter &AddrWriter,
std::unique_ptr<DebugBufferVector> LocArrayBuffer =		DebugBufferVector &LocBuffer, DWARFUnit &CU,
std::make_unique<DebugBufferVector>();		raw_svector_ostream &LocStream) {
std::unique_ptr<raw_svector_ostream> LocArrayStream =		const uint64_t AttrOffset = AttrVal.Offset;
std::make_unique<raw_svector_ostream>(*LocArrayBuffer);		if (LocList.empty()) {
std::unique_ptr<DebugBufferVector> LocBodyBuffer =		DebugInfoPatcher.addLE32Patch(AttrOffset, DebugLocWriter::EmptyListOffset);
std::make_unique<DebugBufferVector>();		return;
std::unique_ptr<raw_svector_ostream> LocBodyStream =		}
std::make_unique<raw_svector_ostream>(*LocBodyBuffer);

const uint32_t SizeOfArraySection = Patches.size() * sizeof(uint32_t);
std::sort(Patches.begin(), Patches.end(),
[](const LocPatch &P1, const LocPatch &P2) -> bool {
return P1.Index < P2.Index;
});

if (LocListsBaseAttrOffset != InvalidLocListsBaseAttrOffset)
DebugInfoPatcher.addLE32Patch(LocListsBaseAttrOffset,
SectionOffset +
getDWARF5RngListLocListHeaderSize());

uint32_t Index{0};		const uint32_t EntryOffset = LocBuffer.size();
for (LocPatch &Patch : Patches) {		for (const DebugLocationEntry &Entry : LocList) {
const uint32_t EntryOffset = LocBodyBuffer->size();		support::endian::write(LocStream,
if (Patch.LocList.empty()) {		static_cast<uint8_t>(dwarf::DW_LLE_startx_length),
if (Patch.Index == DebugLoclistWriter::InvalidIndex)		support::little);
DebugInfoPatcher.addLE32Patch(Patch.AttrOffset, EntryOffset);		const uint32_t Index = AddrWriter.getIndexFromAddress(Entry.LowPC, CU);
		encodeULEB128(Index, LocStream);

writeEmptyListDwarf5(*LocBodyStream);		support::endian::write(LocStream,
continue;		static_cast<uint32_t>(Entry.HighPC - Entry.LowPC),
		support::little);
		support::endian::write(LocStream, static_cast<uint16_t>(Entry.Expr.size()),
		support::little);
		LocStream << StringRef(reinterpret_cast<const char *>(Entry.Expr.data()),
		Entry.Expr.size());
		}
		support::endian::write(LocStream,
		static_cast<uint8_t>(dwarf::DW_LLE_end_of_list),
		support::little);
		DebugInfoPatcher.addLE32Patch(AttrOffset, EntryOffset);
}		}

assert(Patch.Index == DebugLoclistWriter::InvalidIndex \|\|		static void writeDWARF5LocList(
Patch.Index == Index++ && "Gap in LocList Index Array.");		uint32_t &NumberOfentries, AttrInfo &AttrVal, DebugLocationsVector &LocList,
(void)Index;		DebugInfoBinaryPatcher &DebugInfoPatcher, DebugAbbrevWriter &AbbrevWriter,
		DebugAddrWriter &AddrWriter, DebugBufferVector &LocBodyBuffer,
		std::vector<uint32_t> &RelativeLocListOffsets, DWARFUnit &CU,
		raw_svector_ostream &LocBodyStream) {
		if (AttrVal.V.getForm() != dwarf::DW_FORM_loclistx) {
		AbbrevWriter.addAttributePatch(CU, AttrVal.AbbrevDecl,
		dwarf::DW_AT_location, dwarf::DW_AT_location,
		dwarf::DW_FORM_loclistx);
		}
		DebugInfoPatcher.addUDataPatch(AttrVal.Offset, NumberOfentries, AttrVal.Size);
		RelativeLocListOffsets.push_back(LocBodyBuffer.size());
		++NumberOfentries;
		if (LocList.empty()) {
		writeEmptyListDwarf5(LocBodyStream);
		return;
		}

std::vector<uint64_t> OffsetsArray;		std::vector<uint64_t> OffsetsArray;
for (const DebugLocationEntry &Entry : Patch.LocList) {		for (const DebugLocationEntry &Entry : LocList) {
support::endian::write(*LocBodyStream,		support::endian::write(LocBodyStream,
static_cast<uint8_t>(dwarf::DW_LLE_startx_length),		static_cast<uint8_t>(dwarf::DW_LLE_startx_length),
support::little);		support::little);
const uint32_t Index = AddrWriter->getIndexFromAddress(Entry.LowPC, CU);		const uint32_t Index = AddrWriter.getIndexFromAddress(Entry.LowPC, CU);
encodeULEB128(Index, *LocBodyStream);		encodeULEB128(Index, LocBodyStream);
encodeULEB128(Entry.HighPC - Entry.LowPC, *LocBodyStream);		encodeULEB128(Entry.HighPC - Entry.LowPC, LocBodyStream);
encodeULEB128(Entry.Expr.size(), *LocBodyStream);		encodeULEB128(Entry.Expr.size(), LocBodyStream);
*LocBodyStream << StringRef(		LocBodyStream << StringRef(
reinterpret_cast<const char *>(Entry.Expr.data()), Entry.Expr.size());		reinterpret_cast<const char *>(Entry.Expr.data()), Entry.Expr.size());
}		}
support::endian::write(*LocBodyStream,		support::endian::write(LocBodyStream,
static_cast<uint8_t>(dwarf::DW_LLE_end_of_list),		static_cast<uint8_t>(dwarf::DW_LLE_end_of_list),
support::little);		support::little);
		}

		void DebugLoclistWriter::addList(AttrInfo &AttrVal,
		DebugLocationsVector &LocList,
		DebugInfoBinaryPatcher &DebugInfoPatcher,
		DebugAbbrevWriter &AbbrevWriter) {
		if (DwarfVersion < 5)
		writeLegacyLocList(AttrVal, LocList, DebugInfoPatcher, *AddrWriter,
		LocBuffer, CU, LocStream);
		else
		writeDWARF5LocList(NumberOfentries, AttrVal, LocList, DebugInfoPatcher,
		AbbrevWriter, AddrWriter, LocBodyBuffer,
		RelativeLocListOffsets, CU, *LocBodyStream);
		}

		uint32_t DebugLoclistWriter::LoclistBaseOffset = 0;
		void DebugLoclistWriter::finalizeDWARF5(
		DebugInfoBinaryPatcher &DebugInfoPatcher, DebugAbbrevWriter &AbbrevWriter) {
		if (LocBodyBuffer->empty())
		return;

		std::unique_ptr<DebugBufferVector> LocArrayBuffer =
		std::make_unique<DebugBufferVector>();
		std::unique_ptr<raw_svector_ostream> LocArrayStream =
		std::make_unique<raw_svector_ostream>(*LocArrayBuffer);

		const uint32_t SizeOfArraySection = NumberOfentries * sizeof(uint32_t);
// Write out IndexArray		// Write out IndexArray
		for (uint32_t RelativeOffset : RelativeLocListOffsets)
support::endian::write(		support::endian::write(
*LocArrayStream,		*LocArrayStream,
static_cast<uint32_t>(SizeOfArraySection + EntryOffset),		static_cast<uint32_t>(SizeOfArraySection + RelativeOffset),
support::little);		support::little);
// Don't need to patch Index since we are re-using them.
if (Patch.Index == DebugLoclistWriter::InvalidIndex)		std::unique_ptr<DebugBufferVector> Header = getDWARF5Header(
DebugInfoPatcher.addLE32Patch(Patch.AttrOffset, EntryOffset);		{static_cast<uint32_t>(SizeOfArraySection + LocBodyBuffer.get()->size()),
clearList(Patch.LocList);		5, 8, 0, NumberOfentries});
}
if (!Patches.empty()) {
std::unique_ptr<DebugBufferVector> Header =
getDWARF5Header({static_cast<uint32_t>(SizeOfArraySection +
LocBodyBuffer.get()->size()),
5, 8, 0, static_cast<uint32_t>(Patches.size())});
LocStream << Header;		LocStream << Header;
LocStream << LocArrayBuffer;		LocStream << LocArrayBuffer;
LocStream << LocBodyBuffer;		LocStream << LocBodyBuffer;
}
clearList(Patches);
}

void DebugLoclistWriter::finalizeDWARFLegacy(
uint64_t SectionOffset, SimpleBinaryPatcher &DebugInfoPatcher) {
for (LocPatch &Patch : Patches) {
if (Patch.LocList.empty()) {
DebugInfoPatcher.addLE32Patch(Patch.AttrOffset,
DebugLocWriter::EmptyListOffset);
continue;
}
const uint32_t EntryOffset = LocBuffer->size();
for (const DebugLocationEntry &Entry : Patch.LocList) {
support::endian::write(*LocStream,
static_cast<uint8_t>(dwarf::DW_LLE_startx_length),
support::little);
const uint32_t Index = AddrWriter->getIndexFromAddress(Entry.LowPC, CU);
encodeULEB128(Index, *LocStream);

// TODO: Support DWARF5
support::endian::write(*LocStream,
static_cast<uint32_t>(Entry.HighPC - Entry.LowPC),
support::little);
support::endian::write(*LocStream,
static_cast<uint16_t>(Entry.Expr.size()),
support::little);
LocStream << StringRef(reinterpret_cast<const char >(Entry.Expr.data()),
Entry.Expr.size());
}
support::endian::write(*LocStream,
static_cast<uint8_t>(dwarf::DW_LLE_end_of_list),
support::little);
DebugInfoPatcher.addLE32Patch(Patch.AttrOffset, EntryOffset);
clearList(Patch.LocList);
}
clearList(Patches);
}

void DebugLoclistWriter::finalize(uint64_t SectionOffset,		if (!isSplitDwarf()) {
SimpleBinaryPatcher &DebugInfoPatcher) {		if (Optional<AttrInfo> AttrInfoVal =
if (DwarfVersion < 5)		findAttributeInfo(CU.getUnitDIE(), dwarf::DW_AT_loclists_base))
finalizeDWARFLegacy(SectionOffset, DebugInfoPatcher);		DebugInfoPatcher.addLE32Patch(AttrInfoVal->Offset,
else		LoclistBaseOffset +
finalizeDWARF5(SectionOffset, DebugInfoPatcher);		getDWARF5RngListLocListHeaderSize());
		else {
		AbbrevWriter.addAttribute(
		CU, CU.getUnitDIE().getAbbreviationDeclarationPtr(),
		dwarf::DW_AT_loclists_base, dwarf::DW_FORM_sec_offset);
		DebugInfoPatcher.insertNewEntry(CU.getUnitDIE(),
		LoclistBaseOffset + Header->size());
		}
		LoclistBaseOffset += LocBuffer->size();
		}
		clearList(RelativeLocListOffsets);
		clearList(*LocArrayBuffer);
		clearList(*LocBodyBuffer);
		}

		void DebugLoclistWriter::finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,
		DebugAbbrevWriter &AbbrevWriter) {
		if (DwarfVersion >= 5)
		finalizeDWARF5(DebugInfoPatcher, AbbrevWriter);
}		}

DebugAddrWriter *DebugLoclistWriter::AddrWriter = nullptr;		DebugAddrWriter *DebugLoclistWriter::AddrWriter = nullptr;

void DebugInfoBinaryPatcher::addUnitBaseOffsetLabel(uint64_t Offset) {		void DebugInfoBinaryPatcher::addUnitBaseOffsetLabel(uint64_t Offset) {
Offset -= DWPUnitOffset;		Offset -= DWPUnitOffset;
std::lock_guard<std::mutex> Lock(WriterMutex);		std::lock_guard<std::mutex> Lock(WriterMutex);
DebugPatches.emplace_back(new DWARFUnitOffsetBaseLabel(Offset));		DebugPatches.emplace_back(new DWARFUnitOffsetBaseLabel(Offset));
▲ Show 20 Lines • Show All 928 Lines • Show Last 20 Lines

bolt/lib/Rewrite/DWARFRewriter.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines

static void printDie(const DWARFDie &DIE) {

DIE.dump(dbgs(), 0, DumpOpts);

}

namespace llvm {

namespace bolt {

/// Finds attributes FormValue and Offset.

///

/// \param DIE die to look up in.

/// \param Attr the attribute to extract.

/// \return an optional AttrInfo with DWARFFormValue and Offset.

static Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,

dwarf::Attribute Attr) {

if (!DIE.isValid())

return None;

const DWARFAbbreviationDeclaration *AbbrevDecl =

DIE.getAbbreviationDeclarationPtr();

if (!AbbrevDecl)

return None;

Optional<uint32_t> Index = AbbrevDecl->findAttributeIndex(Attr);

if (!Index)

return None;

return findAttributeInfo(DIE, AbbrevDecl, *Index);

}

/// Finds attributes FormValue and Offset.

///

/// \param DIE die to look up in.

/// \param Attrs finds the first attribute that matches and extracts it.

/// \return an optional AttrInfo with DWARFFormValue and Offset.

Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,

std::vector<dwarf::Attribute> Attrs) {

for (dwarf::Attribute &Attr : Attrs)

if (Optional<AttrInfo> Info = findAttributeInfo(DIE, Attr))

return Info;

return None;

▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines

void DWARFRewriter::updateDebugInfo() {

ARangesSectionWriter = std::make_unique<DebugARangesSectionWriter>();

StrWriter = std::make_unique<DebugStrWriter>(BC);

StrOffstsWriter = std::make_unique<DebugStrOffsetsWriter>();

AbbrevWriter = std::make_unique<DebugAbbrevWriter>(*BC.DwCtx);

if (BC.isDWARF5Used()) {

if (!opts::DeterministicDebugInfo) {

// Disabling none deterministic mode for dwarf5, to keep implementation

// simpler.

opts::DeterministicDebugInfo = true;

llvm::errs()

maksfbUnsubmitted

Done

opts::DeterministicDebugInfo = true;

- llvm::errs()

+ errs()

<< "BOLT-WARNING: --deterministic-debuginfo is being deprecated.\n";

maksfb:

<< "BOLT-WARNING: --deterministic-debuginfo is being deprecated.\n";

maksfbUnsubmitted

Done

llvm::errs()

- << "BOLT-WARNING: --deterministic-debuginfo is being deprecated.\n";

+ << "BOLT-WARNING: --deterministic-debuginfo is being deprecated\n";

}

if (BC.isDWARF5Used()) {

maksfb:

}

if (BC.isDWARF5Used()) {

AddrWriter = std::make_unique<DebugAddrWriterDwarf5>(&BC);

RangesSectionWriter = std::make_unique<DebugRangeListsSectionWriter>();

DebugRangeListsSectionWriter::setAddressWriter(AddrWriter.get());

} else {

AddrWriter = std::make_unique<DebugAddrWriter>(&BC);

RangesSectionWriter = std::make_unique<DebugRangesSectionWriter>();

}

DebugLoclistWriter::setAddressWriter(AddrWriter.get());

size_t CUIndex = 0;

for (std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {

const uint16_t DwarfVersion = CU->getVersion();

if (DwarfVersion >= 5) {

uint32_t AttrInfoOffset =

LocListWritersByCU[CUIndex] =

DebugLoclistWriter::InvalidLocListsBaseAttrOffset;

std::make_unique<DebugLoclistWriter>(*CU.get(), DwarfVersion, false);

if (Optional<AttrInfo> AttrInfoVal =

findAttributeInfo(CU->getUnitDIE(), dwarf::DW_AT_loclists_base)) {

AttrInfoOffset = AttrInfoVal->Offset;

LocListWritersByCU[CUIndex] = std::make_unique<DebugLoclistWriter>(

&BC, *CU.get(), AttrInfoOffset, DwarfVersion, false);

}

if (Optional<uint64_t> DWOId = CU->getDWOId()) {

assert(LocListWritersByCU.count(*DWOId) == 0 &&

"RangeLists writer for DWO unit already exists.");

auto RangeListsSectionWriter =

std::make_unique<DebugRangeListsSectionWriter>();

RangeListsSectionWriter->initSection(*CU.get());

RangeListsWritersByCU[*DWOId] = std::move(RangeListsSectionWriter);

}

} else {

LocListWritersByCU[CUIndex] = std::make_unique<DebugLocWriter>(&BC);

LocListWritersByCU[CUIndex] = std::make_unique<DebugLocWriter>();

}

if (Optional<uint64_t> DWOId = CU->getDWOId()) {

assert(LocListWritersByCU.count(*DWOId) == 0 &&

"LocList writer for DWO unit already exists.");

// Work around some bug in llvm-15. If I pass in directly lld reports

// undefined symbol.

auto constexpr WorkAround =

LocListWritersByCU[*DWOId] =

DebugLoclistWriter::InvalidLocListsBaseAttrOffset;

std::make_unique<DebugLoclistWriter>(*CU.get(), DwarfVersion, true);

LocListWritersByCU[*DWOId] = std::make_unique<DebugLoclistWriter>(

&BC, *CU.get(), WorkAround, DwarfVersion, true);

}

++CUIndex;

}

// Unordered maps to handle name collision if output DWO directory is

// specified.

std::unordered_map<std::string, uint32_t> NameToIndexMap;

std::unordered_map<uint64_t, std::string> DWOIdToName;

▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines

if (SplitCU) {

DwoDebugInfoPatcher->setRangeBase(*RangesBase);

}

DwoDebugInfoPatcher->addUnitBaseOffsetLabel((*SplitCU)->getOffset());

DebugAbbrevWriter *DWOAbbrevWriter =

createBinaryDWOAbbrevWriter((*SplitCU)->getContext(), *DWOId);

updateUnitDebugInfo(*(*SplitCU), *DwoDebugInfoPatcher, *DWOAbbrevWriter,

*DebugLocWriter, *TempRangesSectionWriter);

DebugLocWriter->finalize(*DwoDebugInfoPatcher, *DWOAbbrevWriter);

DwoDebugInfoPatcher->clearDestinationLabels();

if (!DwoDebugInfoPatcher->getWasRangBasedUsed())

RangesBase = None;

if (Unit->getVersion() >= 5)

TempRangesSectionWriter->finalizeSection();

}

{

std::lock_guard<std::mutex> Lock(AccessMutex);

auto LocListWriterIter = LocListWritersByCU.find(CUIndex);

if (LocListWriterIter != LocListWritersByCU.end())

DebugLocWriter = LocListWriterIter->second.get();

}

if (Unit->getVersion() >= 5) {

RangesBase = RangesSectionWriter->getSectionOffset() +

getDWARF5RngListLocListHeaderSize();

RangesSectionWriter.get()->initSection(*Unit);

StrOffstsWriter->finalizeSection();

}

DebugInfoPatcher->addUnitBaseOffsetLabel(Unit->getOffset());

updateUnitDebugInfo(*Unit, *DebugInfoPatcher, *AbbrevWriter,

*DebugLocWriter, *RangesSectionWriter, RangesBase);

DebugLocWriter->finalize(*DebugInfoPatcher, *AbbrevWriter);

if (Unit->getVersion() >= 5)

RangesSectionWriter.get()->finalizeSection();

};

CUIndex = 0;

if (opts::NoThreads || opts::DeterministicDebugInfo) {

for (std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {

processUnitDIE(CUIndex, CU.get());

▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines

default: {

DebugLocationsVector InputLL;

Optional<object::SectionedAddress> SectionAddress =

Unit.getBaseAddress();

uint64_t BaseAddress = 0;

if (SectionAddress)

BaseAddress = SectionAddress->Address;

if (Unit.getVersion() >= 5) {

if (Unit.getVersion() >= 5 &&

AttrVal->V.getForm() == dwarf::DW_FORM_loclistx) {

Optional<uint64_t> LocOffset = Unit.getLoclistOffset(Offset);

assert(LocOffset && "Location Offset is invalid.");

Offset = *LocOffset;

}

Error E = Unit.getLocationTable().visitLocationList(

&Offset, [&](const DWARFLocationEntry &Entry) {

switch (Entry.Kind) {

Show All 11 Lines

default: {

assert(

(Entry.SectionIndex == SectionedAddress::UndefSection &&

(!Unit.isDWOUnit() || Unit.getVersion() == 5)) &&

"absolute address expected");

InputLL.emplace_back(DebugLocationEntry{

BaseAddress + Entry.Value0, BaseAddress + Entry.Value1,

Entry.Loc});

break;

case dwarf::DW_RLE_start_length:

case dwarf::DW_LLE_start_length:

InputLL.emplace_back(DebugLocationEntry{

Entry.Value0, Entry.Value0 + Entry.Value1, Entry.Loc});

break;

case dwarf::DW_LLE_base_addressx: {

Optional<object::SectionedAddress> EntryAddress =

Unit.getAddrOffsetSectionItem(Entry.Value0);

assert(EntryAddress && "base Address not found.");

BaseAddress = EntryAddress->Address;

▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines

default: {

<< Twine::utohexstr(Unit.getOffset()) << '\n';

});

} else {

// It's possible for a subprogram to be removed and to have

// address of 0. Adding this entry to output to preserve debug

// information.

OutputLL = InputLL;

}

uint32_t LocListIndex = 0;

DebugLocWriter.addList(*AttrVal, OutputLL, DebugInfoPatcher,

dwarf::Form Form = Value.getForm();

AbbrevWriter);

if (Form == dwarf::DW_FORM_sec_offset ||

Form == dwarf::DW_FORM_data4) {

// For DWARF5 we can access location list entry either using

// index, or offset. If it's offset, then it's from begnning of

// the file. This implementation was before we could add entries

// to the DIE. For DWARF4 this is no-op.

// TODO: For DWARF5 convert all the offset based entries to index

// based, and insert loclist_base if necessary.

LocListIndex = DebugLoclistWriter::InvalidIndex;

} else if (Form == dwarf::DW_FORM_loclistx) {

LocListIndex = Value.getRawUValue();

} else {

llvm_unreachable("Unsupported LocList access Form.");

}

DebugLocWriter.addList(AttrOffset, LocListIndex,

std::move(OutputLL));

}

} else {

assert((Value.isFormClass(DWARFFormValue::FC_Exprloc) ||

Value.isFormClass(DWARFFormValue::FC_Block)) &&

"unexpected DW_AT_location form");

if (Unit.isDWOUnit() || Unit.getVersion() >= 5) {

ArrayRef<uint8_t> Expr = *Value.getAsBlock();

DataExtractor Data(

▲ Show 20 Lines • Show All 333 Lines • ▼ Show 20 Lines

BC.registerOrUpdateNoteSection(

llvm::isa<DebugRangeListsSectionWriter>(*RangesSectionWriter)

? ".debug_rnglists"

: ".debug_ranges",

copyByteArray(*RangesSectionContents), RangesSectionContents->size());

if (BC.isDWARF5Used()) {

std::unique_ptr<DebugBufferVector> LocationListSectionContents =

makeFinalLocListsSection(DebugInfoPatcher, DWARFVersion::DWARF5);

BC.registerOrUpdateNoteSection(".debug_loclists",

if (!LocationListSectionContents->empty())

copyByteArray(*LocationListSectionContents),

BC.registerOrUpdateNoteSection(

".debug_loclists", copyByteArray(*LocationListSectionContents),

LocationListSectionContents->size());

}

if (BC.isDWARFLegacyUsed()) {

std::unique_ptr<DebugBufferVector> LocationListSectionContents =

makeFinalLocListsSection(DebugInfoPatcher, DWARFVersion::DWARFLegacy);

BC.registerOrUpdateNoteSection(".debug_loc",

if (!LocationListSectionContents->empty())

copyByteArray(*LocationListSectionContents),

BC.registerOrUpdateNoteSection(

".debug_loc", copyByteArray(*LocationListSectionContents),

LocationListSectionContents->size());

}

// AddrWriter should be finalized after debug_loc since more addresses can be

// added there.

if (AddrWriter->isInitialized()) {

AddressSectionBuffer AddressSectionContents = AddrWriter->finalize();

BC.registerOrUpdateNoteSection(".debug_addr",

copyByteArray(AddressSectionContents),

▲ Show 20 Lines • Show All 586 Lines • ▼ Show 20 Lines

void DWARFRewriter::updateGdbIndexSection(CUOffsetMap &CUMap) {

// Copy over the rest of the original data.

memcpy(Buffer, Data, TrailingSize);

// Register the new section.

BC.registerOrUpdateNoteSection(".gdb_index", NewGdbIndexContents,

NewGdbIndexSize);

}

std::unique_ptr<DebugBufferVector>

std::unique_ptr<DebugBufferVector> DWARFRewriter::makeFinalLocListsSection(

DWARFRewriter::makeFinalLocListsSection(SimpleBinaryPatcher &DebugInfoPatcher,

DebugInfoBinaryPatcher &DebugInfoPatcher, DWARFVersion Version) {

DWARFVersion Version) {

auto LocBuffer = std::make_unique<DebugBufferVector>();

auto LocStream = std::make_unique<raw_svector_ostream>(*LocBuffer);

auto Writer =

std::unique_ptr<MCObjectWriter>(BC.createObjectWriter(*LocStream));

uint64_t SectionOffset = 0;

// Add an empty list as the first entry;

if (LocListWritersByCU.empty() ||

LocListWritersByCU.begin()->second.get()->getDwarfVersion() < 5) {

// Should be fine for both DWARF4 and DWARF5?

const char Zeroes[16] = {0};

*LocStream << StringRef(Zeroes, 16);

SectionOffset += 2 * 8;

}

for (std::pair<const uint64_t, std::unique_ptr<DebugLocWriter>> &Loc :

LocListWritersByCU) {

DebugLocWriter *LocWriter = Loc.second.get();

auto *LocListWriter = llvm::dyn_cast<DebugLoclistWriter>(LocWriter);

// Filter out DWARF4, writing out DWARF5

if (Version == DWARFVersion::DWARF5 &&

(!LocListWriter || LocListWriter->getDwarfVersion() <= 4))

continue;

// Filter out DWARF5, writing out DWARF4

if (Version == DWARFVersion::DWARFLegacy &&

(LocListWriter && LocListWriter->getDwarfVersion() >= 5))

continue;

// Skipping DWARF4/5 split dwarf.

if (LocListWriter && (LocListWriter->getDwarfVersion() <= 4 ||

(LocListWriter->getDwarfVersion() >= 5 &&

LocListWriter->isSplitDwarf()))) {

SimpleBinaryPatcher *Patcher =

getBinaryDWODebugInfoPatcher(LocListWriter->getCUID());

LocListWriter->finalize(0, *Patcher);

continue;

}

LocWriter->finalize(SectionOffset, DebugInfoPatcher);

std::unique_ptr<DebugBufferVector> CurrCULocationLists =

LocWriter->getBuffer();

*LocStream << *CurrCULocationLists;

SectionOffset += CurrCULocationLists->size();

}

return LocBuffer;

}

namespace {

void getRangeAttrData(DWARFDie DIE, Optional<AttrInfo> &LowPCVal,

▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

bolt/test/Inputs/dwarf5-loclist-offset-form-helper.s

This file was added.

				# int fooVar = 0;
				# void useFoo(int * x) {
				# *x += 4;
				# }
				# int foo(int argc) {
				# int x = argc;
				# useFoo(&x);
				# return x;
				# }

				.text
				.file "helper.cpp"
				.file 0 "." "helper.cpp" md5 0xf1508be63cfcbaf913e2dfef3cd5bccc
				.globl _Z6useFooPi # -- Begin function _Z6useFooPi
				.p2align 4, 0x90
				.type _Z6useFooPi,@function
				_Z6useFooPi: # @_Z6useFooPi
				.Lfunc_begin0:
				.loc 0 2 0 # helper.cpp:2:0
				.cfi_startproc
				# %bb.0: # %entry
				#DEBUG_VALUE: useFoo:x <- $rdi
				.loc 0 3 5 prologue_end # helper.cpp:3:5
				addl $4, (%rdi)
				.loc 0 4 2 # helper.cpp:4:2
				retq
				.Ltmp0:
				.Lfunc_end0:
				.size _Z6useFooPi, .Lfunc_end0-_Z6useFooPi
				.cfi_endproc
				# -- End function
				.globl _Z3fooi # -- Begin function _Z3fooi
				.p2align 4, 0x90
				.type _Z3fooi,@function
				_Z3fooi: # @_Z3fooi
				.Lfunc_begin1:
				.loc 0 6 0 # helper.cpp:6:0
				.cfi_startproc
				# %bb.0: # %entry
				#DEBUG_VALUE: foo:argc <- $edi
				#DEBUG_VALUE: foo:x <- $edi
				# kill: def $edi killed $edi def $rdi
				#DEBUG_VALUE: useFoo:x <- undef
				.loc 0 3 5 prologue_end # helper.cpp:3:5
				leal 4(%rdi), %eax
				.Ltmp1:
				#DEBUG_VALUE: foo:x <- $eax
				.loc 0 9 5 # helper.cpp:9:5
				retq
				.Ltmp2:
				.Lfunc_end1:
				.size _Z3fooi, .Lfunc_end1-_Z3fooi
				.cfi_endproc
				# -- End function
				.type fooVar,@object # @fooVar
				.bss
				.globl fooVar
				.p2align 2
				fooVar:
				.long 0 # 0x0
				.size fooVar, 4

				.section .debug_loclists,"",@progbits
				.long .Ldebug_list_header_end0-.Ldebug_list_header_start0 # Length
				.Ldebug_list_header_start0:
				.short 5 # Version
				.byte 8 # Address size
				.byte 0 # Segment selector size
				.long 1 # Offset entry count
				.Lloclists_table_base0:
				.long .Ldebug_loc0-.Lloclists_table_base0
				.Ldebug_loc0:
				.byte 4 # DW_LLE_offset_pair
				.uleb128 .Lfunc_begin1-.Lfunc_begin0 # starting offset
				.uleb128 .Ltmp1-.Lfunc_begin0 # ending offset
				.byte 1 # Loc expr size
				.byte 85 # super-register DW_OP_reg5
				.byte 4 # DW_LLE_offset_pair
				.uleb128 .Ltmp1-.Lfunc_begin0 # starting offset
				.uleb128 .Lfunc_end1-.Lfunc_begin0 # ending offset
				.byte 1 # Loc expr size
				.byte 80 # super-register DW_OP_reg0
				.byte 0 # DW_LLE_end_of_list
				.Ldebug_list_header_end0:
				.section .debug_abbrev,"",@progbits
				.byte 1 # Abbreviation Code
				.byte 17 # DW_TAG_compile_unit
				.byte 1 # DW_CHILDREN_yes
				.byte 37 # DW_AT_producer
				.byte 37 # DW_FORM_strx1
				.byte 19 # DW_AT_language
				.byte 5 # DW_FORM_data2
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 114 # DW_AT_str_offsets_base
				.byte 23 # DW_FORM_sec_offset
				.byte 16 # DW_AT_stmt_list
				.byte 23 # DW_FORM_sec_offset
				.byte 27 # DW_AT_comp_dir
				.byte 37 # DW_FORM_strx1
				.byte 17 # DW_AT_low_pc
				.byte 27 # DW_FORM_addrx
				.byte 18 # DW_AT_high_pc
				.byte 6 # DW_FORM_data4
				.byte 115 # DW_AT_addr_base
				.byte 23 # DW_FORM_sec_offset
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 2 # Abbreviation Code
				.byte 52 # DW_TAG_variable
				.byte 0 # DW_CHILDREN_no
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 63 # DW_AT_external
				.byte 25 # DW_FORM_flag_present
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 2 # DW_AT_location
				.byte 24 # DW_FORM_exprloc
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 3 # Abbreviation Code
				.byte 36 # DW_TAG_base_type
				.byte 0 # DW_CHILDREN_no
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 62 # DW_AT_encoding
				.byte 11 # DW_FORM_data1
				.byte 11 # DW_AT_byte_size
				.byte 11 # DW_FORM_data1
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 4 # Abbreviation Code
				.byte 46 # DW_TAG_subprogram
				.byte 1 # DW_CHILDREN_yes
				.byte 17 # DW_AT_low_pc
				.byte 27 # DW_FORM_addrx
				.byte 18 # DW_AT_high_pc
				.byte 6 # DW_FORM_data4
				.byte 64 # DW_AT_frame_base
				.byte 24 # DW_FORM_exprloc
				.byte 122 # DW_AT_call_all_calls
				.byte 25 # DW_FORM_flag_present
				.byte 49 # DW_AT_abstract_origin
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 5 # Abbreviation Code
				.byte 5 # DW_TAG_formal_parameter
				.byte 0 # DW_CHILDREN_no
				.byte 2 # DW_AT_location
				.byte 24 # DW_FORM_exprloc
				.byte 49 # DW_AT_abstract_origin
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 6 # Abbreviation Code
				.byte 46 # DW_TAG_subprogram
				.byte 1 # DW_CHILDREN_yes
				.byte 110 # DW_AT_linkage_name
				.byte 37 # DW_FORM_strx1
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 63 # DW_AT_external
				.byte 25 # DW_FORM_flag_present
				.byte 32 # DW_AT_inline
				.byte 33 # DW_FORM_implicit_const
				.byte 1
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 7 # Abbreviation Code
				.byte 5 # DW_TAG_formal_parameter
				.byte 0 # DW_CHILDREN_no
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 8 # Abbreviation Code
				.byte 15 # DW_TAG_pointer_type
				.byte 0 # DW_CHILDREN_no
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 9 # Abbreviation Code
				.byte 46 # DW_TAG_subprogram
				.byte 1 # DW_CHILDREN_yes
				.byte 17 # DW_AT_low_pc
				.byte 27 # DW_FORM_addrx
				.byte 18 # DW_AT_high_pc
				.byte 6 # DW_FORM_data4
				.byte 64 # DW_AT_frame_base
				.byte 24 # DW_FORM_exprloc
				.byte 122 # DW_AT_call_all_calls
				.byte 25 # DW_FORM_flag_present
				.byte 110 # DW_AT_linkage_name
				.byte 37 # DW_FORM_strx1
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 63 # DW_AT_external
				.byte 25 # DW_FORM_flag_present
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 10 # Abbreviation Code
				.byte 5 # DW_TAG_formal_parameter
				.byte 0 # DW_CHILDREN_no
				.byte 2 # DW_AT_location
				.byte 24 # DW_FORM_exprloc
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 11 # Abbreviation Code
				.byte 52 # DW_TAG_variable
				.byte 0 # DW_CHILDREN_no
				.byte 2 # DW_AT_location
				.byte 23 # DW_FORM_sec_offset
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 12 # Abbreviation Code
				.byte 29 # DW_TAG_inlined_subroutine
				.byte 0 # DW_CHILDREN_no
				.byte 49 # DW_AT_abstract_origin
				.byte 19 # DW_FORM_ref4
				.byte 17 # DW_AT_low_pc
				.byte 27 # DW_FORM_addrx
				.byte 18 # DW_AT_high_pc
				.byte 6 # DW_FORM_data4
				.byte 88 # DW_AT_call_file
				.byte 11 # DW_FORM_data1
				.byte 89 # DW_AT_call_line
				.byte 11 # DW_FORM_data1
				.byte 87 # DW_AT_call_column
				.byte 11 # DW_FORM_data1
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 0 # EOM(3)
				.section .debug_info,"",@progbits
				.Lcu_begin0:
				.long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
				.Ldebug_info_start0:
				.short 5 # DWARF version number
				.byte 1 # DWARF Unit Type
				.byte 8 # Address Size (in bytes)
				.long .debug_abbrev # Offset Into Abbrev. Section
				.byte 1 # Abbrev [1] 0xc:0x83 DW_TAG_compile_unit
				.byte 0 # DW_AT_producer
				.short 33 # DW_AT_language
				.byte 1 # DW_AT_name
				.long .Lstr_offsets_base0 # DW_AT_str_offsets_base
				.long .Lline_table_start0 # DW_AT_stmt_list
				.byte 2 # DW_AT_comp_dir
				.byte 1 # DW_AT_low_pc
				.long .Lfunc_end1-.Lfunc_begin0 # DW_AT_high_pc
				.long .Laddr_table_base0 # DW_AT_addr_base
				.byte 2 # Abbrev [2] 0x27:0xb DW_TAG_variable
				.byte 3 # DW_AT_name
				.long 50 # DW_AT_type
				# DW_AT_external
				.byte 0 # DW_AT_decl_file
				.byte 1 # DW_AT_decl_line
				.byte 2 # DW_AT_location
				.byte 161
				.byte 0
				.byte 3 # Abbrev [3] 0x32:0x4 DW_TAG_base_type
				.byte 4 # DW_AT_name
				.byte 5 # DW_AT_encoding
				.byte 4 # DW_AT_byte_size
				.byte 4 # Abbrev [4] 0x36:0x14 DW_TAG_subprogram
				.byte 1 # DW_AT_low_pc
				.long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
				.byte 1 # DW_AT_frame_base
				.byte 87
				# DW_AT_call_all_calls
				.long 74 # DW_AT_abstract_origin
				.byte 5 # Abbrev [5] 0x42:0x7 DW_TAG_formal_parameter
				.byte 1 # DW_AT_location
				.byte 85
				.long 79 # DW_AT_abstract_origin
				.byte 0 # End Of Children Mark
				.byte 6 # Abbrev [6] 0x4a:0xe DW_TAG_subprogram
				.byte 5 # DW_AT_linkage_name
				.byte 6 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 2 # DW_AT_decl_line
				# DW_AT_external
				# DW_AT_inline
				.byte 7 # Abbrev [7] 0x4f:0x8 DW_TAG_formal_parameter
				.byte 7 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 2 # DW_AT_decl_line
				.long 88 # DW_AT_type
				.byte 0 # End Of Children Mark
				.byte 8 # Abbrev [8] 0x58:0x5 DW_TAG_pointer_type
				.long 50 # DW_AT_type
				.byte 9 # Abbrev [9] 0x5d:0x31 DW_TAG_subprogram
				.byte 2 # DW_AT_low_pc
				.long .Lfunc_end1-.Lfunc_begin1 # DW_AT_high_pc
				.byte 1 # DW_AT_frame_base
				.byte 87
				# DW_AT_call_all_calls
				.byte 8 # DW_AT_linkage_name
				.byte 9 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 6 # DW_AT_decl_line
				.long 50 # DW_AT_type
				# DW_AT_external
				.byte 10 # Abbrev [10] 0x6d:0xa DW_TAG_formal_parameter
				.byte 1 # DW_AT_location
				.byte 85
				.byte 10 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 6 # DW_AT_decl_line
				.long 50 # DW_AT_type
				.byte 11 # Abbrev [11] 0x77:0x9 DW_TAG_variable
				.long .Ldebug_loc0 # DW_AT_location
				.byte 7 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 7 # DW_AT_decl_line
				.long 50 # DW_AT_type
				.byte 12 # Abbrev [12] 0x80:0xd DW_TAG_inlined_subroutine
				.long 74 # DW_AT_abstract_origin
				.byte 2 # DW_AT_low_pc
				.long .Ltmp1-.Lfunc_begin1 # DW_AT_high_pc
				.byte 0 # DW_AT_call_file
				.byte 8 # DW_AT_call_line
				.byte 5 # DW_AT_call_column
				.byte 0 # End Of Children Mark
				.byte 0 # End Of Children Mark
				.Ldebug_info_end0:
				.section .debug_str_offsets,"",@progbits
				.long 48 # Length of String Offsets Set
				.short 5
				.short 0
				.Lstr_offsets_base0:
				.section .debug_str,"MS",@progbits,1
				.Linfo_string0:
				.asciz "clang version 15.0.0" # string offset=0
				.Linfo_string1:
				.asciz "helper.cpp" # string offset=134
				.Linfo_string2:
				.asciz "." # string offset=145
				.Linfo_string3:
				.asciz "fooVar" # string offset=183
				.Linfo_string4:
				.asciz "int" # string offset=190
				.Linfo_string5:
				.asciz "_Z6useFooPi" # string offset=194
				.Linfo_string6:
				.asciz "useFoo" # string offset=206
				.Linfo_string7:
				.asciz "x" # string offset=213
				.Linfo_string8:
				.asciz "_Z3fooi" # string offset=215
				.Linfo_string9:
				.asciz "foo" # string offset=223
				.Linfo_string10:
				.asciz "argc" # string offset=227
				.section .debug_str_offsets,"",@progbits
				.long .Linfo_string0
				.long .Linfo_string1
				.long .Linfo_string2
				.long .Linfo_string3
				.long .Linfo_string4
				.long .Linfo_string5
				.long .Linfo_string6
				.long .Linfo_string7
				.long .Linfo_string8
				.long .Linfo_string9
				.long .Linfo_string10
				.section .debug_addr,"",@progbits
				.long .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution
				.Ldebug_addr_start0:
				.short 5 # DWARF version number
				.byte 8 # Address size
				.byte 0 # Segment selector size
				.Laddr_table_base0:
				.quad fooVar
				.quad .Lfunc_begin0
				.quad .Lfunc_begin1
				.Ldebug_addr_end0:
				.ident "clang version 15.0.0"
				.section ".note.GNU-stack","",@progbits
				.addrsig
				.section .debug_line,"",@progbits
				.Lline_table_start0:

bolt/test/Inputs/dwarf5-loclist-offset-form-main.s

This file was added.

				# void use(int * x, int * y) {
				# *x += 4;
				# *y -= 2;
				# }
				#
				# extern int fooVar;
				# int main(int argc, char *argv[]) {
				# int x = argc;
				# int y = fooVar + 3;
				# use(&x, &y);
				# return x + y;
				# }

				.text
				.file "main.cpp"
				.globl _Z3usePiS_ # -- Begin function _Z3usePiS_
				.p2align 4, 0x90
				.type _Z3usePiS_,@function
				_Z3usePiS_: # @_Z3usePiS_
				.Lfunc_begin0:
				.file 0 "." "main.cpp" md5 0x0df8b93231613cae17dbf82c0897c3b3
				.loc 0 1 0 # main.cpp:1:0
				.cfi_startproc
				# %bb.0: # %entry
				#DEBUG_VALUE: use:x <- $rdi
				#DEBUG_VALUE: use:y <- $rsi
				.loc 0 2 6 prologue_end # main.cpp:2:6
				addl $4, (%rdi)
				.loc 0 3 6 # main.cpp:3:6
				addl $-2, (%rsi)
				.loc 0 4 1 # main.cpp:4:1
				retq
				.Ltmp0:
				.Lfunc_end0:
				.size _Z3usePiS_, .Lfunc_end0-_Z3usePiS_
				.cfi_endproc
				# -- End function
				.globl main # -- Begin function main
				.p2align 4, 0x90
				.type main,@function
				main: # @main
				.Lfunc_begin1:
				.loc 0 7 0 # main.cpp:7:0
				.cfi_startproc
				# %bb.0: # %entry
				#DEBUG_VALUE: main:argc <- $edi
				#DEBUG_VALUE: main:argv <- $rsi
				#DEBUG_VALUE: main:x <- $edi
				# kill: def $edi killed $edi def $rdi
				.loc 0 9 13 prologue_end # main.cpp:9:13
				movq fooVar@GOTPCREL(%rip), %rax
				movl (%rax), %eax
				.Ltmp1:
				#DEBUG_VALUE: main:y <- [DW_OP_plus_uconst 3, DW_OP_stack_value] $eax
				#DEBUG_VALUE: main:y <- [DW_OP_plus_uconst 1, DW_OP_stack_value] $eax
				#DEBUG_VALUE: main:x <- [DW_OP_plus_uconst 4, DW_OP_stack_value] $edi
				.loc 0 11 14 # main.cpp:11:14
				addl %edi, %eax
				.Ltmp2:
				addl $5, %eax
				.loc 0 11 5 is_stmt 0 # main.cpp:11:5
				retq
				.Ltmp3:
				.Lfunc_end1:
				.size main, .Lfunc_end1-main
				.cfi_endproc
				# -- End function
				.section .debug_loclists,"",@progbits
				.long .Ldebug_list_header_end0-.Ldebug_list_header_start0 # Length
				.Ldebug_list_header_start0:
				.short 5 # Version
				.byte 8 # Address size
				.byte 0 # Segment selector size
				.long 2 # Offset entry count
				.Lloclists_table_base0:
				.long .Ldebug_loc0-.Lloclists_table_base0
				.long .Ldebug_loc1-.Lloclists_table_base0
				.Ldebug_loc0:
				.byte 4 # DW_LLE_offset_pair
				.uleb128 .Lfunc_begin1-.Lfunc_begin0 # starting offset
				.uleb128 .Ltmp1-.Lfunc_begin0 # ending offset
				.byte 1 # Loc expr size
				.byte 85 # super-register DW_OP_reg5
				.byte 4 # DW_LLE_offset_pair
				.uleb128 .Ltmp1-.Lfunc_begin0 # starting offset
				.uleb128 .Lfunc_end1-.Lfunc_begin0 # ending offset
				.byte 10 # Loc expr size
				.byte 117 # DW_OP_breg5
				.byte 4 # 4
				.byte 16 # DW_OP_constu
				.byte 255 # 4294967295
				.byte 255 #
				.byte 255 #
				.byte 255 #
				.byte 15 #
				.byte 26 # DW_OP_and
				.byte 159 # DW_OP_stack_value
				.byte 0 # DW_LLE_end_of_list
				.Ldebug_loc1:
				.byte 4 # DW_LLE_offset_pair
				.uleb128 .Ltmp1-.Lfunc_begin0 # starting offset
				.uleb128 .Ltmp2-.Lfunc_begin0 # ending offset
				.byte 10 # Loc expr size
				.byte 112 # DW_OP_breg0
				.byte 1 # 1
				.byte 16 # DW_OP_constu
				.byte 255 # 4294967295
				.byte 255 #
				.byte 255 #
				.byte 255 #
				.byte 15 #
				.byte 26 # DW_OP_and
				.byte 159 # DW_OP_stack_value
				.byte 0 # DW_LLE_end_of_list
				.Ldebug_list_header_end0:
				.section .debug_abbrev,"",@progbits
				.byte 1 # Abbreviation Code
				.byte 17 # DW_TAG_compile_unit
				.byte 1 # DW_CHILDREN_yes
				.byte 37 # DW_AT_producer
				.byte 37 # DW_FORM_strx1
				.byte 19 # DW_AT_language
				.byte 5 # DW_FORM_data2
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 114 # DW_AT_str_offsets_base
				.byte 23 # DW_FORM_sec_offset
				.byte 16 # DW_AT_stmt_list
				.byte 23 # DW_FORM_sec_offset
				.byte 27 # DW_AT_comp_dir
				.byte 37 # DW_FORM_strx1
				.byte 17 # DW_AT_low_pc
				.byte 27 # DW_FORM_addrx
				.byte 18 # DW_AT_high_pc
				.byte 6 # DW_FORM_data4
				.byte 115 # DW_AT_addr_base
				.byte 23 # DW_FORM_sec_offset
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 2 # Abbreviation Code
				.byte 46 # DW_TAG_subprogram
				.byte 1 # DW_CHILDREN_yes
				.byte 17 # DW_AT_low_pc
				.byte 27 # DW_FORM_addrx
				.byte 18 # DW_AT_high_pc
				.byte 6 # DW_FORM_data4
				.byte 64 # DW_AT_frame_base
				.byte 24 # DW_FORM_exprloc
				.byte 122 # DW_AT_call_all_calls
				.byte 25 # DW_FORM_flag_present
				.byte 110 # DW_AT_linkage_name
				.byte 37 # DW_FORM_strx1
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 63 # DW_AT_external
				.byte 25 # DW_FORM_flag_present
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 3 # Abbreviation Code
				.byte 5 # DW_TAG_formal_parameter
				.byte 0 # DW_CHILDREN_no
				.byte 2 # DW_AT_location
				.byte 24 # DW_FORM_exprloc
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 4 # Abbreviation Code
				.byte 46 # DW_TAG_subprogram
				.byte 1 # DW_CHILDREN_yes
				.byte 17 # DW_AT_low_pc
				.byte 27 # DW_FORM_addrx
				.byte 18 # DW_AT_high_pc
				.byte 6 # DW_FORM_data4
				.byte 64 # DW_AT_frame_base
				.byte 24 # DW_FORM_exprloc
				.byte 122 # DW_AT_call_all_calls
				.byte 25 # DW_FORM_flag_present
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 63 # DW_AT_external
				.byte 25 # DW_FORM_flag_present
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 5 # Abbreviation Code
				.byte 52 # DW_TAG_variable
				.byte 0 # DW_CHILDREN_no
				.byte 2 # DW_AT_location
				.byte 23 # DW_FORM_sec_offset
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 58 # DW_AT_decl_file
				.byte 11 # DW_FORM_data1
				.byte 59 # DW_AT_decl_line
				.byte 11 # DW_FORM_data1
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 6 # Abbreviation Code
				.byte 36 # DW_TAG_base_type
				.byte 0 # DW_CHILDREN_no
				.byte 3 # DW_AT_name
				.byte 37 # DW_FORM_strx1
				.byte 62 # DW_AT_encoding
				.byte 11 # DW_FORM_data1
				.byte 11 # DW_AT_byte_size
				.byte 11 # DW_FORM_data1
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 7 # Abbreviation Code
				.byte 15 # DW_TAG_pointer_type
				.byte 0 # DW_CHILDREN_no
				.byte 73 # DW_AT_type
				.byte 19 # DW_FORM_ref4
				.byte 0 # EOM(1)
				.byte 0 # EOM(2)
				.byte 0 # EOM(3)
				.section .debug_info,"",@progbits
				.Lcu_begin0:
				.long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
				.Ldebug_info_start0:
				.short 5 # DWARF version number
				.byte 1 # DWARF Unit Type
				.byte 8 # Address Size (in bytes)
				.long .debug_abbrev # Offset Into Abbrev. Section
				.byte 1 # Abbrev [1] 0xc:0x8a DW_TAG_compile_unit
				.byte 0 # DW_AT_producer
				.short 33 # DW_AT_language
				.byte 1 # DW_AT_name
				.long .Lstr_offsets_base0 # DW_AT_str_offsets_base
				.long .Lline_table_start0 # DW_AT_stmt_list
				.byte 2 # DW_AT_comp_dir
				.byte 0 # DW_AT_low_pc
				.long .Lfunc_end1-.Lfunc_begin0 # DW_AT_high_pc
				.long .Laddr_table_base0 # DW_AT_addr_base
				.byte 2 # Abbrev [2] 0x27:0x21 DW_TAG_subprogram
				.byte 0 # DW_AT_low_pc
				.long .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
				.byte 1 # DW_AT_frame_base
				.byte 87
				# DW_AT_call_all_calls
				.byte 3 # DW_AT_linkage_name
				.byte 4 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 1 # DW_AT_decl_line
				# DW_AT_external
				.byte 3 # Abbrev [3] 0x33:0xa DW_TAG_formal_parameter
				.byte 1 # DW_AT_location
				.byte 85
				.byte 7 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 1 # DW_AT_decl_line
				.long 130 # DW_AT_type
				.byte 3 # Abbrev [3] 0x3d:0xa DW_TAG_formal_parameter
				.byte 1 # DW_AT_location
				.byte 84
				.byte 8 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 1 # DW_AT_decl_line
				.long 130 # DW_AT_type
				.byte 0 # End Of Children Mark
				.byte 4 # Abbrev [4] 0x48:0x36 DW_TAG_subprogram
				.byte 1 # DW_AT_low_pc
				.long .Lfunc_end1-.Lfunc_begin1 # DW_AT_high_pc
				.byte 1 # DW_AT_frame_base
				.byte 87
				# DW_AT_call_all_calls
				.byte 5 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 7 # DW_AT_decl_line
				.long 126 # DW_AT_type
				# DW_AT_external
				.byte 3 # Abbrev [3] 0x57:0xa DW_TAG_formal_parameter
				.byte 1 # DW_AT_location
				.byte 85
				.byte 9 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 7 # DW_AT_decl_line
				.long 126 # DW_AT_type
				.byte 3 # Abbrev [3] 0x61:0xa DW_TAG_formal_parameter
				.byte 1 # DW_AT_location
				.byte 84
				.byte 10 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 7 # DW_AT_decl_line
				.long 135 # DW_AT_type
				.byte 5 # Abbrev [5] 0x6b:0x9 DW_TAG_variable
				.long .Ldebug_loc0 # DW_AT_location
				.byte 7 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 8 # DW_AT_decl_line
				.long 126 # DW_AT_type
				.byte 5 # Abbrev [5] 0x74:0x9 DW_TAG_variable
				.long .Ldebug_loc1 # DW_AT_location
				.byte 8 # DW_AT_name
				.byte 0 # DW_AT_decl_file
				.byte 9 # DW_AT_decl_line
				.long 126 # DW_AT_type
				.byte 0 # End Of Children Mark
				.byte 6 # Abbrev [6] 0x7e:0x4 DW_TAG_base_type
				.byte 6 # DW_AT_name
				.byte 5 # DW_AT_encoding
				.byte 4 # DW_AT_byte_size
				.byte 7 # Abbrev [7] 0x82:0x5 DW_TAG_pointer_type
				.long 126 # DW_AT_type
				.byte 7 # Abbrev [7] 0x87:0x5 DW_TAG_pointer_type
				.long 140 # DW_AT_type
				.byte 7 # Abbrev [7] 0x8c:0x5 DW_TAG_pointer_type
				.long 145 # DW_AT_type
				.byte 6 # Abbrev [6] 0x91:0x4 DW_TAG_base_type
				.byte 11 # DW_AT_name
				.byte 6 # DW_AT_encoding
				.byte 1 # DW_AT_byte_size
				.byte 0 # End Of Children Mark
				.Ldebug_info_end0:
				.section .debug_str_offsets,"",@progbits
				.long 52 # Length of String Offsets Set
				.short 5
				.short 0
				.Lstr_offsets_base0:
				.section .debug_str,"MS",@progbits,1
				.Linfo_string0:
				.asciz "clang version 15.0.0" # string offset=0
				.Linfo_string1:
				.asciz "main.cpp" # string offset=134
				.Linfo_string2:
				.asciz "." # string offset=143
				.Linfo_string3:
				.asciz "_Z3usePiS_" # string offset=181
				.Linfo_string4:
				.asciz "use" # string offset=192
				.Linfo_string5:
				.asciz "main" # string offset=196
				.Linfo_string6:
				.asciz "int" # string offset=201
				.Linfo_string7:
				.asciz "x" # string offset=205
				.Linfo_string8:
				.asciz "y" # string offset=207
				.Linfo_string9:
				.asciz "argc" # string offset=209
				.Linfo_string10:
				.asciz "argv" # string offset=214
				.Linfo_string11:
				.asciz "char" # string offset=219
				.section .debug_str_offsets,"",@progbits
				.long .Linfo_string0
				.long .Linfo_string1
				.long .Linfo_string2
				.long .Linfo_string3
				.long .Linfo_string4
				.long .Linfo_string5
				.long .Linfo_string6
				.long .Linfo_string7
				.long .Linfo_string8
				.long .Linfo_string9
				.long .Linfo_string10
				.long .Linfo_string11
				.section .debug_addr,"",@progbits
				.long .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution
				.Ldebug_addr_start0:
				.short 5 # DWARF version number
				.byte 8 # Address size
				.byte 0 # Segment selector size
				.Laddr_table_base0:
				.quad .Lfunc_begin0
				.quad .Lfunc_begin1
				.Ldebug_addr_end0:
				.ident "clang version 15.0.0"
				.section ".note.GNU-stack","",@progbits
				.addrsig
				.section .debug_line,"",@progbits
				.Lline_table_start0:

bolt/test/X86/dwarf4-df-dualcu-loclist.test

	Show All 20 Lines
	; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000005, 0x0000000000000005)			; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000005, 0x0000000000000005)
	; PRE-BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]			; PRE-BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]
	; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000016:			; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000016:
	; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x000000000000000c)			; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x000000000000000c)
	; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000006, 0x000000000000000d)			; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000006, 0x000000000000000d)

	; BOLT-DWO-MAIN: version = 0x0004			; BOLT-DWO-MAIN: version = 0x0004
	; BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]			; BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]
	; BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000000:			; BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000010:
	; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x0000000000000014)			; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x0000000000000014)
	; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x0000000000000005)			; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x0000000000000005)
	; BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]			; BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]
	; BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000016:			; BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000026:
	; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x000000000000000c)			; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x000000000000000c)
	; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000005, 0x000000000000000d)			; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length (0x0000000000000004, 0x000000000000000d)


	; PRE-BOLT-DWO-HELPER: version = 0x0004			; PRE-BOLT-DWO-HELPER: version = 0x0004
	; PRE-BOLT-DWO-HELPER: DW_TAG_formal_parameter [5]			; PRE-BOLT-DWO-HELPER: DW_TAG_formal_parameter [5]
	; PRE-BOLT-DWO-HELPER-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000000:			; PRE-BOLT-DWO-HELPER-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000000:
	; PRE-BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x0000000000000008)			; PRE-BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x0000000000000008)
	; PRE-BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x0000000000000016)			; PRE-BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x0000000000000016)

	; BOLT-DWO-HELPER: version = 0x0004			; BOLT-DWO-HELPER: version = 0x0004
	; BOLT-DWO-HELPER: DW_TAG_formal_parameter [5]			; BOLT-DWO-HELPER: DW_TAG_formal_parameter [5]
	; BOLT-DWO-HELPER-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000000:			; BOLT-DWO-HELPER-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000010:
	; BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x0000000000000008): DW_OP_reg5 RDI			; BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000002, 0x0000000000000008): DW_OP_reg5 RDI
	; BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x0000000000000016)			; BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length (0x0000000000000003, 0x0000000000000016)

bolt/test/dwarf5-loclist-offset-form.test

This file was added.

				# REQUIRES: system-linux

				# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-loclist-offset-form-main.s -o %tmain.o
				# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-loclist-offset-form-helper.s -o %thelper.o
				# RUN: %clang %cflags -dwarf-5 %tmain.o %thelper.o -o %t.exe -Wl,-q
				# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections
				# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe \| FileCheck --check-prefix=PRECHECK %s
				# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
				# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
				# RUN: cat %t.txt \| FileCheck --check-prefix=POSTCHECK %s

				# Checks we can handle DWARF5 CU with DWARF4 DW_AT_location access pattern.

				# PRECHECK: DW_TAG_compile_unit
				# PRECHECK: DW_TAG_variable [5]
				# PRECHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]
				# PRECHECK: DW_TAG_variable [5]
				# PRECHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]
				# PRECHECK: DW_TAG_compile_unit
				# PRECHECK: DW_TAG_variable [11]
				# PRECHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]

				# POSTCHECK: Addrs: [
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR1:]]
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR3:]]
				# For second CU.
				# POSTCHECK: Addrs: [
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR4:]]
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR5:]]
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR6:]]
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR7:]]
				# POSTCHECK-NEXT: 0x[[#%.16x,ADDR8:]]

				# POSTCHECK: DW_TAG_compile_unit
				# POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset] (0x0000000c)
				# POSTCHECK: DW_TAG_variable [5]
				# POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
				# POSTCHECK-NEXT: [0x[[#ADDR1]]
				# POSTCHECK-SAME: 0x[[#ADDR1 + 9]]
				# POSTCHECK-NEXT: [0x[[#ADDR3]]
				# POSTCHECK-SAME: 0x[[#ADDR3 + 6]]
				# POSTCHECK: DW_TAG_variable [5]
				# POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1)
				# POSTCHECK-NEXT: [0x[[#ADDR3]]
				# POSTCHECK-SAME: 0x[[#ADDR3 + 2]]

				# POSTCHECK: DW_TAG_compile_unit
				# POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset] (0x00000043)
				# POSTCHECK: DW_TAG_variable [11]
				# POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
				# POSTCHECK-NEXT: [0x[[#ADDR5]]
				# POSTCHECK-SAME: 0x[[#ADDR5 + 3]]
				# POSTCHECK-NEXT: [0x[[#ADDR8]]
				# POSTCHECK-SAME: 0x[[#ADDR8 + 1]]

This is an archive of the discontinued LLVM Phabricator instance.

[BOLT]DWARF] Eagerly write out loclists
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 434548

bolt/include/bolt/Core/DebugData.h

bolt/include/bolt/Rewrite/DWARFRewriter.h

bolt/lib/Core/DebugData.cpp

bolt/lib/Rewrite/DWARFRewriter.cpp

bolt/test/Inputs/dwarf5-loclist-offset-form-helper.s

bolt/test/Inputs/dwarf5-loclist-offset-form-main.s

bolt/test/X86/dwarf4-df-dualcu-loclist.test

bolt/test/dwarf5-loclist-offset-form.test

This is an archive of the discontinued LLVM Phabricator instance.

[BOLT]DWARF] Eagerly write out loclistsClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 434548

bolt/include/bolt/Core/DebugData.h

bolt/include/bolt/Rewrite/DWARFRewriter.h

bolt/lib/Core/DebugData.cpp

bolt/lib/Rewrite/DWARFRewriter.cpp

bolt/test/Inputs/dwarf5-loclist-offset-form-helper.s

bolt/test/Inputs/dwarf5-loclist-offset-form-main.s

bolt/test/X86/dwarf4-df-dualcu-loclist.test

bolt/test/dwarf5-loclist-offset-form.test

[BOLT]DWARF] Eagerly write out loclists
ClosedPublic