//===- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file contains support for writing dwarf debug info into asm files. // //===----------------------------------------------------------------------===// #include "DwarfDebug.h" #include "ByteStreamer.h" #include "DIEHash.h" #include "DwarfCompileUnit.h" #include "DwarfExpression.h" #include "DwarfUnit.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/Twine.h" #include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/DIE.h" #include "llvm/CodeGen/LexicalScopes.h" #include "llvm/CodeGen/MachineBasicBlock.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/MachineOperand.h" #include "llvm/CodeGen/TargetInstrInfo.h" #include "llvm/CodeGen/TargetLowering.h" #include "llvm/CodeGen/TargetRegisterInfo.h" #include "llvm/CodeGen/TargetSubtargetInfo.h" #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h" #include "llvm/DebugInfo/DWARF/DWARFExpression.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Function.h" #include "llvm/IR/GlobalVariable.h" #include "llvm/IR/Module.h" #include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCSection.h" #include "llvm/MC/MCStreamer.h" #include "llvm/MC/MCSymbol.h" #include "llvm/MC/MCTargetOptions.h" #include "llvm/MC/MachineLocation.h" #include "llvm/MC/SectionKind.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MD5.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Target/TargetLoweringObjectFile.h" #include "llvm/Target/TargetMachine.h" #include "llvm/TargetParser/Triple.h" #include <algorithm> #include <cstddef> #include <iterator> #include <optional> #include <string> usingnamespacellvm; #define DEBUG_TYPE … STATISTIC(NumCSParams, "Number of dbg call site params created"); static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier( "use-dwarf-ranges-base-address-specifier", cl::Hidden, cl::desc("Use base address specifiers in debug_ranges"), cl::init(false)); static cl::opt<bool> GenerateARangeSection("generate-arange-section", cl::Hidden, cl::desc("Generate dwarf aranges"), cl::init(false)); static cl::opt<bool> GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, cl::desc("Generate DWARF4 type units."), cl::init(false)); static cl::opt<bool> SplitDwarfCrossCuReferences( "split-dwarf-cross-cu-references", cl::Hidden, cl::desc("Enable cross-cu references in DWO files"), cl::init(false)); enum DefaultOnOff { … }; static cl::opt<DefaultOnOff> UnknownLocations( "use-unknown-locations", cl::Hidden, cl::desc("Make an absence of debug location information explicit."), cl::values(clEnumVal(Default, "At top of block or after label"), clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")), cl::init(Default)); static cl::opt<AccelTableKind> AccelTables( "accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."), cl::values(clEnumValN(AccelTableKind::Default, "Default", "Default for platform"), clEnumValN(AccelTableKind::None, "Disable", "Disabled."), clEnumValN(AccelTableKind::Apple, "Apple", "Apple"), clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")), cl::init(AccelTableKind::Default)); static cl::opt<DefaultOnOff> DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden, cl::desc("Use inlined strings rather than string section."), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default)); static cl::opt<bool> NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden, cl::desc("Disable emission .debug_ranges section."), cl::init(false)); static cl::opt<DefaultOnOff> DwarfSectionsAsReferences( "dwarf-sections-as-references", cl::Hidden, cl::desc("Use sections+offset as references rather than labels."), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default)); static cl::opt<bool> UseGNUDebugMacro("use-gnu-debug-macro", cl::Hidden, cl::desc("Emit the GNU .debug_macro format with DWARF <5"), cl::init(false)); static cl::opt<DefaultOnOff> DwarfOpConvert( "dwarf-op-convert", cl::Hidden, cl::desc("Enable use of the DWARFv5 DW_OP_convert operator"), cl::values(clEnumVal(Default, "Default for platform"), clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), cl::init(Default)); enum LinkageNameOption { … }; static cl::opt<LinkageNameOption> DwarfLinkageNames("dwarf-linkage-names", cl::Hidden, cl::desc("Which DWARF linkage-name attributes to emit."), cl::values(clEnumValN(DefaultLinkageNames, "Default", "Default for platform"), clEnumValN(AllLinkageNames, "All", "All"), clEnumValN(AbstractLinkageNames, "Abstract", "Abstract subprograms")), cl::init(DefaultLinkageNames)); static cl::opt<DwarfDebug::MinimizeAddrInV5> MinimizeAddrInV5Option( "minimize-addr-in-v5", cl::Hidden, cl::desc("Always use DW_AT_ranges in DWARFv5 whenever it could allow more " "address pool entry sharing to reduce relocations/object size"), cl::values(clEnumValN(DwarfDebug::MinimizeAddrInV5::Default, "Default", "Default address minimization strategy"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Ranges, "Ranges", "Use rnglists for contiguous ranges if that allows " "using a pre-existing base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Expressions, "Expressions", "Use exprloc addrx+offset expressions for any " "address with a prior base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Form, "Form", "Use addrx+offset extension form for any address " "with a prior base address"), clEnumValN(DwarfDebug::MinimizeAddrInV5::Disabled, "Disabled", "Stuff")), cl::init(DwarfDebug::MinimizeAddrInV5::Default)); static constexpr unsigned ULEB128PadSize = …; void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) { … } void DebugLocDwarfExpression::emitSigned(int64_t Value) { … } void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) { … } void DebugLocDwarfExpression::emitData1(uint8_t Value) { … } void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) { … } bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI, llvm::Register MachineReg) { … } void DebugLocDwarfExpression::enableTemporaryBuffer() { … } void DebugLocDwarfExpression::disableTemporaryBuffer() { … } unsigned DebugLocDwarfExpression::getTemporaryBufferSize() { … } void DebugLocDwarfExpression::commitTemporaryBuffer() { … } const DIType *DbgVariable::getType() const { … } /// Get .debug_loc entry for the instruction range starting at MI. static DbgValueLoc getDebugLocValue(const MachineInstr *MI) { … } static uint64_t getFragmentOffsetInBits(const DIExpression &Expr) { … } bool llvm::operator<(const FrameIndexExpr &LHS, const FrameIndexExpr &RHS) { … } bool llvm::operator<(const EntryValueInfo &LHS, const EntryValueInfo &RHS) { … } Loc::Single::Single(DbgValueLoc ValueLoc) : … { … } Loc::Single::Single(const MachineInstr *DbgValue) : … { … } const std::set<FrameIndexExpr> &Loc::MMI::getFrameIndexExprs() const { … } void Loc::MMI::addFrameIndexExpr(const DIExpression *Expr, int FI) { … } static AccelTableKind computeAccelTableKind(unsigned DwarfVersion, bool GenerateTypeUnits, DebuggerKind Tuning, const Triple &TT) { … } DwarfDebug::DwarfDebug(AsmPrinter *A) : … { … } // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h. DwarfDebug::~DwarfDebug() = default; static bool isObjCClass(StringRef Name) { … } static bool hasObjCCategory(StringRef Name) { … } static void getObjCClassCategory(StringRef In, StringRef &Class, StringRef &Category) { … } static StringRef getObjCMethodName(StringRef In) { … } // Add the various names to the Dwarf accelerator table names. void DwarfDebug::addSubprogramNames( const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, const DISubprogram *SP, DIE &Die) { … } /// Check whether we should create a DIE for the given Scope, return true /// if we don't create a DIE (the corresponding DIE is null). bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) { … } template <typename Func> static void forBothCUs(DwarfCompileUnit &CU, Func F) { … } bool DwarfDebug::shareAcrossDWOCUs() const { … } void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope) { … } /// Represents a parameter whose call site value can be described by applying a /// debug expression to a register in the forwarded register worklist. struct FwdRegParamInfo { … }; /// Register worklist for finding call site values. FwdRegWorklist; /// Container for the set of registers known to be clobbered on the path to a /// call site. ClobberedRegSet; /// Append the expression \p Addition to \p Original and return the result. static const DIExpression *combineDIExpressions(const DIExpression *Original, const DIExpression *Addition) { … } /// Emit call site parameter entries that are described by the given value and /// debug expression. template <typename ValT> static void finishCallSiteParams(ValT Val, const DIExpression *Expr, ArrayRef<FwdRegParamInfo> DescribedParams, ParamSet &Params) { … } /// Add \p Reg to the worklist, if it's not already present, and mark that the /// given parameter registers' values can (potentially) be described using /// that register and an debug expression. static void addToFwdRegWorklist(FwdRegWorklist &Worklist, unsigned Reg, const DIExpression *Expr, ArrayRef<FwdRegParamInfo> ParamsToAdd) { … } /// Interpret values loaded into registers by \p CurMI. static void interpretValues(const MachineInstr *CurMI, FwdRegWorklist &ForwardedRegWorklist, ParamSet &Params, ClobberedRegSet &ClobberedRegUnits) { … } static bool interpretNextInstr(const MachineInstr *CurMI, FwdRegWorklist &ForwardedRegWorklist, ParamSet &Params, ClobberedRegSet &ClobberedRegUnits) { … } /// Try to interpret values loaded into registers that forward parameters /// for \p CallMI. Store parameters with interpreted value into \p Params. static void collectCallSiteParameters(const MachineInstr *CallMI, ParamSet &Params) { … } void DwarfDebug::constructCallSiteEntryDIEs(const DISubprogram &SP, DwarfCompileUnit &CU, DIE &ScopeDIE, const MachineFunction &MF) { … } void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const { … } void DwarfDebug::finishUnitAttributes(const DICompileUnit *DIUnit, DwarfCompileUnit &NewCU) { … } // Create new DwarfCompileUnit for the given metadata node with tag // DW_TAG_compile_unit. DwarfCompileUnit & DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) { … } /// Sort and unique GVEs by comparing their fragment offset. static SmallVectorImpl<DwarfCompileUnit::GlobalExpr> & sortGlobalExprs(SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &GVEs) { … } // Emit all Dwarf sections that should come prior to the content. Create // global DIEs and emit initial debug info sections. This is invoked by // the target AsmPrinter. void DwarfDebug::beginModule(Module *M) { … } void DwarfDebug::finishEntityDefinitions() { … } void DwarfDebug::finishSubprogramDefinitions() { … } void DwarfDebug::finalizeModuleInfo() { … } // Emit all Dwarf sections that should come after the content. void DwarfDebug::endModule() { … } void DwarfDebug::ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU, const DINode *Node, const MDNode *ScopeNode) { … } static const DILocalScope *getRetainedNodeScope(const MDNode *N) { … } // Collect variable information from side table maintained by MF. void DwarfDebug::collectVariableInfoFromMFTable( DwarfCompileUnit &TheCU, DenseSet<InlinedEntity> &Processed) { … } /// Determine whether a *singular* DBG_VALUE is valid for the entirety of its /// enclosing lexical scope. The check ensures there are no other instructions /// in the same lexical scope preceding the DBG_VALUE and that its range is /// either open or otherwise rolls off the end of the scope. static bool validThroughout(LexicalScopes &LScopes, const MachineInstr *DbgValue, const MachineInstr *RangeEnd, const InstructionOrdering &Ordering) { … } /// Build the location list for all DBG_VALUEs in the function that /// describe the same variable. The resulting DebugLocEntries will have /// strict monotonically increasing begin addresses and will never /// overlap. If the resulting list has only one entry that is valid /// throughout variable's scope return true. // // See the definition of DbgValueHistoryMap::Entry for an explanation of the // different kinds of history map entries. One thing to be aware of is that if // a debug value is ended by another entry (rather than being valid until the // end of the function), that entry's instruction may or may not be included in // the range, depending on if the entry is a clobbering entry (it has an // instruction that clobbers one or more preceding locations), or if it is an // (overlapping) debug value entry. This distinction can be seen in the example // below. The first debug value is ended by the clobbering entry 2, and the // second and third debug values are ended by the overlapping debug value entry // 4. // // Input: // // History map entries [type, end index, mi] // // 0 | [DbgValue, 2, DBG_VALUE $reg0, [...] (fragment 0, 32)] // 1 | | [DbgValue, 4, DBG_VALUE $reg1, [...] (fragment 32, 32)] // 2 | | [Clobber, $reg0 = [...], -, -] // 3 | | [DbgValue, 4, DBG_VALUE 123, [...] (fragment 64, 32)] // 4 [DbgValue, ~0, DBG_VALUE @g, [...] (fragment 0, 96)] // // Output [start, end) [Value...]: // // [0-1) [(reg0, fragment 0, 32)] // [1-3) [(reg0, fragment 0, 32), (reg1, fragment 32, 32)] // [3-4) [(reg1, fragment 32, 32), (123, fragment 64, 32)] // [4-) [(@g, fragment 0, 96)] bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc, const DbgValueHistoryMap::Entries &Entries) { … } DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU, LexicalScope &Scope, const DINode *Node, const DILocation *Location, const MCSymbol *Sym) { … } // Find variables for each lexical scope. void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP, DenseSet<InlinedEntity> &Processed) { … } // Process beginning of an instruction. void DwarfDebug::beginInstruction(const MachineInstr *MI) { … } static std::pair<const MachineInstr *, bool> findPrologueEndLoc(const MachineFunction *MF) { … } /// Register a source line with debug info. Returns the unique label that was /// emitted and which provides correspondence to the source line list. static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col, const MDNode *S, unsigned Flags, unsigned CUID, uint16_t DwarfVersion, ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs) { … } const MachineInstr * DwarfDebug::emitInitialLocDirective(const MachineFunction &MF, unsigned CUID) { … } // Gather pre-function debug information. Assumes being called immediately // after the function entry point has been emitted. void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) { … } unsigned DwarfDebug::getDwarfCompileUnitIDForLineTable(const DwarfCompileUnit &CU) { … } void DwarfDebug::terminateLineTable(const DwarfCompileUnit *CU) { … } void DwarfDebug::skippedNonDebugFunction() { … } // Gather and emit post-function debug information. void DwarfDebug::endFunctionImpl(const MachineFunction *MF) { … } // Register a source line with debug info. Returns the unique label that was // emitted and which provides correspondence to the source line list. void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, unsigned Flags) { … } //===----------------------------------------------------------------------===// // Emit Methods //===----------------------------------------------------------------------===// // Emit the debug info section. void DwarfDebug::emitDebugInfo() { … } // Emit the abbreviation section. void DwarfDebug::emitAbbreviations() { … } void DwarfDebug::emitStringOffsetsTableHeader() { … } template <typename AccelTableT> void DwarfDebug::emitAccel(AccelTableT &Accel, MCSection *Section, StringRef TableName) { … } void DwarfDebug::emitAccelDebugNames() { … } // Emit visible names into a hashed accelerator table section. void DwarfDebug::emitAccelNames() { … } // Emit objective C classes and categories into a hashed accelerator table // section. void DwarfDebug::emitAccelObjC() { … } // Emit namespace dies into a hashed accelerator table. void DwarfDebug::emitAccelNamespaces() { … } // Emit type dies into a hashed accelerator table. void DwarfDebug::emitAccelTypes() { … } // Public name handling. // The format for the various pubnames: // // dwarf pubnames - offset/name pairs where the offset is the offset into the CU // for the DIE that is named. // // gnu pubnames - offset/index value/name tuples where the offset is the offset // into the CU and the index value is computed according to the type of value // for the DIE that is named. // // For type units the offset is the offset of the skeleton DIE. For split dwarf // it's the offset within the debug_info/debug_types dwo section, however, the // reference in the pubname header doesn't change. /// computeIndexValue - Compute the gdb index value for the DIE and CU. static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU, const DIE *Die) { … } /// emitDebugPubSections - Emit visible names and types into debug pubnames and /// pubtypes sections. void DwarfDebug::emitDebugPubSections() { … } void DwarfDebug::emitSectionReference(const DwarfCompileUnit &CU) { … } void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name, DwarfCompileUnit *TheU, const StringMap<const DIE *> &Globals) { … } /// Emit null-terminated strings into a debug str section. void DwarfDebug::emitDebugStr() { … } void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer, const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU) { … } void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, const DbgValueLoc &Value, DwarfExpression &DwarfExpr) { … } void DebugLocEntry::finalize(const AsmPrinter &AP, DebugLocStream::ListBuilder &List, const DIBasicType *BT, DwarfCompileUnit &TheCU) { … } void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU) { … } // Emit the header of a DWARF 5 range list table list table. Returns the symbol // that designates the end of the table for the caller to emit when the table is // complete. static MCSymbol *emitRnglistsTableHeader(AsmPrinter *Asm, const DwarfFile &Holder) { … } // Emit the header of a DWARF 5 locations list table. Returns the symbol that // designates the end of the table for the caller to emit when the table is // complete. static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm, const DwarfDebug &DD) { … } template <typename Ranges, typename PayloadEmitter> static void emitRangeList( DwarfDebug &DD, AsmPrinter *Asm, MCSymbol *Sym, const Ranges &R, const DwarfCompileUnit &CU, unsigned BaseAddressx, unsigned OffsetPair, unsigned StartxLength, unsigned EndOfList, StringRef (*StringifyEnum)(unsigned), bool ShouldUseBaseAddress, PayloadEmitter EmitPayload) { … } // Handles emission of both debug_loclist / debug_loclist.dwo static void emitLocList(DwarfDebug &DD, AsmPrinter *Asm, const DebugLocStream::List &List) { … } void DwarfDebug::emitDebugLocImpl(MCSection *Sec) { … } // Emit locations into the .debug_loc/.debug_loclists section. void DwarfDebug::emitDebugLoc() { … } // Emit locations into the .debug_loc.dwo/.debug_loclists.dwo section. void DwarfDebug::emitDebugLocDWO() { … } struct ArangeSpan { … }; // Emit a debug aranges section, containing a CU lookup for any // address we can tie back to a CU. void DwarfDebug::emitDebugARanges() { … } /// Emit a single range list. We handle both DWARF v5 and earlier. static void emitRangeList(DwarfDebug &DD, AsmPrinter *Asm, const RangeSpanList &List) { … } void DwarfDebug::emitDebugRangesImpl(const DwarfFile &Holder, MCSection *Section) { … } /// Emit address ranges into the .debug_ranges section or into the DWARF v5 /// .debug_rnglists section. void DwarfDebug::emitDebugRanges() { … } void DwarfDebug::emitDebugRangesDWO() { … } /// Emit the header of a DWARF 5 macro section, or the GNU extension for /// DWARF 4. static void emitMacroHeader(AsmPrinter *Asm, const DwarfDebug &DD, const DwarfCompileUnit &CU, uint16_t DwarfVersion) { … } void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) { … } void DwarfDebug::emitMacro(DIMacro &M) { … } void DwarfDebug::emitMacroFileImpl( DIMacroFile &MF, DwarfCompileUnit &U, unsigned StartFile, unsigned EndFile, StringRef (*MacroFormToString)(unsigned Form)) { … } void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) { … } void DwarfDebug::emitDebugMacinfoImpl(MCSection *Section) { … } /// Emit macros into a debug macinfo/macro section. void DwarfDebug::emitDebugMacinfo() { … } void DwarfDebug::emitDebugMacinfoDWO() { … } // DWARF5 Experimental Separate Dwarf emitters. void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die, std::unique_ptr<DwarfCompileUnit> NewU) { … } DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) { … } // Emit the .debug_info.dwo section for separated dwarf. This contains the // compile units that would normally be in debug_info. void DwarfDebug::emitDebugInfoDWO() { … } // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the // abbreviations for the .debug_info.dwo section. void DwarfDebug::emitDebugAbbrevDWO() { … } void DwarfDebug::emitDebugLineDWO() { … } void DwarfDebug::emitStringOffsetsTableHeaderDWO() { … } // Emit the .debug_str.dwo section for separated dwarf. This contains the // string section and is identical in format to traditional .debug_str // sections. void DwarfDebug::emitDebugStrDWO() { … } // Emit address pool. void DwarfDebug::emitDebugAddr() { … } MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) { … } uint64_t DwarfDebug::makeTypeSignature(StringRef Identifier) { … } void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &RefDie, const DICompositeType *CTy) { … } // Add the Name along with its companion DIE to the appropriate accelerator // table (for AccelTableKind::Dwarf it's always AccelDebugNames, for // AccelTableKind::Apple, we use the table we got as an argument). If // accelerator tables are disabled, this function does nothing. template <typename DataT> void DwarfDebug::addAccelNameImpl( const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, AccelTable<DataT> &AppleAccel, StringRef Name, const DIE &Die) { … } void DwarfDebug::addAccelName( const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die) { … } void DwarfDebug::addAccelObjC( const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die) { … } void DwarfDebug::addAccelNamespace( const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die) { … } void DwarfDebug::addAccelType( const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die, char Flags) { … } uint16_t DwarfDebug::getDwarfVersion() const { … } dwarf::Form DwarfDebug::getDwarfSectionOffsetForm() const { … } const MCSymbol *DwarfDebug::getSectionLabel(const MCSection *S) { … } void DwarfDebug::insertSectionLabel(const MCSymbol *S) { … } std::optional<MD5::MD5Result> DwarfDebug::getMD5AsBytes(const DIFile *File) const { … } bool DwarfDebug::alwaysUseRanges(const DwarfCompileUnit &CU) const { … } void DwarfDebug::beginCodeAlignment(const MachineBasicBlock &MBB) { … }
Codebase Browser
llvm