diff options
| -rw-r--r-- | include/llvm/CodeGen/DwarfWriter.h | 446 | ||||
| -rw-r--r-- | include/llvm/CodeGen/MachineDebugInfo.h | 144 | ||||
| -rw-r--r-- | lib/CodeGen/DwarfWriter.cpp | 1344 | ||||
| -rw-r--r-- | lib/CodeGen/MachineDebugInfo.cpp | 42 | ||||
| -rw-r--r-- | lib/CodeGen/SelectionDAG/LegalizeDAG.cpp | 2 | ||||
| -rw-r--r-- | lib/Target/PowerPC/PPCAsmPrinter.cpp | 14 |
6 files changed, 1787 insertions, 205 deletions
diff --git a/include/llvm/CodeGen/DwarfWriter.h b/include/llvm/CodeGen/DwarfWriter.h index 1a7c5a5..e178c91 100644 --- a/include/llvm/CodeGen/DwarfWriter.h +++ b/include/llvm/CodeGen/DwarfWriter.h @@ -7,14 +7,26 @@ // //===----------------------------------------------------------------------===// // -// This file contains support for writing dwarf debug info into asm files. +// 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. +// //===----------------------------------------------------------------------===// #ifndef LLVM_CODEGEN_DWARFPRINTER_H #define LLVM_CODEGEN_DWARFPRINTER_H +#include "llvm/ADT/UniqueVector.h" + #include <iosfwd> +#include <map> +#include <string> +#include <vector> + namespace llvm { @@ -23,6 +35,8 @@ namespace llvm { // reference manual http://dwarf.freestandards.org . // enum dwarf_constants { + DWARF_VERSION = 2, + // Tags DW_TAG_array_type = 0x01, DW_TAG_class_type = 0x02, @@ -425,23 +439,246 @@ namespace llvm { DW_CFA_hi_user = 0x3f }; + //===--------------------------------------------------------------------===// + // 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. + struct DWLabel { + const char *Tag; // Label category tag. Should always be + // a staticly declared C string. + unsigned Number; // Unique number + + DWLabel() : Tag(NULL), Number(0) {} + DWLabel(const char *T, unsigned N) : Tag(T), Number(N) {} + }; + + //===--------------------------------------------------------------------===// + // DIEAbbrev - Dwarf abbreviation, describes the organization of a debug + // information object. + // + class DIEAbbrev { + private: + const unsigned char *Data; // Static array of bytes containing the + // image of the raw abbreviation data. + + public: + + DIEAbbrev(const unsigned char *D) + : Data(D) + {} + + /// operator== - Used by UniqueVector to locate entry. + /// + bool operator==(const DIEAbbrev &DA) const { + return Data == DA.Data; + } + + /// operator< - Used by UniqueVector to locate entry. + /// + bool operator<(const DIEAbbrev &DA) const { + return Data < DA.Data; + } + + // Accessors + unsigned getTag() const { return Data[0]; } + unsigned getChildrenFlag() const { return Data[1]; } + unsigned getAttribute(unsigned i) const { return Data[2 + 2 * i + 0]; } + unsigned getForm(unsigned i) const { return Data[2 + 2 * i + 1]; } + }; + + //===--------------------------------------------------------------------===// + // DIEValue - A debug information entry value. + // + class DwarfWriter; + class DIEValue { + public: + enum { + isInteger, + isString, + isLabel, + isDelta + }; + + unsigned Type; // Type of the value + + DIEValue(unsigned T) : Type(T) {} + virtual ~DIEValue() {} + + // Implement isa/cast/dyncast. + static bool classof(const DIEValue *) { return true; } + + /// EmitValue - Emit value via the Dwarf writer. + /// + virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const = 0; + + /// SizeOf - Return the size of a value in bytes. + /// + virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const = 0; + }; + + //===--------------------------------------------------------------------===// + // DWInteger - An integer value DIE. + // + class DIEInteger : public DIEValue { + private: + int Value; + + public: + DIEInteger(int V) : DIEValue(isInteger), Value(V) {} + + // Implement isa/cast/dyncast. + static bool classof(const DIEInteger *) { return true; } + static bool classof(const DIEValue *V) { return V->Type == isInteger; } + + /// EmitValue - Emit integer of appropriate size. + /// + virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const; + + /// SizeOf - Determine size of integer value in bytes. + /// + virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const; + }; + + //===--------------------------------------------------------------------===// + // DIEString - A string value DIE. + // + struct DIEString : public DIEValue { + const std::string Value; + + DIEString(const std::string &V) : DIEValue(isString), Value(V) {} + + // Implement isa/cast/dyncast. + static bool classof(const DIEString *) { return true; } + static bool classof(const DIEValue *V) { return V->Type == isString; } + + /// EmitValue - Emit string value. + /// + virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const; + + /// SizeOf - Determine size of string value in bytes. + /// + virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const; + }; + + //===--------------------------------------------------------------------===// + // DIELabel - A simple label expression DIE. + // + struct DIELabel : public DIEValue { + const DWLabel Value; + + DIELabel(const DWLabel &V) : DIEValue(DW_FORM_ref4), Value(V) {} + + // Implement isa/cast/dyncast. + static bool classof(const DWLabel *) { return true; } + static bool classof(const DIEValue *V) { return V->Type == isLabel; } + + /// EmitValue - Emit label value. + /// + virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const; + + /// SizeOf - Determine size of label value in bytes. + /// + virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const; + }; + + //===--------------------------------------------------------------------===// + // DIEDelta - A simple label difference DIE. + // + struct DIEDelta : public DIEValue { + const DWLabel Value1; + const DWLabel Value2; + + DIEDelta(const DWLabel &V1, const DWLabel &V2) + : DIEValue(DW_FORM_addr), Value1(V1), Value2(V2) {} + + // Implement isa/cast/dyncast. + static bool classof(const DIEDelta *) { return true; } + static bool classof(const DIEValue *V) { return V->Type == isDelta; } + + /// EmitValue - Emit delta value. + /// + virtual void EmitValue(const DwarfWriter &DW, unsigned Form) const; + + /// SizeOf - Determine size of delta value in bytes. + /// + virtual unsigned SizeOf(const DwarfWriter &DW, unsigned Form) const; + }; + + //===--------------------------------------------------------------------===// + // DIE - A structured debug information entry. Has an abbreviation which + // describes it's organization. + class DIE { + private: + unsigned AbbrevID; // Decribing abbreviation ID. + unsigned Offset; // Offset in debug info section + unsigned Size; // Size of instance + children + std::vector<DIE *> Children; // Children DIEs + std::vector<DIEValue *> Values; // Attributes values + + public: + DIE(unsigned AbbrevID) + : AbbrevID(AbbrevID) + , Offset(0) + , Size(0) + , Children() + , Values() + {} + virtual ~DIE() { + } + + // Accessors + unsigned getAbbrevID() const { return AbbrevID; } + unsigned getOffset() const { return Offset; } + unsigned getSize() const { return Size; } + const std::vector<DIE *> &getChildren() const { return Children; } + const std::vector<DIEValue *> &getValues() const { return Values; } + void setOffset(unsigned O) { Offset = O; } + void setSize(unsigned S) { Size = S; } + + /// AddValue - Add an attribute value of appropriate type. + /// + void AddValue(int Value) { + Values.push_back(new DIEInteger(Value)); + } + void AddValue(const std::string &Value) { + Values.push_back(new DIEString(Value)); + } + void AddValue(const DWLabel &Value) { + Values.push_back(new DIELabel(Value)); + } + void AddValue(const DWLabel &Value1, const DWLabel &Value2) { + Values.push_back(new DIEDelta(Value1, Value2)); + } + + /// SiblingOffset - Return the offset of the debug information entry's + /// sibling. + unsigned SiblingOffset() const { return Offset + Size; } + }; + + //===--------------------------------------------------------------------===// // Forward declarations. // class AsmPrinter; class MachineDebugInfo; //===--------------------------------------------------------------------===// - // DwarfWriter - emits dwarf debug and exception handling directives. + // DwarfWriter - emits Dwarf debug and exception handling directives. // class DwarfWriter { protected: + //===------------------------------------------------------------------===// + // Core attributes used by the Dwarf writer. + // + + // /// O - Stream to .s file. /// std::ostream &O; - /// Asm - Target of dwarf emission. + /// Asm - Target of Dwarf emission. /// AsmPrinter *Asm; @@ -454,8 +691,25 @@ namespace llvm { bool didInitial; //===------------------------------------------------------------------===// + // 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<DIE *> CompileUnits; + + /// Abbreviations - A UniqueVector of TAG structure abbreviations. + /// + UniqueVector<DIEAbbrev> Abbreviations; + + //===------------------------------------------------------------------===// // Properties to be set by the derived class ctor, used to configure the - // dwarf writer. + // Dwarf writer. + // + + /// AddressSize - Size of addresses used in file. + /// + unsigned AddressSize; /// hasLEB128 - True if target asm supports leb128 directives. /// @@ -473,93 +727,174 @@ namespace llvm { /// directives. bool needsSet; /// Defaults to false. - /// DwarfAbbrevSection - section directive arg for dwarf abbrev. + /// DwarfAbbrevSection - Section directive for Dwarf abbrev. /// const char *DwarfAbbrevSection; /// Defaults to ".debug_abbrev". - /// DwarfInfoSection - section directive arg for dwarf info. + /// DwarfInfoSection - Section directive for Dwarf info. /// const char *DwarfInfoSection; /// Defaults to ".debug_info". - /// DwarfLineSection - section directive arg for dwarf info. + /// DwarfLineSection - Section directive for Dwarf info. /// const char *DwarfLineSection; /// Defaults to ".debug_line". + + /// TextSection - Section directive for standard text. + /// + const char *TextSection; /// Defaults to ".text". + + /// DataSection - Section directive for standard data. + /// + const char *DataSection; /// Defaults to ".data". //===------------------------------------------------------------------===// + // Emission and print routines + // - public: +public: + /// getAddressSize - Return the size of a target address in bytes. + /// + unsigned getAddressSize() const { return AddressSize; } + + /// 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; + + /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an + /// unsigned leb128 value. + void EmitULEB128Bytes(unsigned Value) const; - // Ctor. - DwarfWriter(std::ostream &o, AsmPrinter *ap) - : O(o) - , Asm(ap) - , DebugInfo(NULL) - , didInitial(false) - , hasLEB128(false) - , hasDotLoc(false) - , hasDotFile(false) - , needsSet(false) - , DwarfAbbrevSection(".debug_abbrev") - , DwarfInfoSection(".debug_info") - , DwarfLineSection(".debug_line") - {} + /// EmitSLEB128Bytes - print an assembler byte data directive to compose a + /// signed leb128 value. + void EmitSLEB128Bytes(int Value) const; - /// SetDebugInfo - Set DebugInfo at when it's know that pass manager - /// has created it. - void SetDebugInfo(MachineDebugInfo *di) { DebugInfo = di; } + /// 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); - /// EmitHex - Emit a hexidecimal string to the output stream. - /// - void EmitHex(unsigned Value) const; + /// PrintSLEB128 - Print a series of hexidecimal values (separated by + /// commas) representing a signed leb128 value. + void PrintSLEB128(int Value) const; - /// EmitComment - Emit a simple string comment. + /// SizeSLEB128 - Compute the number of bytes required for a signed leb128 + /// value. + static unsigned SizeSLEB128(int Value); + + /// EmitByte - Emit a byte directive and value. /// - void EmitComment(const char *Comment) const; + void EmitByte(int Value) const; - /// EmitULEB128 - Emit a series of hexidecimal values (separated by commas) - /// representing an unsigned leb128 value. + /// EmitShort - Emit a short directive and value. /// - void EmitULEB128(unsigned Value) const; + void EmitShort(int Value) const; - /// EmitSLEB128 - Emit a series of hexidecimal values (separated by commas) - /// representing a signed leb128 value. + /// EmitLong - Emit a long directive and value. /// - void EmitSLEB128(int Value) const; + void EmitLong(int Value) const; - /// EmitLabelName - Emit label name for internal use by dwarf. + /// EmitString - Emit a string with quotes and a null terminator. + /// Special characters are emitted properly. (Eg. '\t') + void DwarfWriter::EmitString(const std::string &String) const; + + /// PrintLabelName - Print label name in form used by Dwarf writer. /// - void EmitLabelName(const char *Tag, int Num) const; + 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. + /// EmitLabel - Emit location label for internal use by Dwarf. /// - void EmitLabel(const char *Tag, int Num) const; + void EmitLabel(DWLabel Label) const { + EmitLabel(Label.Tag, Label.Number); + } + void EmitLabel(const char *Tag, unsigned Number) const; - /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an - /// unsigned leb128 value. Comment is added to the end of the directive if - /// DwarfVerbose is true (should not contain any newlines.) + /// EmitLabelReference - Emit a reference to a label. + /// + void EmitLabelReference(DWLabel Label) const { + EmitLabelReference(Label.Tag, Label.Number); + } + void EmitLabelReference(const char *Tag, unsigned Number) 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 Label1, DWLabel Label2) const { + EmitDifference(Label1.Tag, Label1.Number, Label2.Tag, Label2.Number); + } + void EmitDifference(const char *Tag1, unsigned Number1, + const char *Tag2, unsigned Number2) const; + +private: + /// NewDIE - Construct a new structured debug information entry. + /// + DIE *NewDIE(const unsigned char *AbbrevData); + + /// NewCompileUnit - Create new compile unit information. + /// + DIE *NewCompileUnit(const std::string &Directory, + const std::string &SourceName); + + /// EmitInitial - Emit initial Dwarf declarations. /// - void EmitULEB128Bytes(unsigned Value, const char *Comment) const; + void EmitInitial() const; - /// EmitSLEB128Bytes - Emit an assembler byte data directive to compose a - /// signed leb128 value. Comment is added to the end of the directive if - /// DwarfVerbose is true (should not contain any newlines.) + /// EmitDIE - Recusively Emits a debug information entry. /// - void EmitSLEB128Bytes(int Value, const char *Comment) const; + void EmitDIE(DIE *Die) const; - /// EmitInitial - Emit initial dwarf declarations. + /// SizeAndOffsetDie - Compute the size and offset of a DIE. /// - void EmitInitial() const; + unsigned SizeAndOffsetDie(DIE *Die, unsigned Offset) const; + + /// SizeAndOffsets - Compute the size and offset of all the DIEs. + /// + void SizeAndOffsets(); - /// ShouldEmitDwarf - Returns true if dwarf declarations should be made. + /// 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; + + /// ShouldEmitDwarf - Returns true if Dwarf declarations should be made. /// When called it also checks to see if debug info is newly available. if - /// so the initial dwarf headers are emitted. + /// so the initial Dwarf headers are emitted. bool ShouldEmitDwarf(); - - /// BeginModule - Emit all dwarf sections that should come prior to the + + public: + + DwarfWriter(std::ostream &o, AsmPrinter *ap); + virtual ~DwarfWriter(); + + /// SetDebugInfo - Set DebugInfo when it's known that pass manager has + /// created it. Set by the target AsmPrinter. + void SetDebugInfo(MachineDebugInfo *di) { DebugInfo = di; } + + //===------------------------------------------------------------------===// + // Main enties. + // + + /// BeginModule - Emit all Dwarf sections that should come prior to the /// content. void BeginModule(); - /// EndModule - Emit all dwarf sections that should come after the content. + /// EndModule - Emit all Dwarf sections that should come after the content. /// void EndModule(); @@ -571,7 +906,6 @@ namespace llvm { /// void EndFunction(); }; - } // end llvm namespace diff --git a/include/llvm/CodeGen/MachineDebugInfo.h b/include/llvm/CodeGen/MachineDebugInfo.h index 039bdbc..5846748 100644 --- a/include/llvm/CodeGen/MachineDebugInfo.h +++ b/include/llvm/CodeGen/MachineDebugInfo.h @@ -10,17 +10,83 @@ // Collect debug information for a module. This information should be in a // neutral form that can be used by different debugging schemes. // +// The organization of information is primarily clustered around the source +// compile units. The main exception is source line coorespondence where +// inlining may interleave code from various compile units. +// +// The following information can be retrieved from the MachineDebugInfo. +// +// -- Source directories - Directories are uniqued based on their canonical +// string and assigned a sequential numeric ID (base 1.) A directory ID - 1 +// provides the index of directory information in a queried directory list. +// -- Source files - Files are also uniqued based on their name and directory +// ID. A file ID is sequential number (base 1.) A file ID - 1 provides the +// index of source information in a queried file list. +// -- Source line coorespondence - A vector of file ID, line#, column# triples. +// A DEBUG_LOCATION instruction is generated by the DAG Legalizer +// corresponding to each entry in the source line list. This allows a debug +// information emitter to generate labels to map code addressed to debug +// tables. +// //===----------------------------------------------------------------------===// #ifndef LLVM_CODEGEN_MACHINEDEBUGINFO_H #define LLVM_CODEGEN_MACHINEDEBUGINFO_H #include "llvm/Pass.h" +#include "llvm/ADT/UniqueVector.h" #include <string> -#include <map> -#include <vector> namespace llvm { + +//===----------------------------------------------------------------------===// +/// SourceLineInfo - This class is used to record source line correspondence. +/// +class SourceLineInfo { +private: + unsigned Line; // Source line number. + unsigned Column; // Source column. + unsigned SourceID; // Source ID number. + +public: + SourceLineInfo(unsigned L, unsigned C, unsigned S) + : Line(L), Column(C), SourceID(S) {} + + // Accessors + unsigned getLine() const { return Line; } + unsigned getColumn() const { return Column; } + unsigned getSourceID() const { return SourceID; } +}; + +//===----------------------------------------------------------------------===// +/// SourceFileInfo - This class is used to track source information. +/// +class SourceFileInfo { +private: + unsigned DirectoryID; // Directory ID number. + std::string Name; // File name (not including directory.) + +public: + SourceFileInfo(unsigned D, const std::string &N) : DirectoryID(D), Name(N) {} + + // Accessors + unsigned getDirectoryID() const { return DirectoryID; } + const std::string &getName() const { return Name; } + + /// operator== - Used by UniqueVector to locate entry. + /// + bool operator==(const SourceFileInfo &SI) const { + return getDirectoryID() == SI.getDirectoryID() && getName() == SI.getName(); + } + + /// operator< - Used by UniqueVector to locate entry. + /// + bool operator<(const SourceFileInfo &SI) const { + return getDirectoryID() < SI.getDirectoryID() || + (getDirectoryID() == SI.getDirectoryID() && getName() < SI.getName()); + } +}; + //===----------------------------------------------------------------------===// /// MachineDebugInfo - This class contains debug information specific to a /// module. Queries can be made by different debugging schemes and reformated @@ -28,48 +94,70 @@ namespace llvm { /// class MachineDebugInfo : public ImmutablePass { private: - std::map<std::string, unsigned> SourceMap; // Map of source file path to id - unsigned SourceCount; // Number of source files (used to - // generate id) - unsigned UniqueID; // Number used to unique labels used - // by debugger. + // DirectoryMap - UniqueVector for directories. + UniqueVector<std::string> Directories; + + // SourceMap - UniqueVector for source files. + UniqueVector<SourceFileInfo> SourceFiles; + + // Lines - List of of source line correspondence. + std::vector<SourceLineInfo *> Lines; public: - // Ctor. MachineDebugInfo() - : SourceMap() - , SourceCount(0) - , UniqueID(1) + : Directories() + , SourceFiles() + , Lines() {} ~MachineDebugInfo() { } - /// hasInfo - Returns true if debug info is present. + /// doInitialization - Initialize the debug state for a new module. /// - // FIXME - need scheme to suppress debug output. - bool hasInfo() const { return SourceCount != 0; } + bool doInitialization(); + - /// getNextUniqueID - Returns a unique number for labels used by debugger. + /// doFinalization - Tear down the debug state after completion of a module. /// - unsigned getNextUniqueID() { return UniqueID++; } + bool doFinalization(); + + /// hasInfo - Returns true if debug info is present. + /// + // FIXME - need proper scheme to suppress debug output. + bool hasInfo() const { return !SourceFiles.empty(); } /// RecordLabel - Records location information and associates it with a - /// debug label. Returns unique label id. - unsigned RecordLabel(unsigned Line, unsigned Col, unsigned SrcFile) { - // FIXME - actually record. - return getNextUniqueID(); + /// debug label. Returns a unique label ID used to generate a label and + /// provide correspondence to the source line list. + unsigned RecordLabel(unsigned Line, unsigned Column, unsigned Source) { + Lines.push_back(new SourceLineInfo(Line, Column, Source)); + return Lines.size(); } - bool doInitialization(); - bool doFinalization(); + /// RecordSource - Register a source file with debug info. Returns an source + /// ID. + unsigned RecordSource(const std::string &Directory, + const std::string &Source) { + unsigned DirectoryID = Directories.insert(Directory); + return SourceFiles.insert(SourceFileInfo(DirectoryID, Source)); + } - /// getUniqueSourceID - Register a source file with debug info. Returns an id. - /// - unsigned getUniqueSourceID(const std::string &fname, - const std::string &dirname); + /// getDirectories - Return the UniqueVector of std::string representing + /// directories. + const UniqueVector<std::string> &getDirectories() const { + return Directories; + } - /// getSourceFiles - Return a vector of files. Vector index + 1 equals id. + /// getSourceFiles - Return the UniqueVector of source files. /// - std::vector<std::string> getSourceFiles() const; + const UniqueVector<SourceFileInfo> &getSourceFiles() const { + return SourceFiles; + } + + /// getSourceLines - Return a vector of source lines. Vector index + 1 + /// equals label ID. + const std::vector<SourceLineInfo *> &getSourceLines() const { + return Lines; + } }; // End class MachineDebugInfo diff --git a/lib/CodeGen/DwarfWriter.cpp b/lib/CodeGen/DwarfWriter.cpp index b44b1aa..67a6464 100644 --- a/lib/CodeGen/DwarfWriter.cpp +++ b/lib/CodeGen/DwarfWriter.cpp @@ -13,6 +13,7 @@ #include "llvm/CodeGen/DwarfWriter.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/MachineDebugInfo.h" #include "llvm/Support/CommandLine.h" @@ -23,90 +24,776 @@ using namespace llvm; static cl::opt<bool> DwarfVerbose("dwarf-verbose", cl::Hidden, - cl::desc("Add comments to dwarf directives.")); + cl::desc("Add comments to Dwarf directives.")); -/// EmitULEB128Bytes - Emit an assembler byte data directive to compose an -/// unsigned leb128 value. Comment is added to the end of the directive if -/// DwarfVerbose is true (should not contain any newlines.) +//===----------------------------------------------------------------------===// +// Dwarf abbreviations used by this emitter. +// + +static const unsigned char AbbrevTAG_compile_unit[] = { + DW_TAG_compile_unit, DW_CHILDREN_yes, + DW_AT_stmt_list, DW_FORM_data4, + DW_AT_high_pc, DW_FORM_addr, + DW_AT_low_pc, DW_FORM_addr, + DW_AT_producer, DW_FORM_string, + DW_AT_language, DW_FORM_data1, + DW_AT_name, DW_FORM_string, + DW_AT_comp_dir, DW_FORM_string, + 0, 0 +}; + +static const unsigned char AbbrevTAG_subprogram[] = { + DW_TAG_subprogram, DW_CHILDREN_yes, + DW_AT_sibling, DW_FORM_ref4, + DW_AT_external, DW_FORM_flag, + DW_AT_name, DW_FORM_string, + DW_AT_decl_file, DW_FORM_data1, + DW_AT_decl_line, DW_FORM_data1, + DW_AT_prototyped, DW_FORM_flag, + DW_AT_type, DW_FORM_ref4, + DW_AT_low_pc, DW_FORM_addr, + DW_AT_high_pc, DW_FORM_addr, + DW_AT_frame_base, DW_FORM_block1, + 0, 0 +}; + +static const unsigned char AbbrevTAG_formal_parameter[] = { + DW_TAG_formal_parameter, DW_CHILDREN_no, + DW_AT_name, DW_FORM_string, + DW_AT_decl_file, DW_FORM_data1, + DW_AT_decl_line, DW_FORM_data1, + DW_AT_type, DW_FORM_ref4, + DW_AT_location, DW_FORM_block1, + 0, 0 +}; + +static const unsigned char AbbrevTAG_base_type[] = { + DW_TAG_base_type, DW_CHILDREN_no, + DW_AT_name, DW_FORM_string, + DW_AT_byte_size, DW_FORM_data1, + DW_AT_encoding, DW_FORM_data1, + 0, 0 +}; + +static const unsigned char AbbrevTAG_pointer_type[] = { + DW_TAG_pointer_type, DW_CHILDREN_no, + DW_AT_byte_size, DW_FORM_data1, + DW_AT_type, DW_FORM_ref4, + 0, 0 +}; + +static const unsigned char AbbrevTAG_array_type[] = { + DW_TAG_array_type, DW_CHILDREN_yes, + DW_AT_sibling, DW_FORM_ref4, + DW_AT_type, DW_FORM_ref4, + 0, 0 +}; + +static const unsigned char AbbrevTAG_subrange_type[] = { + DW_TAG_subrange_type, DW_CHILDREN_no, + 0, 0 +}; + +static const unsigned char AbbrevTAG_variable[] = { + DW_TAG_variable, DW_CHILDREN_no, + DW_AT_name, DW_FORM_string, + DW_AT_type, DW_FORM_ref4, + DW_AT_external, DW_FORM_flag, + DW_AT_artificial, DW_FORM_flag, + DW_AT_declaration, DW_FORM_flag, + 0, 0 +}; + +//===----------------------------------------------------------------------===// + +/// TagString - Return the string for the specified tag. /// -void DwarfWriter::EmitULEB128Bytes(unsigned Value, const char *Comment) const { - if (hasLEB128) { - O << "\t.uleb128\t" - << Value; - } else { - O << Asm->Data8bitsDirective; - EmitULEB128(Value); +static const char *TagString(unsigned Tag) { + switch(Tag) { + case DW_TAG_array_type: return "TAG_array_type"; + case DW_TAG_class_type: return "TAG_class_type"; + case DW_TAG_entry_point: return "TAG_entry_point"; + case DW_TAG_enumeration_type: return "TAG_enumeration_type"; + case DW_TAG_formal_parameter: return "TAG_formal_parameter"; + case DW_TAG_imported_declaration: return "TAG_imported_declaration"; + case DW_TAG_label: return "TAG_label"; + case DW_TAG_lexical_block: return "TAG_lexical_block"; + case DW_TAG_member: return "TAG_member"; + case DW_TAG_pointer_type: return "TAG_pointer_type"; + case DW_TAG_reference_type: return "TAG_reference_type"; + case DW_TAG_compile_unit: return "TAG_compile_unit"; + case DW_TAG_string_type: return "TAG_string_type"; + case DW_TAG_structure_type: return "TAG_structure_type"; + case DW_TAG_subroutine_type: return "TAG_subroutine_type"; + case DW_TAG_typedef: return "TAG_typedef"; + case DW_TAG_union_type: return "TAG_union_type"; + case DW_TAG_unspecified_parameters: return "TAG_unspecified_parameters"; + case DW_TAG_variant: return "TAG_variant"; + case DW_TAG_common_block: return "TAG_common_block"; + case DW_TAG_common_inclusion: return "TAG_common_inclusion"; + case DW_TAG_inheritance: return "TAG_inheritance"; + case DW_TAG_inlined_subroutine: return "TAG_inlined_subroutine"; + case DW_TAG_module: return "TAG_module"; + case DW_TAG_ptr_to_member_type: return "TAG_ptr_to_member_type"; + case DW_TAG_set_type: return "TAG_set_type"; + case DW_TAG_subrange_type: return "TAG_subrange_type"; + case DW_TAG_with_stmt: return "TAG_with_stmt"; + case DW_TAG_access_declaration: return "TAG_access_declaration"; + case DW_TAG_base_type: return "TAG_base_type"; + case DW_TAG_catch_block: return "TAG_catch_block"; + case DW_TAG_const_type: return "TAG_const_type"; + case DW_TAG_constant: return "TAG_constant"; + case DW_TAG_enumerator: return "TAG_enumerator"; + case DW_TAG_file_type: return "TAG_file_type"; + case DW_TAG_friend: return "TAG_friend"; + case DW_TAG_namelist: return "TAG_namelist"; + case DW_TAG_namelist_item: return "TAG_namelist_item"; + case DW_TAG_packed_type: return "TAG_packed_type"; + case DW_TAG_subprogram: return "TAG_subprogram"; + case DW_TAG_template_type_parameter: return "TAG_template_type_parameter"; + case DW_TAG_template_value_parameter: return "TAG_template_value_parameter"; + case DW_TAG_thrown_type: return "TAG_thrown_type"; + case DW_TAG_try_block: return "TAG_try_block"; + case DW_TAG_variant_part: return "TAG_variant_part"; + case DW_TAG_variable: return "TAG_variable"; + case DW_TAG_volatile_type: return "TAG_volatile_type"; + case DW_TAG_dwarf_procedure: return "TAG_dwarf_procedure"; + case DW_TAG_restrict_type: return "TAG_restrict_type"; + case DW_TAG_interface_type: return "TAG_interface_type"; + case DW_TAG_namespace: return "TAG_namespace"; + case DW_TAG_imported_module: return "TAG_imported_module"; + case DW_TAG_unspecified_type: return "TAG_unspecified_type"; + case DW_TAG_partial_unit: return "TAG_partial_unit"; + case DW_TAG_imported_unit: return "TAG_imported_unit"; + case DW_TAG_condition: return "TAG_condition"; + case DW_TAG_shared_type: return "TAG_shared_type"; + case DW_TAG_lo_user: return "TAG_lo_user"; + case DW_TAG_hi_user: return "TAG_hi_user"; } - if (DwarfVerbose) { - O << "\t" - << Asm->CommentString - << " " - << Comment - << " " - << Value; + assert(0 && "Unknown Dwarf Tag"); + return ""; +} + +/// ChildrenString - Return the string for the specified children flag. +/// +static const char *ChildrenString(unsigned Children) { + switch(Children) { + case DW_CHILDREN_no: return "CHILDREN_no"; + case DW_CHILDREN_yes: return "CHILDREN_yes"; } - O << "\n"; + assert(0 && "Unknown Dwarf ChildrenFlag"); + return ""; } -/// EmitSLEB128Bytes - Emit an assembler byte data directive to compose a -/// signed leb128 value. Comment is added to the end of the directive if -/// DwarfVerbose is true (should not contain any newlines.) +/// AttributeString - Return the string for the specified attribute. /// -void DwarfWriter::EmitSLEB128Bytes(int Value, const char *Comment) const { - if (hasLEB128) { - O << "\t.sleb128\t" - << Value; - } else { - O << Asm->Data8bitsDirective; - EmitSLEB128(Value); +static const char *AttributeString(unsigned Attribute) { + switch(Attribute) { + case DW_AT_sibling: return "AT_sibling"; + case DW_AT_location: return "AT_location"; + case DW_AT_name: return "AT_name"; + case DW_AT_ordering: return "AT_ordering"; + case DW_AT_byte_size: return "AT_byte_size"; + case DW_AT_bit_offset: return "AT_bit_offset"; + case DW_AT_bit_size: return "AT_bit_size"; + case DW_AT_stmt_list: return "AT_stmt_list"; + case DW_AT_low_pc: return "AT_low_pc"; + case DW_AT_high_pc: return "AT_high_pc"; + case DW_AT_language: return "AT_language"; + case DW_AT_discr: return "AT_discr"; + case DW_AT_discr_value: return "AT_discr_value"; + case DW_AT_visibility: return "AT_visibility"; + case DW_AT_import: return "AT_import"; + case DW_AT_string_length: return "AT_string_length"; + case DW_AT_common_reference: return "AT_common_reference"; + case DW_AT_comp_dir: return "AT_comp_dir"; + case DW_AT_const_value: return "AT_const_value"; + case DW_AT_containing_type: return "AT_containing_type"; + case DW_AT_default_value: return "AT_default_value"; + case DW_AT_inline: return "AT_inline"; + case DW_AT_is_optional: return "AT_is_optional"; + case DW_AT_lower_bound: return "AT_lower_bound"; + case DW_AT_producer: return "AT_producer"; + case DW_AT_prototyped: return "AT_prototyped"; + case DW_AT_return_addr: return "AT_return_addr"; + case DW_AT_start_scope: return "AT_start_scope"; + case DW_AT_bit_stride: return "AT_bit_stride"; + case DW_AT_upper_bound: return "AT_upper_bound"; + case DW_AT_abstract_origin: return "AT_abstract_origin"; + case DW_AT_accessibility: return "AT_accessibility"; + case DW_AT_address_class: return "AT_address_class"; + case DW_AT_artificial: return "AT_artificial"; + case DW_AT_base_types: return "AT_base_types"; + case DW_AT_calling_convention: return "AT_calling_convention"; + case DW_AT_count: return "AT_count"; + case DW_AT_data_member_location: return "AT_data_member_location"; + case DW_AT_decl_column: return "AT_decl_column"; + case DW_AT_decl_file: return "AT_decl_file"; + case DW_AT_decl_line: return "AT_decl_line"; + case DW_AT_declaration: return "AT_declaration"; + case DW_AT_discr_list: return "AT_discr_list"; + case DW_AT_encoding: return "AT_encoding"; + case DW_AT_external: return "AT_external"; + case DW_AT_frame_base: return "AT_frame_base"; + case DW_AT_friend: return "AT_friend"; + case DW_AT_identifier_case: return "AT_identifier_case"; + case DW_AT_macro_info: return "AT_macro_info"; + case DW_AT_namelist_item: return "AT_namelist_item"; + case DW_AT_priority: return "AT_priority"; + case DW_AT_segment: return "AT_segment"; + case DW_AT_specification: return "AT_specification"; + case DW_AT_static_link: return "AT_static_link"; + case DW_AT_type: return "AT_type"; + case DW_AT_use_location: return "AT_use_location"; + case DW_AT_variable_parameter: return "AT_variable_parameter"; + case DW_AT_virtuality: return "AT_virtuality"; + case DW_AT_vtable_elem_location: return "AT_vtable_elem_location"; + case DW_AT_allocated: return "AT_allocated"; + case DW_AT_associated: return "AT_associated"; + case DW_AT_data_location: return "AT_data_location"; + case DW_AT_byte_stride: return "AT_byte_stride"; + case DW_AT_entry_pc: return "AT_entry_pc"; + case DW_AT_use_UTF8: return "AT_use_UTF8"; + case DW_AT_extension: return "AT_extension"; + case DW_AT_ranges: return "AT_ranges"; + case DW_AT_trampoline: return "AT_trampoline"; + case DW_AT_call_column: return "AT_call_column"; + case DW_AT_call_file: return "AT_call_file"; + case DW_AT_call_line: return "AT_call_line"; + case DW_AT_description: return "AT_description"; + case DW_AT_binary_scale: return "AT_binary_scale"; + case DW_AT_decimal_scale: return "AT_decimal_scale"; + case DW_AT_small: return "AT_small"; + case DW_AT_decimal_sign: return "AT_decimal_sign"; + case DW_AT_digit_count: return "AT_digit_count"; + case DW_AT_picture_string: return "AT_picture_string"; + case DW_AT_mutable: return "AT_mutable"; + case DW_AT_threads_scaled: return "AT_threads_scaled"; + case DW_AT_explicit: return "AT_explicit"; + case DW_AT_object_pointer: return "AT_object_pointer"; + case DW_AT_endianity: return "AT_endianity"; + case DW_AT_elemental: return "AT_elemental"; + case DW_AT_pure: return "AT_pure"; + case DW_AT_recursive: return "AT_recursive"; + case DW_AT_lo_user: return "AT_lo_user"; + case DW_AT_hi_user: return "AT_hi_user"; + } + assert(0 && "Unknown Dwarf Attribute"); + return ""; +} + +/// FormEncodingString - Return the string for the specified form encoding. +/// +static const char *FormEncodingString(unsigned Encoding) { + switch(Encoding) { + case DW_FORM_addr: return "FORM_addr"; + case DW_FORM_block2: return "FORM_block2"; + case DW_FORM_block4: return "FORM_block4"; + case DW_FORM_data2: return "FORM_data2"; + case DW_FORM_data4: return "FORM_data4"; + case DW_FORM_data8: return "FORM_data8"; + case DW_FORM_string: return "FORM_string"; + case DW_FORM_block: return "FORM_block"; + case DW_FORM_block1: return "FORM_block1"; + case DW_FORM_data1: return "FORM_data1"; + case DW_FORM_flag: return "FORM_flag"; + case DW_FORM_sdata: return "FORM_sdata"; + case DW_FORM_strp: return "FORM_strp"; + case DW_FORM_udata: return "FORM_udata"; + case DW_FORM_ref_addr: return "FORM_ref_addr"; + case DW_FORM_ref1: return "FORM_ref1"; + case DW_FORM_ref2: return "FORM_ref2"; + case DW_FORM_ref4: return "FORM_ref4"; + case DW_FORM_ref8: return "FORM_ref8"; + case DW_FORM_ref_udata: return "FORM_ref_udata"; + case DW_FORM_indirect: return "FORM_indirect"; + } + assert(0 && "Unknown Dwarf Form Encoding"); + return ""; +} + +/// OperationEncodingString - Return the string for the specified operation +/// encoding. +static const char *OperationEncodingString(unsigned Encoding) { + switch(Encoding) { + case DW_OP_addr: return "OP_addr"; + case DW_OP_deref: return "OP_deref"; + case DW_OP_const1u: return "OP_const1u"; + case DW_OP_const1s: return "OP_const1s"; + case DW_OP_const2u: return "OP_const2u"; + case DW_OP_const2s: return "OP_const2s"; + case DW_OP_const4u: return "OP_const4u"; + case DW_OP_const4s: return "OP_const4s"; + case DW_OP_const8u: return "OP_const8u"; + case DW_OP_const8s: return "OP_const8s"; + case DW_OP_constu: return "OP_constu"; + case DW_OP_consts: return "OP_consts"; + case DW_OP_dup: return "OP_dup"; + case DW_OP_drop: return "OP_drop"; + case DW_OP_over: return "OP_over"; + case DW_OP_pick: return "OP_pick"; + case DW_OP_swap: return "OP_swap"; + case DW_OP_rot: return "OP_rot"; + case DW_OP_xderef: return "OP_xderef"; + case DW_OP_abs: return "OP_abs"; + case DW_OP_and: return "OP_and"; + case DW_OP_div: return "OP_div"; + case DW_OP_minus: return "OP_minus"; + case DW_OP_mod: return "OP_mod"; + case DW_OP_mul: return "OP_mul"; + case DW_OP_neg: return "OP_neg"; + case DW_OP_not: return "OP_not"; + case DW_OP_or: return "OP_or"; + case DW_OP_plus: return "OP_plus"; + case DW_OP_plus_uconst: return "OP_plus_uconst"; + case DW_OP_shl: return "OP_shl"; + case DW_OP_shr: return "OP_shr"; + case DW_OP_shra: return "OP_shra"; + case DW_OP_xor: return "OP_xor"; + case DW_OP_skip: return "OP_skip"; + case DW_OP_bra: return "OP_bra"; + case DW_OP_eq: return "OP_eq"; + case DW_OP_ge: return "OP_ge"; + case DW_OP_gt: return "OP_gt"; + case DW_OP_le: return "OP_le"; + case DW_OP_lt: return "OP_lt"; + case DW_OP_ne: return "OP_ne"; + case DW_OP_lit0: return "OP_lit0"; + case DW_OP_lit1: return "OP_lit1"; + case DW_OP_lit31: return "OP_lit31"; + case DW_OP_reg0: return "OP_reg0"; + case DW_OP_reg1: return "OP_reg1"; + case DW_OP_reg31: return "OP_reg31"; + case DW_OP_breg0: return "OP_breg0"; + case DW_OP_breg1: return "OP_breg1"; + case DW_OP_breg31: return "OP_breg31"; + case DW_OP_regx: return "OP_regx"; + case DW_OP_fbreg: return "OP_fbreg"; + case DW_OP_bregx: return "OP_bregx"; + case DW_OP_piece: return "OP_piece"; + case DW_OP_deref_size: return "OP_deref_size"; + case DW_OP_xderef_size: return "OP_xderef_size"; + case DW_OP_nop: return "OP_nop"; + case DW_OP_push_object_address: return "OP_push_object_address"; + case DW_OP_call2: return "OP_call2"; + case DW_OP_call4: return "OP_call4"; + case DW_OP_call_ref: return "OP_call_ref"; + case DW_OP_form_tls_address: return "OP_form_tls_address"; + case DW_OP_call_frame_cfa: return "OP_call_frame_cfa"; + case DW_OP_lo_user: return "OP_lo_user"; + case DW_OP_hi_user: return "OP_hi_user"; + } + assert(0 && "Unknown Dwarf Operation Encoding"); + return ""; +} + +/// AttributeEncodingString - Return the string for the specified attribute +/// encoding. +static const char *AttributeEncodingString(unsigned Encoding) { + switch(Encoding) { + case DW_ATE_address: return "ATE_address"; + case DW_ATE_boolean: return "ATE_boolean"; + case DW_ATE_complex_float: return "ATE_complex_float"; + case DW_ATE_float: return "ATE_float"; + case DW_ATE_signed: return "ATE_signed"; + case DW_ATE_signed_char: return "ATE_signed_char"; + case DW_ATE_unsigned: return "ATE_unsigned"; + case DW_ATE_unsigned_char: return "ATE_unsigned_char"; + case DW_ATE_imaginary_float: return "ATE_imaginary_float"; + case DW_ATE_packed_decimal: return "ATE_packed_decimal"; + case DW_ATE_numeric_string: return "ATE_numeric_string"; + case DW_ATE_edited: return "ATE_edited"; + case DW_ATE_signed_fixed: return "ATE_signed_fixed"; + case DW_ATE_unsigned_fixed: return "ATE_unsigned_fixed"; + case DW_ATE_decimal_float: return "ATE_decimal_float"; + case DW_ATE_lo_user: return "ATE_lo_user"; + case DW_ATE_hi_user: return "ATE_hi_user"; + } + assert(0 && "Unknown Dwarf Attribute Encoding"); + return ""; +} + +/// DecimalSignString - Return the string for the specified decimal sign +/// attribute. +static const char *DecimalSignString(unsigned Sign) { + switch(Sign) { + case DW_DS_unsigned: return "DS_unsigned"; + case DW_DS_leading_overpunch: return "DS_leading_overpunch"; + case DW_DS_trailing_overpunch: return "DS_trailing_overpunch"; + case DW_DS_leading_separate: return "DS_leading_separate"; + case DW_DS_trailing_separate: return "DS_trailing_separate"; + } + assert(0 && "Unknown Dwarf Decimal Sign Attribute"); + return ""; +} + +/// EndianityString - Return the string for the specified endianity. +/// +static const char *EndianityString(unsigned Endian) { + switch(Endian) { + case DW_END_default: return "END_default"; + case DW_END_big: return "END_big"; + case DW_END_little: return "END_little"; + case DW_END_lo_user: return "END_lo_user"; + case DW_END_hi_user: return "END_hi_user"; + } + assert(0 && "Unknown Dwarf Endianity"); + return ""; +} + +/// AccessibilityString - Return the string for the specified accessibility. +/// +static const char *AccessibilityString(unsigned Access) { + switch(Access) { + // Accessibility codes + case DW_ACCESS_public: return "ACCESS_public"; + case DW_ACCESS_protected: return "ACCESS_protected"; + case DW_ACCESS_private: return "ACCESS_private"; + } + assert(0 && "Unknown Dwarf Accessibility"); + return ""; +} + +/// VisibilityString - Return the string for the specified visibility. +/// +static const char *VisibilityString(unsigned Visibility) { + switch(Visibility) { + case DW_VIS_local: return "VIS_local"; + case DW_VIS_exported: return "VIS_exported"; + case DW_VIS_qualified: return "VIS_qualified"; + } + assert(0 && "Unknown Dwarf Visibility"); + return ""; +} + +/// VirtualityString - Return the string for the specified virtuality. +/// +static const char *VirtualityString(unsigned Virtuality) { + switch(Virtuality) { + case DW_VIRTUALITY_none: return "VIRTUALITY_none"; + case DW_VIRTUALITY_virtual: return "VIRTUALITY_virtual"; + case DW_VIRTUALITY_pure_virtual: return "VIRTUALITY_pure_virtual"; + } + assert(0 && "Unknown Dwarf Virtuality"); + return ""; +} + +/// LanguageString - Return the string for the specified language. +/// +static const char *LanguageString(unsigned Language) { + switch(Language) { + case DW_LANG_C89: return "LANG_C89"; + case DW_LANG_C: return "LANG_C"; + case DW_LANG_Ada83: return "LANG_Ada83"; + case DW_LANG_C_plus_plus: return "LANG_C_plus_plus"; + case DW_LANG_Cobol74: return "LANG_Cobol74"; + case DW_LANG_Cobol85: return "LANG_Cobol85"; + case DW_LANG_Fortran77: return "LANG_Fortran77"; + case DW_LANG_Fortran90: return "LANG_Fortran90"; + case DW_LANG_Pascal83: return "LANG_Pascal83"; + case DW_LANG_Modula2: return "LANG_Modula2"; + case DW_LANG_Java: return "LANG_Java"; + case DW_LANG_C99: return "LANG_C99"; + case DW_LANG_Ada95: return "LANG_Ada95"; + case DW_LANG_Fortran95: return "LANG_Fortran95"; + case DW_LANG_PLI: return "LANG_PLI"; + case DW_LANG_ObjC: return "LANG_ObjC"; + case DW_LANG_ObjC_plus_plus: return "LANG_ObjC_plus_plus"; + case DW_LANG_UPC: return "LANG_UPC"; + case DW_LANG_D: return "LANG_D"; + case DW_LANG_lo_user: return "LANG_lo_user"; + case DW_LANG_hi_user: return "LANG_hi_user"; + } + assert(0 && "Unknown Dwarf Language"); + return ""; +} + +/// CaseString - Return the string for the specified identifier case. +/// +static const char *CaseString(unsigned Case) { + switch(Case) { + case DW_ID_case_sensitive: return "ID_case_sensitive"; + case DW_ID_up_case: return "ID_up_case"; + case DW_ID_down_case: return "ID_down_case"; + case DW_ID_case_insensitive: return "ID_case_insensitive"; + } + assert(0 && "Unknown Dwarf Identifier Case"); + return ""; +} + +/// ConventionString - Return the string for the specified calling convention. +/// +static const char *ConventionString(unsigned Convention) { + switch(Convention) { + case DW_CC_normal: return "CC_normal"; + case DW_CC_program: return "CC_program"; + case DW_CC_nocall: return "CC_nocall"; + case DW_CC_lo_user: return "CC_lo_user"; + case DW_CC_hi_user: return "CC_hi_user"; + } + assert(0 && "Unknown Dwarf Calling Convention"); + return ""; +} + +/// InlineCodeString - Return the string for the specified inline code. +/// +static const char *InlineCodeString(unsigned Code) { + switch(Code) { + case DW_INL_not_inlined: return "INL_not_inlined"; + case DW_INL_inlined: return "INL_inlined"; + case DW_INL_declared_not_inlined: return "INL_declared_not_inlined"; + case DW_INL_declared_inlined: return "INL_declared_inlined"; + } + assert(0 && "Unknown Dwarf Inline Code"); + return ""; +} + +/// ArrayOrderString - Return the string for the specified array order. +/// +static const char *ArrayOrderString(unsigned Order) { + switch(Order) { + case DW_ORD_row_major: return "ORD_row_major"; + case DW_ORD_col_major: return "ORD_col_major"; + } + assert(0 && "Unknown Dwarf Array Order"); + return ""; +} + +/// DiscriminantString - Return the string for the specified discriminant +/// descriptor. +static const char *DiscriminantString(unsigned Discriminant) { + switch(Discriminant) { + case DW_DSC_label: return "DSC_label"; + case DW_DSC_range: return "DSC_range"; + } + assert(0 && "Unknown Dwarf Discriminant Descriptor"); + return ""; +} + +/// LNStandardString - Return the string for the specified line number standard. +/// +static const char *LNStandardString(unsigned Standard) { + switch(Standard) { + case DW_LNS_copy: return "LNS_copy"; + case DW_LNS_advance_pc: return "LNS_advance_pc"; + case DW_LNS_advance_line: return "LNS_advance_line"; + case DW_LNS_set_file: return "LNS_set_file"; + case DW_LNS_set_column: return "LNS_set_column"; + case DW_LNS_negate_stmt: return "LNS_negate_stmt"; + case DW_LNS_set_basic_block: return "LNS_set_basic_block"; + case DW_LNS_const_add_pc: return "LNS_const_add_pc"; + case DW_LNS_fixed_advance_pc: return "LNS_fixed_advance_pc"; + case DW_LNS_set_prologue_end: return "LNS_set_prologue_end"; + case DW_LNS_set_epilogue_begin: return "LNS_set_epilogue_begin"; + case DW_LNS_set_isa: return "LNS_set_isa"; + } + assert(0 && "Unknown Dwarf Line Number Standard"); + return ""; +} + +/// LNExtendedString - Return the string for the specified line number extended +/// opcode encodings. +static const char *LNExtendedString(unsigned Encoding) { + switch(Encoding) { + // Line Number Extended Opcode Encodings + case DW_LNE_end_sequence: return "LNE_end_sequence"; + case DW_LNE_set_address: return "LNE_set_address"; + case DW_LNE_define_file: return "LNE_define_file"; + case DW_LNE_lo_user: return "LNE_lo_user"; + case DW_LNE_hi_user: return "LNE_hi_user"; + } + assert(0 && "Unknown Dwarf Line Number Extended Opcode Encoding"); + return ""; +} + +/// MacinfoString - Return the string for the specified macinfo type encodings. +/// +static const char *MacinfoString(unsigned Encoding) { + switch(Encoding) { + // Macinfo Type Encodings + case DW_MACINFO_define: return "MACINFO_define"; + case DW_MACINFO_undef: return "MACINFO_undef"; + case DW_MACINFO_start_file: return "MACINFO_start_file"; + case DW_MACINFO_end_file: return "MACINFO_end_file"; + case DW_MACINFO_vendor_ext: return "MACINFO_vendor_ext"; + } + assert(0 && "Unknown Dwarf Macinfo Type Encodings"); + return ""; +} + +/// CallFrameString - Return the string for the specified call frame instruction +/// encodings. +static const char *CallFrameString(unsigned Encoding) { + switch(Encoding) { + case DW_CFA_advance_loc: return "CFA_advance_loc"; + case DW_CFA_offset: return "CFA_offset"; + case DW_CFA_restore: return "CFA_restore"; + case DW_CFA_set_loc: return "CFA_set_loc"; + case DW_CFA_advance_loc1: return "CFA_advance_loc1"; + case DW_CFA_advance_loc2: return "CFA_advance_loc2"; + case DW_CFA_advance_loc4: return "CFA_advance_loc4"; + case DW_CFA_offset_extended: return "CFA_offset_extended"; + case DW_CFA_restore_extended: return "CFA_restore_extended"; + case DW_CFA_undefined: return "CFA_undefined"; + case DW_CFA_same_value: return "CFA_same_value"; + case DW_CFA_register: return "CFA_register"; + case DW_CFA_remember_state: return "CFA_remember_state"; + case DW_CFA_restore_state: return "CFA_restore_state"; + case DW_CFA_def_cfa: return "CFA_def_cfa"; + case DW_CFA_def_cfa_register: return "CFA_def_cfa_register"; + case DW_CFA_def_cfa_offset: return "CFA_def_cfa_offset"; + case DW_CFA_def_cfa_expression: return "CFA_def_cfa_expression"; + case DW_CFA_expression: return "CFA_expression"; + case DW_CFA_offset_extended_sf: return "CFA_offset_extended_sf"; + case DW_CFA_def_cfa_sf: return "CFA_def_cfa_sf"; + case DW_CFA_def_cfa_offset_sf: return "CFA_def_cfa_offset_sf"; + case DW_CFA_val_offset: return "CFA_val_offset"; + case DW_CFA_val_offset_sf: return "CFA_val_offset_sf"; + case DW_CFA_val_expression: return "CFA_val_expression"; + case DW_CFA_lo_user: return "CFA_lo_user"; + case DW_CFA_hi_user: return "CFA_hi_user"; + } + assert(0 && "Unknown Dwarf Call Frame Instruction Encodings"); + return ""; +} + +//===----------------------------------------------------------------------===// + +/// EmitValue - Emit integer of appropriate size. +/// +void DIEInteger::EmitValue(const DwarfWriter &DW, unsigned Form) const { + switch (Form) { + case DW_FORM_data1: DW.EmitByte(Value); break; + case DW_FORM_data2: DW.EmitShort(Value); break; + case DW_FORM_data4: DW.EmitLong(Value); break; + default: assert(0 && "DIE Value form not supported yet"); break; } +} + +/// SizeOf - Determine size of integer value in bytes. +/// +unsigned DIEInteger::SizeOf(const DwarfWriter &DW, unsigned Form) const { + switch (Form) { + case DW_FORM_data1: return sizeof(int8_t); + case DW_FORM_data2: return sizeof(int16_t); + case DW_FORM_data4: return sizeof(int32_t); + default: assert(0 && "DIE Value form not supported yet"); break; + } + return 0; +} + +//===----------------------------------------------------------------------===// + +/// EmitValue - Emit string value. +/// +void DIEString::EmitValue(const DwarfWriter &DW, unsigned Form) const { + DW.EmitString(Value); +} + +/// SizeOf - Determine size of string value in bytes. +/// +unsigned DIEString::SizeOf(const DwarfWriter &DW, unsigned Form) const { + return Value.size() + sizeof(int8_t); +} + +//===----------------------------------------------------------------------===// + +/// EmitValue - Emit label value. +/// +void DIELabel::EmitValue(const DwarfWriter &DW, unsigned Form) const { + DW.EmitLabelReference(Value); +} + +/// SizeOf - Determine size of label value in bytes. +/// +unsigned DIELabel::SizeOf(const DwarfWriter &DW, unsigned Form) const { + return DW.getAddressSize(); +} + +//===----------------------------------------------------------------------===// + +/// EmitValue - Emit delta value. +/// +void DIEDelta::EmitValue(const DwarfWriter &DW, unsigned Form) const { + DW.EmitDifference(Value1, Value2); +} + +/// SizeOf - Determine size of delta value in bytes. +/// +unsigned DIEDelta::SizeOf(const DwarfWriter &DW, unsigned Form) const { + return DW.getAddressSize(); +} + +//===----------------------------------------------------------------------===// + +/// PrintHex - Print a value as a hexidecimal value. +/// +void DwarfWriter::PrintHex(int Value) const { + O << "0x" << std::hex << Value << std::dec; +} + +/// 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 DwarfWriter::EOL(const std::string &Comment) const { if (DwarfVerbose) { O << "\t" << Asm->CommentString << " " - << Comment - << " " - << Value; + << Comment; } O << "\n"; } -/// EmitHex - Emit a hexidecimal string to the output stream. -/// -void DwarfWriter::EmitHex(unsigned Value) const { - O << "0x" - << std::hex - << Value - << std::dec; +/// EmitULEB128Bytes - Emit an assembler byte data directive to compose an +/// unsigned leb128 value. +void DwarfWriter::EmitULEB128Bytes(unsigned Value) const { + if (hasLEB128) { + O << "\t.uleb128\t" + << Value; + } else { + O << Asm->Data8bitsDirective; + PrintULEB128(Value); + } } -/// EmitComment - Emit a simple string comment. -/// -void DwarfWriter::EmitComment(const char *Comment) const { - O << "\t" - << Asm->CommentString - << " " - << Comment - << "\n"; +/// EmitSLEB128Bytes - Emit an assembler byte data directive to compose a +/// signed leb128 value. +void DwarfWriter::EmitSLEB128Bytes(int Value) const { + if (hasLEB128) { + O << "\t.sleb128\t" + << Value; + } else { + O << Asm->Data8bitsDirective; + PrintSLEB128(Value); + } } -/// EmitULEB128 - Emit a series of hexidecimal values (separated by commas) +/// PrintULEB128 - Print a series of hexidecimal values (separated by commas) /// representing an unsigned leb128 value. -/// -void DwarfWriter::EmitULEB128(unsigned Value) const { +void DwarfWriter::PrintULEB128(unsigned Value) const { do { unsigned Byte = Value & 0x7f; Value >>= 7; if (Value) Byte |= 0x80; - EmitHex(Byte); + PrintHex(Byte); if (Value) O << ", "; } while (Value); } -/// EmitSLEB128 - Emit a series of hexidecimal values (separated by commas) +/// SizeULEB128 - Compute the number of bytes required for an unsigned leb128 +/// value. +unsigned DwarfWriter::SizeULEB128(unsigned Value) { + unsigned Size = 0; + do { + Value >>= 7; + Size += sizeof(int8_t); + } while (Value); + return Size; +} + +/// PrintSLEB128 - Print a series of hexidecimal values (separated by commas) /// representing a signed leb128 value. -/// -void DwarfWriter::EmitSLEB128(int Value) const { +void DwarfWriter::PrintSLEB128(int Value) const { int Sign = Value >> (8 * sizeof(Value) - 1); bool IsMore; @@ -115,40 +802,499 @@ void DwarfWriter::EmitSLEB128(int Value) const { Value >>= 7; IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0; if (IsMore) Byte |= 0x80; - EmitHex(Byte); + PrintHex(Byte); if (IsMore) O << ", "; } while (IsMore); } -/// EmitLabelName - Emit label name for internal use by dwarf. +/// SizeSLEB128 - Compute the number of bytes required for a signed leb128 +/// value. +unsigned DwarfWriter::SizeSLEB128(int Value) { + unsigned Size = 0; + int Sign = Value >> (8 * sizeof(Value) - 1); + bool IsMore; + + do { + unsigned Byte = Value & 0x7f; + Value >>= 7; + IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0; + Size += sizeof(int8_t); + } while (IsMore); + return Size; +} + +/// EmitByte - Emit a byte directive and value. /// -void DwarfWriter::EmitLabelName(const char *Tag, int Num) const { +void DwarfWriter::EmitByte(int Value) const { + O << Asm->Data8bitsDirective; + PrintHex(Value); +} + +/// EmitShort - Emit a short directive and value. +/// +void DwarfWriter::EmitShort(int Value) const { + O << Asm->Data16bitsDirective; + PrintHex(Value); +} + +/// EmitLong - Emit a long directive and value. +/// +void DwarfWriter::EmitLong(int Value) const { + O << Asm->Data32bitsDirective; + PrintHex(Value); +} + +/// EmitString - Emit a string with quotes and a null terminator. +/// Special characters are emitted properly. (Eg. '\t') +void DwarfWriter::EmitString(const std::string &String) const { + O << Asm->AsciiDirective + << "\""; + for (unsigned i = 0, N = String.size(); i < N; i++) { + unsigned char C = String[i]; + + if (!isascii(C) || iscntrl(C)) { + switch(C) { + case '\b': O << "\\b"; break; + case '\f': O << "\\f"; break; + case '\n': O << "\\n"; break; + case '\r': O << "\\r"; break; + case '\t': O << "\\t"; break; + default: + O << '\\'; + O << char('0' + (C >> 6)); + O << char('0' + (C >> 3)); + O << char('0' + (C >> 0)); + break; + } + } else if (C == '\"') { + O << "\\\""; + } else if (C == '\'') { + O << "\\\'"; + } else { + O << C; + } + } + O << "\\0\""; +} + +/// PrintLabelName - Print label name in form used by Dwarf writer. +/// +void DwarfWriter::PrintLabelName(const char *Tag, unsigned Number) const { O << Asm->PrivateGlobalPrefix << "debug_" << Tag - << Num; + << Number; } -/// EmitLabel - Emit location label for internal use by dwarf. +/// EmitLabel - Emit location label for internal use by Dwarf. /// -void DwarfWriter::EmitLabel(const char *Tag, int Num) const { - EmitLabelName(Tag, Num); +void DwarfWriter::EmitLabel(const char *Tag, unsigned Number) const { + PrintLabelName(Tag, Number); O << ":\n"; } -/// EmitInitial -Emit initial dwarf declarations. +/// EmitLabelReference - Emit a reference to a label. +/// +void DwarfWriter::EmitLabelReference(const char *Tag, unsigned Number) const { + if (AddressSize == 4) + O << Asm->Data32bitsDirective; + else + O << Asm->Data64bitsDirective; + + PrintLabelName(Tag, Number); +} + +/// EmitDifference - Emit an label difference as sizeof(pointer) value. Some +/// assemblers do not accept absolute expressions with data directives, so there +/// is an option (needsSet) to use an intermediary 'set' expression. +void DwarfWriter::EmitDifference(const char *Tag1, unsigned Number1, + const char *Tag2, unsigned Number2) const { + if (needsSet) { + static unsigned SetCounter = 0; + O << "\t.set\t"; + PrintLabelName("set", SetCounter); + O << ","; + PrintLabelName(Tag1, Number1); + O << "-"; + PrintLabelName(Tag2, Number2); + O << "\n"; + + if (AddressSize == sizeof(int32_t)) + O << Asm->Data32bitsDirective; + else + O << Asm->Data64bitsDirective; + + PrintLabelName("set", SetCounter); + + SetCounter++; + } else { + if (AddressSize == sizeof(int32_t)) + O << Asm->Data32bitsDirective; + else + O << Asm->Data64bitsDirective; + + PrintLabelName(Tag1, Number1); + O << "-"; + PrintLabelName(Tag2, Number2); + } +} + +/// NewDIE - Construct a new structured debug information entry. +/// +DIE *DwarfWriter::NewDIE(const unsigned char *AbbrevData) { + // Get the abbreviation ID. + unsigned AbbrevID = Abbreviations.insert(DIEAbbrev(AbbrevData)); + // Allocate new new structured DIE. + DIE *Die = new DIE(AbbrevID); + // Return structured DIE. + return Die; +} + +/// NewCompileUnit - Create new compile unit information. +/// +DIE *DwarfWriter::NewCompileUnit(const std::string &Directory, + const std::string &SourceName) { + DIE *Die = NewDIE(AbbrevTAG_compile_unit); + // FIXME - use the correct line set. + Die->AddValue(DWLabel("line", 0)); + Die->AddValue(DWLabel("text_end", 0)); + Die->AddValue(DWLabel("text_begin", 0)); + // FIXME - The producer needs to be in this form, but should come from + // an appropriate source. + Die->AddValue("llvm 3.4.x (LLVM Research Group)"); + Die->AddValue(DW_LANG_C89); + Die->AddValue(SourceName); + Die->AddValue(Directory); + + return Die; +} + +/// EmitInitial - Emit initial Dwarf declarations. This is necessary for cc +/// tools to recognize the object file contains Dwarf information. /// void DwarfWriter::EmitInitial() const { - // Dwarf section's base addresses. + // Dwarf sections base addresses. Asm->SwitchSection(DwarfAbbrevSection, 0); EmitLabel("abbrev", 0); Asm->SwitchSection(DwarfInfoSection, 0); EmitLabel("info", 0); Asm->SwitchSection(DwarfLineSection, 0); EmitLabel("line", 0); + + // Standard sections base addresses. + Asm->SwitchSection(TextSection, 0); + EmitLabel("text_begin", 0); + Asm->SwitchSection(DataSection, 0); + EmitLabel("data_begin", 0); } -/// ShouldEmitDwarf - Determine if dwarf declarations should be made. +/// EmitDIE - Recusively Emits a debug information entry. +/// +void DwarfWriter::EmitDIE(DIE *Die) const { + // Get the abbreviation for this DIE. + unsigned AbbrevID = Die->getAbbrevID(); + const DIEAbbrev &Abbrev = Abbreviations[AbbrevID]; + + // Emit the code (index) for the abbreviation. + EmitULEB128Bytes(AbbrevID); + EOL(std::string("Abbrev [" + + utostr(AbbrevID) + + TagString(Abbrev.getTag())) + + " "); + + const std::vector<DIEValue *> &Values = Die->getValues(); + + // Emit the DIE attribute values. + for (unsigned i = 0, N = Values.size(); i < N; i++) { + unsigned Attr = Abbrev.getAttribute(i); + unsigned Form = Abbrev.getForm(i); + assert(Form && "Too many attributes for DIE (check abbreviation)"); + + switch (Attr) { + case DW_AT_sibling: { + EmitLong(Die->SiblingOffset()); + break; + } + default: { + // Emit an attribute using the defined form. + Values[i]->EmitValue(*this, Form); + break; + } + } + + EOL(AttributeString(Attr)); + } + + // Emit the DIE children if any. + if (Abbrev.getChildrenFlag() == DW_CHILDREN_yes) { + const std::vector<DIE *> &Children = Die->getChildren(); + + for (unsigned j = 0, M = Children.size(); j < M; j++) { + // FIXME - handle sibling offsets. + // FIXME - handle all DIE types. + EmitDIE(Children[j]); + } + + EmitByte(0); EOL("End Of Children Mark"); + } +} + +/// SizeAndOffsetDie - Compute the size and offset of a DIE. +/// +unsigned DwarfWriter::SizeAndOffsetDie(DIE *Die, unsigned Offset) const { + // Get the abbreviation for this DIE. + unsigned AbbrevID = Die->getAbbrevID(); + const DIEAbbrev &Abbrev = Abbreviations[AbbrevID]; + + // Set DIE offset + Die->setOffset(Offset); + + // Start the size with the size of abbreviation code. + Offset += SizeULEB128(AbbrevID); + + const std::vector<DIEValue *> &Values = Die->getValues(); + + // Emit the DIE attribute values. + for (unsigned i = 0, N = Values.size(); i < N; i++) { + // Size attribute value. + Offset += Values[i]->SizeOf(*this, Abbrev.getForm(i)); + } + + // Emit the DIE children if any. + if (Abbrev.getChildrenFlag() == DW_CHILDREN_yes) { + const std::vector<DIE *> &Children = Die->getChildren(); + + for (unsigned j = 0, M = Children.size(); j < M; j++) { + // FIXME - handle sibling offsets. + // FIXME - handle all DIE types. + Offset = SizeAndOffsetDie(Children[j], Offset); + } + + // End of children marker. + Offset += sizeof(int8_t); + } + + Die->setSize(Offset - Die->getOffset()); + return Offset; +} + +/// SizeAndOffsets - Compute the size and offset of all the DIEs. +/// +void DwarfWriter::SizeAndOffsets() { + // Compute size of debug unit header + unsigned Offset = sizeof(int32_t) + // Length of Compilation Unit Info + sizeof(int16_t) + // DWARF version number + sizeof(int32_t) + // Offset Into Abbrev. Section + sizeof(int8_t); // Pointer Size (in bytes) + + // Process each compile unit. + for (unsigned i = 0, N = CompileUnits.size(); i < N; i++) { + Offset = SizeAndOffsetDie(CompileUnits[i], Offset); + } +} + +/// EmitDebugInfo - Emit the debug info section. +/// +void DwarfWriter::EmitDebugInfo() const { + // Start debug info section. + Asm->SwitchSection(DwarfInfoSection, 0); + + // Get the number of compile units. + unsigned N = CompileUnits.size(); + + // If there are any compile units. + if (N) { + // Emit the compile units header. + + // Emit size of content not including length itself + unsigned ContentSize = CompileUnits[N - 1]->SiblingOffset(); + EmitLong(ContentSize - sizeof(int32_t)); + EOL("Length of Compilation Unit Info"); + + EmitShort(DWARF_VERSION); EOL("DWARF version number"); + + EmitLabelReference("abbrev", 0); EOL("Offset Into Abbrev. Section"); + + EmitByte(AddressSize); EOL("Address Size (in bytes)"); + + // Process each compile unit. + for (unsigned i = 0; i < N; i++) { + EmitDIE(CompileUnits[i]); + } + } +} + +/// EmitAbbreviations - Emit the abbreviation section. +/// +void DwarfWriter::EmitAbbreviations() const { + // Start the debug abbrev section. + Asm->SwitchSection(DwarfAbbrevSection, 0); + + // For each abbrevation. + for (unsigned AbbrevID = 1, NAID = Abbreviations.size(); + AbbrevID <= NAID; AbbrevID++) { + // Get abbreviation data + const DIEAbbrev &Abbrev = Abbreviations[AbbrevID]; + + // Emit the abbrevations code (base 1 index.) + EmitULEB128Bytes(AbbrevID); EOL("Abbreviation Code"); + + // Emit its Dwarf tag type. + EmitULEB128Bytes(Abbrev.getTag()); + EOL(TagString(Abbrev.getTag())); + + // Emit whether it has children DIEs. + EmitULEB128Bytes(Abbrev.getChildrenFlag()); + EOL(ChildrenString(Abbrev.getChildrenFlag())); + + // For each attribute description. + for (unsigned i = 0; ; i++) { + unsigned Attr = Abbrev.getAttribute(i); + unsigned Form = Abbrev.getForm(i); + + // Attributes are null terminated. + if (!Attr) break; + + // Emit attribute type. + EmitULEB128Bytes(Attr); + EOL(AttributeString(Attr)); + + // Emit form type. + EmitULEB128Bytes(Form); + EOL(FormEncodingString(Form)); + } + + // Mark end of abbreviation. + EmitULEB128Bytes(0); EOL("EOM(1)"); + EmitULEB128Bytes(0); EOL("EOM(2)"); + } +} + +/// EmitDebugLines - Emit source line information. +/// +void DwarfWriter::EmitDebugLines() const { + // Minimum line delta, thus ranging from -10..(255-10). + const int MinLineDelta = -(DW_LNS_fixed_advance_pc + 1); + // Maximum line delta, thus ranging from -10..(255-10). + const int MaxLineDelta = 255 + MinLineDelta; + + // Start the dwarf line section. + Asm->SwitchSection(DwarfLineSection, 0); + + // Construct the section header. + + EmitDifference("line_end", 0, "line_begin", 0); + EOL("Length of Source Line Info"); + EmitLabel("line_begin", 0); + + EmitShort(DWARF_VERSION); EOL("DWARF version number"); + + EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0); + EOL("Prolog Length"); + EmitLabel("line_prolog_begin", 0); + + EmitByte(1); EOL("Minimum Instruction Length"); + + EmitByte(1); EOL("Default is_stmt_start flag"); + + EmitByte(MinLineDelta); EOL("Line Base Value (Special Opcodes)"); + + EmitByte(MaxLineDelta); EOL("Line Range Value (Special Opcodes)"); + + EmitByte(-MinLineDelta); EOL("Special Opcode Base"); + + // Line number standard opcode encodings argument count + EmitByte(0); EOL("DW_LNS_copy arg count"); + EmitByte(1); EOL("DW_LNS_advance_pc arg count"); + EmitByte(1); EOL("DW_LNS_advance_line arg count"); + EmitByte(1); EOL("DW_LNS_set_file arg count"); + EmitByte(1); EOL("DW_LNS_set_column arg count"); + EmitByte(0); EOL("DW_LNS_negate_stmt arg count"); + EmitByte(0); EOL("DW_LNS_set_basic_block arg count"); + EmitByte(0); EOL("DW_LNS_const_add_pc arg count"); + EmitByte(1); EOL("DW_LNS_fixed_advance_pc arg count"); + + const UniqueVector<std::string> &Directories = DebugInfo->getDirectories(); + const UniqueVector<SourceFileInfo> &SourceFiles = DebugInfo->getSourceFiles(); + + // Emit directories. + for (unsigned DirectoryID = 1, NDID = Directories.size(); + DirectoryID <= NDID; DirectoryID++) { + EmitString(Directories[DirectoryID]); EOL("Directory"); + } + EmitByte(0); EOL("End of directories"); + + // Emit files. + for (unsigned SourceID = 1, NSID = SourceFiles.size(); + SourceID <= NSID; SourceID++) { + const SourceFileInfo &SourceFile = SourceFiles[SourceID]; + EmitString(SourceFile.getName()); EOL("Source"); + EmitULEB128Bytes(SourceFile.getDirectoryID()); EOL("Directory #"); + EmitULEB128Bytes(0); EOL("Mod date"); + EmitULEB128Bytes(0); EOL("File size"); + } + EmitByte(0); EOL("End of files"); + + EmitLabel("line_prolog_end", 0); + + // Emit line information + const std::vector<SourceLineInfo *> &LineInfos = DebugInfo->getSourceLines(); + + // Dwarf assumes we start with first line of first source file. + unsigned Source = 1; + unsigned Line = 1; + + // Construct rows of the address, source, line, column matrix. + for (unsigned i = 0, N = LineInfos.size(); i < N; i++) { + SourceLineInfo *LineInfo = LineInfos[i]; + + // Define the line address. + EmitByte(0); EOL("Extended Op"); + EmitByte(4 + 1); EOL("Op size"); + EmitByte(DW_LNE_set_address); EOL("DW_LNE_set_address"); + EmitLabelReference("loc", i + 1); EOL("Location label"); + + // If change of source, then switch to the new source. + if (Source != LineInfo->getSourceID()) { + Source = LineInfo->getSourceID(); + EmitByte(DW_LNS_set_file); EOL("DW_LNS_set_file"); + EmitULEB128Bytes(0); EOL("New Source"); + } + + // If change of line. + if (Line != LineInfo->getLine()) { + // Determine offset. + int Offset = LineInfo->getLine() - Line; + int Delta = Offset - MinLineDelta; + + // Update line. + Line = LineInfo->getLine(); + + // If delta is small enough and in range... + if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { + // ... then use fast opcode. + EmitByte(Delta - MinLineDelta); EOL("Line Delta"); + } else { + // ... otherwise use long hand. + EmitByte(DW_LNS_advance_line); EOL("DW_LNS_advance_line"); + EmitSLEB128Bytes(Offset); EOL("Line Offset"); + EmitByte(DW_LNS_copy); EOL("DW_LNS_copy"); + } + } else { + // Copy the previous row (different address or source) + EmitByte(DW_LNS_copy); EOL("DW_LNS_copy"); + } + } + + // Mark end of matrix. + EmitByte(0); EOL("DW_LNE_end_sequence"); + EmitULEB128Bytes(1); O << "\n"; + EmitByte(1); O << "\n"; + + EmitLabel("line_end", 0); +} + +/// ShouldEmitDwarf - Determine if Dwarf declarations should be made. /// bool DwarfWriter::ShouldEmitDwarf() { // Check if debug info is present. @@ -164,35 +1310,85 @@ bool DwarfWriter::ShouldEmitDwarf() { return true; } -/// BeginModule - Emit all dwarf sections that should come prior to the content. +//===----------------------------------------------------------------------===// +// Main enties. +// + + DwarfWriter::DwarfWriter(std::ostream &o, AsmPrinter *ap) + : O(o) + , Asm(ap) + , DebugInfo(NULL) + , didInitial(false) + , CompileUnits() + , Abbreviations() + , AddressSize(sizeof(int32_t)) + , hasLEB128(false) + , hasDotLoc(false) + , hasDotFile(false) + , needsSet(false) + , DwarfAbbrevSection(".debug_abbrev") + , DwarfInfoSection(".debug_info") + , DwarfLineSection(".debug_line") + , TextSection(".text") + , DataSection(".data") + {} + DwarfWriter::~DwarfWriter() { + } + +/// BeginModule - Emit all Dwarf sections that should come prior to the content. /// void DwarfWriter::BeginModule() { if (!ShouldEmitDwarf()) return; - EmitComment("Dwarf Begin Module"); + EOL("Dwarf Begin Module"); } -/// EndModule - Emit all dwarf sections that should come after the content. +/// EndModule - Emit all Dwarf sections that should come after the content. /// void DwarfWriter::EndModule() { if (!ShouldEmitDwarf()) return; - EmitComment("Dwarf End Module"); - // Print out dwarf file info - std::vector<std::string> Sources = DebugInfo->getSourceFiles(); - for (unsigned i = 0, N = Sources.size(); i < N; i++) { - O << "\t; .file\t" << (i + 1) << "," << "\"" << Sources[i] << "\"" << "\n"; + EOL("Dwarf End Module"); + + // Standard sections final addresses. + EmitLabel("text_end", 0); + EmitLabel("data_end", 0); + + // Get directory and source information. + const UniqueVector<std::string> &Directories = DebugInfo->getDirectories(); + const UniqueVector<SourceFileInfo> &SourceFiles = DebugInfo->getSourceFiles(); + + // Construct compile unit DIEs for each source. + for (unsigned SourceID = 1, NSID = SourceFiles.size(); + SourceID <= NSID; SourceID++) { + const SourceFileInfo &SourceFile = SourceFiles[SourceID]; + const std::string &Directory = Directories[SourceFile.getDirectoryID()]; + const std::string &SourceName = SourceFile.getName(); + DIE *CompileUnit = NewCompileUnit(Directory, SourceName); + CompileUnits.push_back(CompileUnit); } + + // Compute DIE offsets and sizes. + SizeAndOffsets(); + + // Emit all the DIEs into a debug info section + EmitDebugInfo(); + + // Corresponding abbreviations into a abbrev section. + EmitAbbreviations(); + + // Emit source line correspondence into a debug line section. + EmitDebugLines(); } /// BeginFunction - Emit pre-function debug information. /// void DwarfWriter::BeginFunction() { if (!ShouldEmitDwarf()) return; - EmitComment("Dwarf Begin Function"); + EOL("Dwarf Begin Function"); } /// EndFunction - Emit post-function debug information. /// void DwarfWriter::EndFunction() { if (!ShouldEmitDwarf()) return; - EmitComment("Dwarf End Function"); + EOL("Dwarf End Function"); } diff --git a/lib/CodeGen/MachineDebugInfo.cpp b/lib/CodeGen/MachineDebugInfo.cpp index d2a5fd5..5464686 100644 --- a/lib/CodeGen/MachineDebugInfo.cpp +++ b/lib/CodeGen/MachineDebugInfo.cpp @@ -6,11 +6,6 @@ // the University of Illinois Open Source License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// Collect debug information for a module. This information should be in a -// neutral form that can be used by different debugging schemes. -// -//===----------------------------------------------------------------------===// #include "llvm/CodeGen/MachineDebugInfo.h" @@ -20,7 +15,9 @@ using namespace llvm; namespace { RegisterPass<MachineDebugInfo> X("machinedebuginfo", "Debug Information"); } + +//===----------------------------------------------------------------------===// /// doInitialization - Initialize the debug state for a new module. /// bool MachineDebugInfo::doInitialization() { @@ -32,38 +29,3 @@ bool MachineDebugInfo::doInitialization() { bool MachineDebugInfo::doFinalization() { return false; } - -/// getUniqueSourceID - Register a source file with debug info. Returns an id. -/// -unsigned MachineDebugInfo::getUniqueSourceID(const std::string &fname, - const std::string &dirname) { - // Compose a key - const std::string path = dirname + "/" + fname; - // Check if the source file is already recorded - std::map<std::string, unsigned>::iterator - SMI = SourceMap.lower_bound(path); - // If already there return existing id - if (SMI != SourceMap.end() && SMI->first == path) return SMI->second; - // Bump up the count - ++SourceCount; - // Record the count - SourceMap.insert(SMI, std::make_pair(path, SourceCount)); - // Return id - return SourceCount; -} - -/// getSourceFiles - Return a vector of files. Vector index + 1 equals id. -/// -std::vector<std::string> MachineDebugInfo::getSourceFiles() const { - std::vector<std::string> Sources(SourceCount); - - for (std::map<std::string, unsigned>::const_iterator SMI = SourceMap.begin(), - E = SourceMap.end(); - SMI != E; SMI++) { - unsigned Index = SMI->second - 1; - const std::string &Path = SMI->first; - Sources[Index] = Path; - } - return Sources; -} - diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp index fcc3a95..a53be0a 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -627,7 +627,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { cast<StringSDNode>(Node->getOperand(3))->getValue(); const std::string &DirName = cast<StringSDNode>(Node->getOperand(4))->getValue(); - unsigned SrcFile = DebugInfo->getUniqueSourceID(FName, DirName); + unsigned SrcFile = DebugInfo->RecordSource(DirName, FName); std::vector<SDOperand> Ops; Ops.push_back(Tmp1); // chain diff --git a/lib/Target/PowerPC/PPCAsmPrinter.cpp b/lib/Target/PowerPC/PPCAsmPrinter.cpp index de865db..55f54c4 100644 --- a/lib/Target/PowerPC/PPCAsmPrinter.cpp +++ b/lib/Target/PowerPC/PPCAsmPrinter.cpp @@ -215,9 +215,11 @@ namespace { : DwarfWriter(o, ap) { needsSet = true; - DwarfAbbrevSection = ".section __DWARFA,__debug_abbrev,regular,debug"; - DwarfInfoSection = ".section __DWARFA,__debug_info,regular,debug"; - DwarfLineSection = ".section __DWARFA,__debug_line,regular,debug"; + DwarfAbbrevSection = ".section __DWARF,__debug_abbrev,regular,debug"; + DwarfInfoSection = ".section __DWARF,__debug_info,regular,debug"; + DwarfLineSection = ".section __DWARF,__debug_line,regular,debug"; + TextSection = ".text"; + DataSection = ".data"; } }; @@ -607,6 +609,9 @@ bool DarwinAsmPrinter::doFinalization(Module &M) { } } + // Emit initial debug information. + DW.EndModule(); + // Funny Darwin hack: This flag tells the linker that no global symbols // contain code that falls through to other global symbols (e.g. the obvious // implementation of multiple entry points). If this doesn't occur, the @@ -614,9 +619,6 @@ bool DarwinAsmPrinter::doFinalization(Module &M) { // code that does this, it is always safe to set. O << "\t.subsections_via_symbols\n"; - // Emit initial debug information. - DW.EndModule(); - AsmPrinter::doFinalization(M); return false; // success } |