1
0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-29 23:12:55 +01:00
llvm-mirror/include/llvm/CodeGen/DwarfWriter.h

429 lines
13 KiB
C
Raw Normal View History

//===-- llvm/CodeGen/DwarfWriter.h - Dwarf Framework ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by James M. Laskey and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains support for writing Dwarf debug info into asm files. For
// Details on the Dwarf 3 specfication see DWARF Debugging Information Format
// V.3 reference manual http://dwarf.freestandards.org ,
//
// The role of the Dwarf Writer class is to extract debug information from the
// MachineDebugInfo object, organize it in Dwarf form and then emit it into asm
// the current asm file using data and high level Dwarf directives.
//
//===----------------------------------------------------------------------===//
2006-01-17 20:12:24 +01:00
#ifndef LLVM_CODEGEN_DWARFWRITER_H
#define LLVM_CODEGEN_DWARFWRITER_H
#include "llvm/ADT/UniqueVector.h"
#include "llvm/Support/DataTypes.h"
#include <iosfwd>
#include <string>
2005-12-21 20:46:32 +01:00
namespace llvm {
2006-02-27 13:43:29 +01:00
// Forward declarations.
class AsmPrinter;
class CompileUnit;
2006-02-27 13:43:29 +01:00
class CompileUnitDesc;
class DebugInfoDesc;
class DebugVariable;
class DebugScope;
2006-02-27 13:43:29 +01:00
class DIE;
class DIEAbbrev;
class GlobalVariableDesc;
class MachineDebugInfo;
class MachineFunction;
class MachineLocation;
class MachineMove;
2006-02-27 13:43:29 +01:00
class Module;
class MRegisterInfo;
2006-02-27 13:43:29 +01:00
class SubprogramDesc;
class SourceLineInfo;
class TargetAsmInfo;
class TargetData;
2006-02-27 13:43:29 +01:00
class Type;
class TypeDesc;
2006-02-27 13:43:29 +01:00
//===----------------------------------------------------------------------===//
// DWLabel - Labels are used to track locations in the assembler file.
// Labels appear in the form <prefix>debug_<Tag><Number>, where the tag is a
// category of label (Ex. location) and number is a value unique in that
// category.
class DWLabel {
public:
const char *Tag; // Label category tag. Should always be
// a staticly declared C string.
unsigned Number; // Unique number.
DWLabel(const char *T, unsigned N) : Tag(T), Number(N) {}
};
//===----------------------------------------------------------------------===//
// DwarfWriter - Emits Dwarf debug and exception handling directives.
//
class DwarfWriter {
private:
2006-02-27 13:43:29 +01:00
//===--------------------------------------------------------------------===//
2006-02-27 13:43:29 +01:00
// Core attributes used by the Dwarf writer.
//
2006-02-27 13:43:29 +01:00
//
/// O - Stream to .s file.
///
std::ostream &O;
/// Asm - Target of Dwarf emission.
///
AsmPrinter *Asm;
/// TAI - Target Asm Printer.
const TargetAsmInfo *TAI;
/// TD - Target data.
const TargetData *TD;
/// RI - Register Information.
const MRegisterInfo *RI;
/// M - Current module.
///
Module *M;
/// MF - Current machine function.
///
MachineFunction *MF;
2006-02-27 13:43:29 +01:00
/// DebugInfo - Collected debug information.
///
MachineDebugInfo *DebugInfo;
/// didInitial - Flag to indicate if initial emission has been done.
///
bool didInitial;
/// shouldEmit - Flag to indicate if debug information should be emitted.
///
bool shouldEmit;
/// SubprogramCount - The running count of functions being compiled.
///
unsigned SubprogramCount;
//===--------------------------------------------------------------------===//
2006-02-27 13:43:29 +01:00
// Attributes used to construct specific Dwarf sections.
//
/// CompileUnits - All the compile units involved in this build. The index
/// of each entry in this vector corresponds to the sources in DebugInfo.
std::vector<CompileUnit *> CompileUnits;
2006-02-27 13:43:29 +01:00
/// Abbreviations - A UniqueVector of TAG structure abbreviations.
///
UniqueVector<DIEAbbrev> Abbreviations;
/// StringPool - A UniqueVector of strings used by indirect references.
/// UnitMap - Map debug information descriptor to compile unit.
///
2006-02-27 13:43:29 +01:00
UniqueVector<std::string> StringPool;
/// UnitMap - Map debug information descriptor to compile unit.
///
std::map<DebugInfoDesc *, CompileUnit *> DescToUnitMap;
2006-02-27 13:43:29 +01:00
/// DescToDieMap - Tracks the mapping of top level debug informaton
/// descriptors to debug information entries.
2006-02-27 13:43:29 +01:00
std::map<DebugInfoDesc *, DIE *> DescToDieMap;
/// SectionMap - Provides a unique id per text section.
///
UniqueVector<std::string> SectionMap;
/// SectionSourceLines - Tracks line numbers per text section.
2006-02-27 13:43:29 +01:00
///
std::vector<std::vector<SourceLineInfo *> > SectionSourceLines;
public:
//===--------------------------------------------------------------------===//
2006-02-27 13:43:29 +01:00
// Emission and print routines
//
2006-02-27 13:43:29 +01:00
/// PrintHex - Print a value as a hexidecimal value.
///
void PrintHex(int Value) const;
/// EOL - Print a newline character to asm stream. If a comment is present
/// then it will be printed first. Comments should not contain '\n'.
void EOL(const std::string &Comment) const;
/// EmitAlign - Print a align directive.
///
void EmitAlign(unsigned Alignment) const;
2006-02-27 13:43:29 +01:00
/// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
/// unsigned leb128 value.
void EmitULEB128Bytes(unsigned Value) const;
2006-02-27 13:43:29 +01:00
/// EmitSLEB128Bytes - print an assembler byte data directive to compose a
/// signed leb128 value.
void EmitSLEB128Bytes(int Value) const;
2006-02-27 13:43:29 +01:00
/// PrintULEB128 - Print a series of hexidecimal values (separated by
/// commas) representing an unsigned leb128 value.
void PrintULEB128(unsigned Value) const;
/// SizeULEB128 - Compute the number of bytes required for an unsigned
/// leb128 value.
static unsigned SizeULEB128(unsigned Value);
2006-02-27 13:43:29 +01:00
/// PrintSLEB128 - Print a series of hexidecimal values (separated by
/// commas) representing a signed leb128 value.
void PrintSLEB128(int Value) const;
/// SizeSLEB128 - Compute the number of bytes required for a signed leb128
/// value.
static unsigned SizeSLEB128(int Value);
/// EmitInt8 - Emit a byte directive and value.
///
void EmitInt8(int Value) const;
2006-02-27 13:43:29 +01:00
/// EmitInt16 - Emit a short directive and value.
///
void EmitInt16(int Value) const;
/// EmitInt32 - Emit a long directive and value.
///
void EmitInt32(int Value) const;
/// EmitInt64 - Emit a long long directive and value.
///
void EmitInt64(uint64_t Value) const;
/// EmitString - Emit a string with quotes and a null terminator.
/// Special characters are emitted properly.
/// \literal (Eg. '\t') \endliteral
2006-02-27 13:43:29 +01:00
void EmitString(const std::string &String) const;
/// PrintLabelName - Print label name in form used by Dwarf writer.
///
void PrintLabelName(DWLabel Label) const {
PrintLabelName(Label.Tag, Label.Number);
}
void PrintLabelName(const char *Tag, unsigned Number) const;
/// EmitLabel - Emit location label for internal use by Dwarf.
///
void EmitLabel(DWLabel Label) const {
EmitLabel(Label.Tag, Label.Number);
}
void EmitLabel(const char *Tag, unsigned Number) const;
/// EmitReference - Emit a reference to a label.
///
void EmitReference(DWLabel Label) const {
EmitReference(Label.Tag, Label.Number);
}
void EmitReference(const char *Tag, unsigned Number) const;
void EmitReference(const std::string &Name) const;
/// EmitDifference - Emit the difference between two labels. Some
/// assemblers do not behave with absolute expressions with data directives,
/// so there is an option (needsSet) to use an intermediary set expression.
void EmitDifference(DWLabel LabelHi, DWLabel LabelLo) const {
EmitDifference(LabelHi.Tag, LabelHi.Number, LabelLo.Tag, LabelLo.Number);
}
void EmitDifference(const char *TagHi, unsigned NumberHi,
const char *TagLo, unsigned NumberLo) const;
2006-02-27 13:43:29 +01:00
/// NewAbbreviation - Add the abbreviation to the Abbreviation vector.
///
unsigned NewAbbreviation(DIEAbbrev *Abbrev);
/// NewString - Add a string to the constant pool and returns a label.
///
DWLabel NewString(const std::string &String);
/// getDieMapSlotFor - Returns the debug information entry map slot for the
/// specified debug descriptor.
DIE *&getDieMapSlotFor(DebugInfoDesc *DD);
private:
/// AddSourceLine - Add location information to specified debug information
/// entry.
void AddSourceLine(DIE *Die, CompileUnitDesc *File, unsigned Line);
/// AddAddress - Add an address attribute to a die based on the location
/// provided.
void AddAddress(DIE *Die, unsigned Attribute,
const MachineLocation &Location);
2006-02-27 13:43:29 +01:00
/// NewType - Create a new type DIE.
///
DIE *NewType(DIE *Context, TypeDesc *TyDesc, CompileUnit *Unit);
2006-02-27 13:43:29 +01:00
/// NewCompileUnit - Create new compile unit and it's die.
2006-02-27 13:43:29 +01:00
///
CompileUnit *NewCompileUnit(CompileUnitDesc *UnitDesc, unsigned ID);
/// FindCompileUnit - Get the compile unit for the given descriptor.
///
CompileUnit *FindCompileUnit(CompileUnitDesc *UnitDesc);
2006-02-27 13:43:29 +01:00
/// NewGlobalVariable - Make a new global variable DIE.
///
DIE *NewGlobalVariable(GlobalVariableDesc *GVD);
/// NewSubprogram - Add a new subprogram DIE.
///
DIE *NewSubprogram(SubprogramDesc *SPD);
/// NewScopeVariable - Create a new scope variable.
///
DIE *NewScopeVariable(DebugVariable *DV, CompileUnit *Unit);
/// ConstructScope - Construct the components of a scope.
///
void ConstructScope(DebugScope *ParentScope, DIE *ParentDie,
CompileUnit *Unit);
/// ConstructRootScope - Construct the scope for the subprogram.
///
void ConstructRootScope(DebugScope *RootScope);
2006-02-27 13:43:29 +01:00
/// EmitInitial - Emit initial Dwarf declarations.
///
void EmitInitial();
2006-02-27 13:43:29 +01:00
/// EmitDIE - Recusively Emits a debug information entry.
///
void EmitDIE(DIE *Die) const;
/// SizeAndOffsetDie - Compute the size and offset of a DIE.
///
unsigned SizeAndOffsetDie(DIE *Die, unsigned Offset, bool Last);
2006-02-27 13:43:29 +01:00
/// SizeAndOffsets - Compute the size and offset of all the DIEs.
///
void SizeAndOffsets();
/// EmitFrameMoves - Emit frame instructions to describe the layout of the
/// frame.
void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID,
std::vector<MachineMove *> &Moves);
2006-02-27 13:43:29 +01:00
/// EmitDebugInfo - Emit the debug info section.
///
void EmitDebugInfo() const;
/// EmitAbbreviations - Emit the abbreviation section.
///
void EmitAbbreviations() const;
/// EmitDebugLines - Emit source line information.
///
void EmitDebugLines() const;
/// EmitInitialDebugFrame - Emit common frame info into a debug frame section.
2006-02-27 13:43:29 +01:00
///
void EmitInitialDebugFrame();
/// EmitFunctionDebugFrame - Emit per function frame info into a debug frame
/// section.
void EmitFunctionDebugFrame();
2006-02-27 13:43:29 +01:00
/// EmitDebugPubNames - Emit info into a debug pubnames section.
///
void EmitDebugPubNames();
/// EmitDebugStr - Emit info into a debug str section.
///
void EmitDebugStr();
/// EmitDebugLoc - Emit info into a debug loc section.
///
void EmitDebugLoc();
/// EmitDebugARanges - Emit info into a debug aranges section.
///
void EmitDebugARanges();
/// EmitDebugRanges - Emit info into a debug ranges section.
///
void EmitDebugRanges();
/// EmitDebugMacInfo - Emit info into a debug macinfo section.
///
void EmitDebugMacInfo();
/// ConstructCompileUnitDIEs - Create a compile unit DIE for each source and
/// header file.
void ConstructCompileUnitDIEs();
/// ConstructGlobalDIEs - Create DIEs for each of the externally visible
/// global variables.
void ConstructGlobalDIEs();
2006-02-27 13:43:29 +01:00
/// ConstructSubprogramDIEs - Create DIEs for each of the externally visible
/// subprograms.
void ConstructSubprogramDIEs();
2006-02-27 13:43:29 +01:00
/// ShouldEmitDwarf - Returns true if Dwarf declarations should be made.
///
bool ShouldEmitDwarf() const { return shouldEmit; }
2006-02-27 13:43:29 +01:00
public:
DwarfWriter(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T);
2006-02-27 13:43:29 +01:00
virtual ~DwarfWriter();
// Accessors.
//
const TargetAsmInfo *getTargetAsmInfo() const { return TAI; }
2006-02-27 13:43:29 +01:00
/// SetDebugInfo - Set DebugInfo when it's known that pass manager has
/// created it. Set by the target AsmPrinter.
void SetDebugInfo(MachineDebugInfo *DI);
2006-02-27 13:43:29 +01:00
//===--------------------------------------------------------------------===//
// Main entry points.
//
/// BeginModule - Emit all Dwarf sections that should come prior to the
/// content.
void BeginModule(Module *M);
2006-02-27 13:43:29 +01:00
/// EndModule - Emit all Dwarf sections that should come after the content.
///
void EndModule();
2006-02-27 13:43:29 +01:00
/// BeginFunction - Gather pre-function debug information. Assumes being
/// emitted immediately after the function entry point.
void BeginFunction(MachineFunction *MF);
2006-02-27 13:43:29 +01:00
/// EndFunction - Gather and emit post-function debug information.
///
void EndFunction();
/// NonFunction - Function does not have a true body.
///
void NonFunction();
2006-02-27 13:43:29 +01:00
};
2005-12-21 20:46:32 +01:00
} // end llvm namespace
#endif