DIE.cpp | Explore in Territory

//===--- lib/CodeGen/DIE.cpp - DWARF Info Entries -------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Data structures for DWARF info entries.
//
//===----------------------------------------------------------------------===//

#include "llvm/CodeGen/DIE.h"
#include "DwarfCompileUnit.h"
#include "DwarfDebug.h"
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/raw_ostream.h"
usingnamespacellvm;

#define DEBUG_TYPE …

//===----------------------------------------------------------------------===//
// DIEAbbrevData Implementation
//===----------------------------------------------------------------------===//

/// Profile - Used to gather unique data for the abbreviation folding set.
///
void DIEAbbrevData::Profile(FoldingSetNodeID &ID) const { … }

//===----------------------------------------------------------------------===//
// DIEAbbrev Implementation
//===----------------------------------------------------------------------===//

/// Profile - Used to gather unique data for the abbreviation folding set.
///
void DIEAbbrev::Profile(FoldingSetNodeID &ID) const { … }

/// Emit - Print the abbreviation using the specified asm printer.
///
void DIEAbbrev::Emit(const AsmPrinter *AP) const { … }

LLVM_DUMP_METHOD
void DIEAbbrev::print(raw_ostream &O) const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void DIEAbbrev::dump() const {
  print(dbgs());
}
#endif

//===----------------------------------------------------------------------===//
// DIEAbbrevSet Implementation
//===----------------------------------------------------------------------===//

DIEAbbrevSet::~DIEAbbrevSet() { … }

DIEAbbrev &DIEAbbrevSet::uniqueAbbreviation(DIE &Die) { … }

void DIEAbbrevSet::Emit(const AsmPrinter *AP, MCSection *Section) const { … }

//===----------------------------------------------------------------------===//
// DIE Implementation
//===----------------------------------------------------------------------===//

DIE *DIE::getParent() const { … }

DIEAbbrev DIE::generateAbbrev() const { … }

uint64_t DIE::getDebugSectionOffset() const { … }

const DIE *DIE::getUnitDie() const { … }

DIEUnit *DIE::getUnit() const { … }

DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const { … }

LLVM_DUMP_METHOD
static void printValues(raw_ostream &O, const DIEValueList &Values,
                        StringRef Type, unsigned Size, unsigned IndentCount) { … }

LLVM_DUMP_METHOD
void DIE::print(raw_ostream &O, unsigned IndentCount) const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void DIE::dump() const {
  print(dbgs());
}
#endif

unsigned DIE::computeOffsetsAndAbbrevs(const dwarf::FormParams &FormParams,
                                       DIEAbbrevSet &AbbrevSet,
                                       unsigned CUOffset) { … }

//===----------------------------------------------------------------------===//
// DIEUnit Implementation
//===----------------------------------------------------------------------===//
DIEUnit::DIEUnit(dwarf::Tag UnitTag) : … { … }

void DIEValue::emitValue(const AsmPrinter *AP) const { … }

unsigned DIEValue::sizeOf(const dwarf::FormParams &FormParams) const { … }

LLVM_DUMP_METHOD
void DIEValue::print(raw_ostream &O) const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void DIEValue::dump() const {
  print(dbgs());
}
#endif

//===----------------------------------------------------------------------===//
// DIEInteger Implementation
//===----------------------------------------------------------------------===//

/// EmitValue - Emit integer of appropriate size.
///
void DIEInteger::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const { … }

/// sizeOf - Determine size of integer value in bytes.
///
unsigned DIEInteger::sizeOf(const dwarf::FormParams &FormParams,
                            dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIEInteger::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEExpr Implementation
//===----------------------------------------------------------------------===//

/// EmitValue - Emit expression value.
///
void DIEExpr::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

/// SizeOf - Determine size of expression value in bytes.
///
unsigned DIEExpr::sizeOf(const dwarf::FormParams &FormParams,
                         dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIEExpr::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIELabel Implementation
//===----------------------------------------------------------------------===//

/// EmitValue - Emit label value.
///
void DIELabel::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

/// sizeOf - Determine size of label value in bytes.
///
unsigned DIELabel::sizeOf(const dwarf::FormParams &FormParams,
                          dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIELabel::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEBaseTypeRef Implementation
//===----------------------------------------------------------------------===//

void DIEBaseTypeRef::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

unsigned DIEBaseTypeRef::sizeOf(const dwarf::FormParams &, dwarf::Form) const { … }

LLVM_DUMP_METHOD
void DIEBaseTypeRef::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEDelta Implementation
//===----------------------------------------------------------------------===//

/// EmitValue - Emit delta value.
///
void DIEDelta::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

/// SizeOf - Determine size of delta value in bytes.
///
unsigned DIEDelta::sizeOf(const dwarf::FormParams &FormParams,
                          dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIEDelta::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEString Implementation
//===----------------------------------------------------------------------===//

/// EmitValue - Emit string value.
///
void DIEString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

/// sizeOf - Determine size of delta value in bytes.
///
unsigned DIEString::sizeOf(const dwarf::FormParams &FormParams,
                           dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIEString::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEInlineString Implementation
//===----------------------------------------------------------------------===//
void DIEInlineString::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

unsigned DIEInlineString::sizeOf(const dwarf::FormParams &, dwarf::Form) const { … }

LLVM_DUMP_METHOD
void DIEInlineString::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEEntry Implementation
//===----------------------------------------------------------------------===//

/// EmitValue - Emit debug information entry offset.
///
void DIEEntry::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

unsigned DIEEntry::sizeOf(const dwarf::FormParams &FormParams,
                          dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIEEntry::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIELoc Implementation
//===----------------------------------------------------------------------===//

unsigned DIELoc::computeSize(const dwarf::FormParams &FormParams) const { … }

/// EmitValue - Emit location data.
///
void DIELoc::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const { … }

/// sizeOf - Determine size of location data in bytes.
///
unsigned DIELoc::sizeOf(const dwarf::FormParams &, dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIELoc::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEBlock Implementation
//===----------------------------------------------------------------------===//

unsigned DIEBlock::computeSize(const dwarf::FormParams &FormParams) const { … }

/// EmitValue - Emit block data.
///
void DIEBlock::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const { … }

/// sizeOf - Determine size of block data in bytes.
///
unsigned DIEBlock::sizeOf(const dwarf::FormParams &, dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIEBlock::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIELocList Implementation
//===----------------------------------------------------------------------===//

unsigned DIELocList::sizeOf(const dwarf::FormParams &FormParams,
                            dwarf::Form Form) const { … }

/// EmitValue - Emit label value.
///
void DIELocList::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIELocList::print(raw_ostream &O) const { … }

//===----------------------------------------------------------------------===//
// DIEAddrOffset Implementation
//===----------------------------------------------------------------------===//

unsigned DIEAddrOffset::sizeOf(const dwarf::FormParams &FormParams,
                               dwarf::Form) const { … }

/// EmitValue - Emit label value.
///
void DIEAddrOffset::emitValue(const AsmPrinter *AP, dwarf::Form Form) const { … }

LLVM_DUMP_METHOD
void DIEAddrOffset::print(raw_ostream &O) const { … }
llvm/llvm/lib/CodeGen/AsmPrinter/DIE.cpp
