summaryrefslogtreecommitdiffstats
path: root/llvm/unittests/DebugInfo/DWARF
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/unittests/DebugInfo/DWARF')
-rw-r--r--llvm/unittests/DebugInfo/DWARF/CMakeLists.txt1
-rw-r--r--llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp2
-rw-r--r--llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp262
-rw-r--r--llvm/unittests/DebugInfo/DWARF/DwarfGenerator.h231
4 files changed, 495 insertions, 1 deletions
diff --git a/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt b/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt
index b01a907fc1e..cfebba02e7a 100644
--- a/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt
+++ b/llvm/unittests/DebugInfo/DWARF/CMakeLists.txt
@@ -10,6 +10,7 @@ set(LLVM_LINK_COMPONENTS
)
set(DebugInfoSources
+ DwarfGenerator.cpp
DWARFDebugInfoTest.cpp
DWARFFormValueTest.cpp
)
diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
index 47709ff89ef..f2a1a1459ee 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
@@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
-#include "../lib/CodeGen/DwarfGenerator.h"
+#include "DwarfGenerator.h"
#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
diff --git a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
new file mode 100644
index 00000000000..06fa121e7a2
--- /dev/null
+++ b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
@@ -0,0 +1,262 @@
+//===--- unittests/DebugInfo/DWARF/DwarfGenerator.cpp -----------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../lib/CodeGen/AsmPrinter/DwarfStringPool.h"
+#include "DwarfGenerator.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/IR/LegacyPassManagers.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCTargetOptionsCommandFlags.h"
+#include "llvm/PassAnalysisSupport.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/LEB128.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+
+using namespace llvm;
+using namespace dwarf;
+
+namespace {} // end anonymous namespace
+
+//===----------------------------------------------------------------------===//
+/// dwarfgen::DIE implementation.
+//===----------------------------------------------------------------------===//
+unsigned dwarfgen::DIE::computeSizeAndOffsets(unsigned Offset) {
+ auto &DG = CU->getGenerator();
+ return Die->computeOffsetsAndAbbrevs(DG.getAsmPrinter(), DG.getAbbrevSet(),
+ Offset);
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, uint64_t U) {
+ auto &DG = CU->getGenerator();
+ Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+ DIEInteger(U));
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form,
+ StringRef String) {
+ auto &DG = CU->getGenerator();
+ if (Form == DW_FORM_string) {
+ Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+ new (DG.getAllocator()) DIEInlineString(String));
+ } else {
+ Die->addValue(
+ DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+ DIEString(DG.getStringPool().getEntry(*DG.getAsmPrinter(), String)));
+ }
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form,
+ dwarfgen::DIE &RefDie) {
+ auto &DG = CU->getGenerator();
+ Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+ DIEEntry(*RefDie.Die));
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, const void *P,
+ size_t S) {
+ auto &DG = CU->getGenerator();
+ DIEBlock *Block = new (DG.getAllocator()) DIEBlock;
+ for (size_t I = 0; I < S; ++I)
+ Block->addValue(DG.getAllocator(), (dwarf::Attribute)0,
+ dwarf::DW_FORM_data1, DIEInteger(((uint8_t *)P)[I]));
+
+ Block->ComputeSize(DG.getAsmPrinter());
+ Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+ Block);
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form) {
+ auto &DG = CU->getGenerator();
+ assert(Form == DW_FORM_flag_present);
+ Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+ DIEInteger(1));
+}
+
+dwarfgen::DIE dwarfgen::DIE::addChild(dwarf::Tag Tag) {
+ auto &DG = CU->getGenerator();
+ return dwarfgen::DIE(CU,
+ &Die->addChild(llvm::DIE::get(DG.getAllocator(), Tag)));
+}
+
+dwarfgen::DIE dwarfgen::CompileUnit::getUnitDIE() {
+ return dwarfgen::DIE(this, &DU.getUnitDie());
+}
+
+//===----------------------------------------------------------------------===//
+/// dwarfgen::Generator implementation.
+//===----------------------------------------------------------------------===//
+
+dwarfgen::Generator::Generator() : Abbreviations(Allocator) {}
+dwarfgen::Generator::~Generator() = default;
+
+llvm::Expected<std::unique_ptr<dwarfgen::Generator>>
+dwarfgen::Generator::create(Triple TheTriple, uint16_t DwarfVersion) {
+ std::unique_ptr<dwarfgen::Generator> GenUP(new dwarfgen::Generator());
+ llvm::Error error = GenUP->init(TheTriple, DwarfVersion);
+ if (error)
+ return Expected<std::unique_ptr<dwarfgen::Generator>>(std::move(error));
+ return Expected<std::unique_ptr<dwarfgen::Generator>>(std::move(GenUP));
+}
+
+llvm::Error dwarfgen::Generator::init(Triple TheTriple, uint16_t V) {
+ Version = V;
+ std::string ErrorStr;
+ std::string TripleName;
+
+ // Get the target.
+ const Target *TheTarget =
+ TargetRegistry::lookupTarget(TripleName, TheTriple, ErrorStr);
+ if (!TheTarget)
+ return make_error<StringError>(ErrorStr, inconvertibleErrorCode());
+
+ TripleName = TheTriple.getTriple();
+
+ // Create all the MC Objects.
+ MRI.reset(TheTarget->createMCRegInfo(TripleName));
+ if (!MRI)
+ return make_error<StringError>(Twine("no register info for target ") +
+ TripleName,
+ inconvertibleErrorCode());
+
+ MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName));
+ if (!MAI)
+ return make_error<StringError>("no asm info for target " + TripleName,
+ inconvertibleErrorCode());
+
+ MOFI.reset(new MCObjectFileInfo);
+ MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
+ MOFI->InitMCObjectFileInfo(TheTriple, /*PIC*/ false, CodeModel::Default, *MC);
+
+ MCTargetOptions Options;
+ MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, "", Options);
+ if (!MAB)
+ return make_error<StringError>("no asm backend for target " + TripleName,
+ inconvertibleErrorCode());
+
+ MII.reset(TheTarget->createMCInstrInfo());
+ if (!MII)
+ return make_error<StringError>("no instr info info for target " +
+ TripleName,
+ inconvertibleErrorCode());
+
+ MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ if (!MSTI)
+ return make_error<StringError>("no subtarget info for target " + TripleName,
+ inconvertibleErrorCode());
+
+ MCE = TheTarget->createMCCodeEmitter(*MII, *MRI, *MC);
+ if (!MCE)
+ return make_error<StringError>("no code emitter for target " + TripleName,
+ inconvertibleErrorCode());
+
+ Stream = make_unique<raw_svector_ostream>(FileBytes);
+
+ MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
+ MS = TheTarget->createMCObjectStreamer(
+ TheTriple, *MC, *MAB, *Stream, MCE, *MSTI, MCOptions.MCRelaxAll,
+ MCOptions.MCIncrementalLinkerCompatible,
+ /*DWARFMustBeAtTheEnd*/ false);
+ if (!MS)
+ return make_error<StringError>("no object streamer for target " +
+ TripleName,
+ inconvertibleErrorCode());
+
+ // Finally create the AsmPrinter we'll use to emit the DIEs.
+ TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
+ None));
+ if (!TM)
+ return make_error<StringError>("no target machine for target " + TripleName,
+ inconvertibleErrorCode());
+
+ Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
+ if (!Asm)
+ return make_error<StringError>("no asm printer for target " + TripleName,
+ inconvertibleErrorCode());
+
+ // Set the DWARF version correctly on all classes that we use.
+ MC->setDwarfVersion(Version);
+ Asm->setDwarfVersion(Version);
+
+ StringPool.reset(new DwarfStringPool(Allocator, *Asm, StringRef()));
+
+ return Error::success();
+}
+
+StringRef dwarfgen::Generator::generate() {
+ // Offset from the first CU in the debug info section is 0 initially.
+ unsigned SecOffset = 0;
+
+ // Iterate over each compile unit and set the size and offsets for each
+ // DIE within each compile unit. All offsets are CU relative.
+ for (auto &CU : CompileUnits) {
+ // Set the absolute .debug_info offset for this compile unit.
+ CU->setOffset(SecOffset);
+ // The DIEs contain compile unit relative offsets.
+ unsigned CUOffset = 11;
+ CUOffset = CU->getUnitDIE().computeSizeAndOffsets(CUOffset);
+ // Update our absolute .debug_info offset.
+ SecOffset += CUOffset;
+ CU->setLength(CUOffset - 4);
+ }
+ Abbreviations.Emit(Asm.get(), MOFI->getDwarfAbbrevSection());
+ StringPool->emit(*Asm, MOFI->getDwarfStrSection());
+ MS->SwitchSection(MOFI->getDwarfInfoSection());
+ for (auto &CU : CompileUnits) {
+ uint16_t Version = CU->getVersion();
+ auto Length = CU->getLength();
+ MC->setDwarfVersion(Version);
+ assert(Length != -1U);
+ Asm->EmitInt32(Length);
+ Asm->EmitInt16(Version);
+ Asm->EmitInt32(0);
+ Asm->EmitInt8(CU->getAddressSize());
+ Asm->emitDwarfDIE(*CU->getUnitDIE().Die);
+ }
+
+ MS->Finish();
+ if (FileBytes.empty())
+ return StringRef();
+ return StringRef(FileBytes.data(), FileBytes.size());
+}
+
+bool dwarfgen::Generator::saveFile(StringRef Path) {
+ if (FileBytes.empty())
+ return false;
+ std::error_code EC;
+ raw_fd_ostream Strm(Path, EC, sys::fs::F_None);
+ if (EC)
+ return false;
+ Strm.write(FileBytes.data(), FileBytes.size());
+ Strm.close();
+ return true;
+}
+
+dwarfgen::CompileUnit &dwarfgen::Generator::addCompileUnit() {
+ CompileUnits.push_back(std::unique_ptr<CompileUnit>(
+ new CompileUnit(*this, Version, Asm->getPointerSize())));
+ return *CompileUnits.back();
+}
diff --git a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.h b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.h
new file mode 100644
index 00000000000..245630e138d
--- /dev/null
+++ b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.h
@@ -0,0 +1,231 @@
+//===--- unittests/DebugInfo/DWARF/DwarfGenerator.h -------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// A file that can generate DWARF debug info for unit tests.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_UNITTESTS_DEBUG_INFO_DWARF_DWARFGENERATOR_H
+#define LLVM_UNITTESTS_DEBUG_INFO_DWARF_DWARFGENERATOR_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
+#include "llvm/Support/Error.h"
+
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace llvm {
+
+class AsmPrinter;
+class DIE;
+class DIEAbbrev;
+class DwarfStringPool;
+class MCAsmBackend;
+class MCAsmInfo;
+class MCCodeEmitter;
+class MCContext;
+struct MCDwarfLineTableParams;
+class MCInstrInfo;
+class MCObjectFileInfo;
+class MCRegisterInfo;
+class MCStreamer;
+class MCSubtargetInfo;
+class raw_fd_ostream;
+class TargetMachine;
+class Triple;
+
+namespace dwarfgen {
+
+class Generator;
+class CompileUnit;
+
+/// A DWARF debug information entry class used to generate DWARF DIEs.
+///
+/// This class is used to quickly generate DWARF debug information by creating
+/// child DIEs or adding attributes to the current DIE. Instances of this class
+/// are created from the compile unit (dwarfgen::CompileUnit::getUnitDIE()) or
+/// by calling dwarfgen::DIE::addChild(...) and using the returned DIE object.
+class DIE {
+ dwarfgen::CompileUnit *CU;
+ llvm::DIE *Die;
+
+protected:
+ friend class Generator;
+ friend class CompileUnit;
+
+ DIE(CompileUnit *U = nullptr, llvm::DIE *D = nullptr) : CU(U), Die(D) {}
+
+ /// Called with a compile/type unit relative offset prior to generating the
+ /// DWARF debug info.
+ ///
+ /// \param CUOffset the compile/type unit relative offset where the
+ /// abbreviation code for this DIE will be encoded.
+ unsigned computeSizeAndOffsets(unsigned CUOffset);
+
+public:
+ /// Add an attribute value that has no value.
+ ///
+ /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+ /// represents a user defined DWARF attribute.
+ /// \param Form the dwarf::Form to use when encoding the attribute. This is
+ /// only used with the DW_FORM_flag_present form encoding.
+ void addAttribute(uint16_t Attr, dwarf::Form Form);
+
+ /// Add an attribute value to be encoded as a DIEInteger
+ ///
+ /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+ /// represents a user defined DWARF attribute.
+ /// \param Form the dwarf::Form to use when encoding the attribute.
+ /// \param U the unsigned integer to encode.
+ void addAttribute(uint16_t Attr, dwarf::Form Form, uint64_t U);
+
+ /// Add an attribute value to be encoded as a DIEString or DIEInlinedString.
+ ///
+ /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+ /// represents a user defined DWARF attribute.
+ /// \param Form the dwarf::Form to use when encoding the attribute. The form
+ /// must be one of DW_FORM_strp or DW_FORM_string.
+ /// \param String the string to encode.
+ void addAttribute(uint16_t Attr, dwarf::Form Form, StringRef String);
+
+ /// Add an attribute value to be encoded as a DIEEntry.
+ ///
+ /// DIEEntry attributes refer to other llvm::DIE objects that have been
+ /// created.
+ ///
+ /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+ /// represents a user defined DWARF attribute.
+ /// \param Form the dwarf::Form to use when encoding the attribute. The form
+ /// must be one of DW_FORM_strp or DW_FORM_string.
+ /// \param RefDie the DIE that this attriute refers to.
+ void addAttribute(uint16_t Attr, dwarf::Form Form, dwarfgen::DIE &RefDie);
+
+ /// Add an attribute value to be encoded as a DIEBlock.
+ ///
+ /// DIEBlock attributes refers to binary data that is stored as the
+ /// attribute's value.
+ ///
+ /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+ /// represents a user defined DWARF attribute.
+ /// \param Form the dwarf::Form to use when encoding the attribute. The form
+ /// must be one of DW_FORM_strp or DW_FORM_string.
+ /// \param P a pointer to the data to store as the attribute value.
+ /// \param S the size in bytes of the data pointed to by \param P .
+ void addAttribute(uint16_t Attr, dwarf::Form Form, const void *P, size_t S);
+
+ /// Add a new child to this DIE object.
+ ///
+ /// \param Tag the dwarf::Tag to assing to the llvm::DIE object.
+ /// \returns the newly created DIE object that is now a child owned by this
+ /// object.
+ dwarfgen::DIE addChild(dwarf::Tag Tag);
+};
+
+/// A DWARF compile unit used to generate DWARF compile/type units.
+///
+/// Instances of these classes are created by instances of the Generator
+/// class. All information required to generate a DWARF compile unit is
+/// contained inside this class.
+class CompileUnit {
+ Generator &DG;
+ DIEUnit DU;
+
+public:
+ CompileUnit(Generator &D, uint16_t V, uint8_t A)
+ : DG(D), DU(V, A, dwarf::DW_TAG_compile_unit) {}
+ DIE getUnitDIE();
+ Generator &getGenerator() { return DG; }
+ uint64_t getOffset() const { return DU.getDebugSectionOffset(); }
+ uint64_t getLength() const { return DU.getLength(); }
+ uint16_t getVersion() const { return DU.getDwarfVersion(); }
+ uint16_t getAddressSize() const { return DU.getAddressSize(); }
+ void setOffset(uint64_t Offset) { DU.setDebugSectionOffset(Offset); }
+ void setLength(uint64_t Length) { DU.setLength(Length); }
+};
+
+/// A DWARF generator.
+///
+/// Generate DWARF for unit tests by creating any instance of this class and
+/// calling Generator::addCompileUnit(), and then getting the dwarfgen::DIE from
+/// the returned compile unit and adding attributes and children to each DIE.
+class Generator {
+ std::unique_ptr<MCRegisterInfo> MRI;
+ std::unique_ptr<MCAsmInfo> MAI;
+ std::unique_ptr<MCObjectFileInfo> MOFI;
+ std::unique_ptr<MCContext> MC;
+ MCAsmBackend *MAB; // Owned by MCStreamer
+ std::unique_ptr<MCInstrInfo> MII;
+ std::unique_ptr<MCSubtargetInfo> MSTI;
+ MCCodeEmitter *MCE; // Owned by MCStreamer
+ MCStreamer *MS; // Owned by AsmPrinter
+ std::unique_ptr<TargetMachine> TM;
+ std::unique_ptr<AsmPrinter> Asm;
+ std::unique_ptr<DwarfStringPool> StringPool;
+ std::vector<std::unique_ptr<CompileUnit>> CompileUnits;
+ BumpPtrAllocator Allocator;
+ DIEAbbrevSet Abbreviations;
+
+ SmallString<4096> FileBytes;
+ /// The stream we use to generate the DWARF into as an ELF file.
+ std::unique_ptr<raw_svector_ostream> Stream;
+ /// The DWARF version to generate.
+ uint16_t Version;
+
+ /// Private constructor, call Generator::Create(...) to get a DWARF generator
+ /// expected.
+ Generator();
+
+ /// Create the streamer and setup the output buffer.
+ llvm::Error init(Triple TheTriple, uint16_t DwarfVersion);
+
+public:
+ /// Create a DWARF generator or get an appropriate error.
+ ///
+ /// \param TheTriple the triple to use when creating any required support
+ /// classes needed to emit the DWARF.
+ /// \param DwarfVersion the version of DWARF to emit.
+ ///
+ /// \returns a llvm::Expected that either contains a unique_ptr to a Generator
+ /// or a llvm::Error.
+ static llvm::Expected<std::unique_ptr<Generator>>
+ create(Triple TheTriple, uint16_t DwarfVersion);
+
+ ~Generator();
+
+ /// Generate all DWARF sections and return a memory buffer that
+ /// contains an ELF file that contains the DWARF.
+ StringRef generate();
+
+ /// Add a compile unit to be generated.
+ ///
+ /// \returns a dwarfgen::CompileUnit that can be used to retrieve the compile
+ /// unit dwarfgen::DIE that can be used to add attributes and add child DIE
+ /// objedts to.
+ dwarfgen::CompileUnit &addCompileUnit();
+
+ BumpPtrAllocator &getAllocator() { return Allocator; }
+ AsmPrinter *getAsmPrinter() const { return Asm.get(); }
+ DIEAbbrevSet &getAbbrevSet() { return Abbreviations; }
+ DwarfStringPool &getStringPool() { return *StringPool; }
+
+ /// Save the generated DWARF file to disk.
+ ///
+ /// \param Path the path to save the ELF file to.
+ bool saveFile(StringRef Path);
+};
+
+} // end namespace dwarfgen
+
+} // end namespace llvm
+
+#endif // LLVM_UNITTESTS_DEBUG_INFO_DWARF_DWARFGENERATOR_H
OpenPOWER on IntegriCloud