X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FDwarfWriter.cpp;h=8cc7f30979b8e9d5d81667b82d35a04bac883216;hb=420cdebbcb95f3881ab3518fd3bb670837669e43;hp=43ea483a36342e9bac44d952b788e7207629f931;hpb=ef42a01113a1ee8ef0f2c803ec05a5f20eca2854;p=oota-llvm.git diff --git a/lib/CodeGen/DwarfWriter.cpp b/lib/CodeGen/DwarfWriter.cpp index 43ea483a363..8cc7f30979b 100644 --- a/lib/CodeGen/DwarfWriter.cpp +++ b/lib/CodeGen/DwarfWriter.cpp @@ -2,46 +2,45 @@ // // 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 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. +// This file contains support for writing dwarf info into asm files. // //===----------------------------------------------------------------------===// #include "llvm/CodeGen/DwarfWriter.h" +#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/UniqueVector.h" #include "llvm/Module.h" #include "llvm/Type.h" #include "llvm/CodeGen/AsmPrinter.h" -#include "llvm/CodeGen/MachineDebugInfo.h" +#include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineLocation.h" +#include "llvm/Support/Debug.h" #include "llvm/Support/Dwarf.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/DataTypes.h" #include "llvm/Support/Mangler.h" +#include "llvm/System/Path.h" #include "llvm/Target/TargetAsmInfo.h" -#include "llvm/Target/MRegisterInfo.h" +#include "llvm/Target/TargetRegisterInfo.h" #include "llvm/Target/TargetData.h" -#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetFrameInfo.h" - -#include +#include "llvm/Target/TargetInstrInfo.h" +#include "llvm/Target/TargetMachine.h" +#include "llvm/Target/TargetOptions.h" +#include #include - using namespace llvm; using namespace llvm::dwarf; -static cl::opt -DwarfVerbose("dwarf-verbose", cl::Hidden, - cl::desc("Add comments to Dwarf directives.")); - namespace llvm { //===----------------------------------------------------------------------===// @@ -58,69 +57,11 @@ static const unsigned InitValuesSetSize = 9; // 512 class DIE; class DIEValue; -//===----------------------------------------------------------------------===// -/// LEB 128 number encoding. - -/// PrintULEB128 - Print a series of hexidecimal values (separated by commas) -/// representing an unsigned leb128 value. -static void PrintULEB128(std::ostream &O, unsigned Value) { - do { - unsigned Byte = Value & 0x7f; - Value >>= 7; - if (Value) Byte |= 0x80; - O << "0x" << std::hex << Byte << std::dec; - if (Value) O << ", "; - } while (Value); -} - -/// SizeULEB128 - Compute the number of bytes required for an unsigned leb128 -/// value. -static unsigned 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. -static void PrintSLEB128(std::ostream &O, int Value) { - int Sign = Value >> (8 * sizeof(Value) - 1); - bool IsMore; - - do { - unsigned Byte = Value & 0x7f; - Value >>= 7; - IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0; - if (IsMore) Byte |= 0x80; - O << "0x" << std::hex << Byte << std::dec; - if (IsMore) O << ", "; - } while (IsMore); -} - -/// SizeSLEB128 - Compute the number of bytes required for a signed leb128 -/// value. -static unsigned 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; -} - //===----------------------------------------------------------------------===// /// DWLabel - Labels are used to track locations in the assembler file. -/// Labels appear in the form debug_, where the tag is a -/// category of label (Ex. location) and number is a value unique in that -/// category. +/// Labels appear in the form @verbatim @endverbatim, +/// where the tag is a category of label (Ex. location) and number is a value +/// unique in that category. class DWLabel { public: /// Tag - Label category tag. Should always be a staticly declared C string. @@ -139,8 +80,11 @@ public: } #ifndef NDEBUG + void print(std::ostream *O) const { + if (O) print(*O); + } void print(std::ostream &O) const { - O << ".debug_" << Tag; + O << "." << Tag; if (Number) O << Number; } #endif @@ -241,9 +185,12 @@ public: /// Emit - Print the abbreviation using the specified Dwarf writer. /// - void Emit(const Dwarf &DW) const; + void Emit(const DwarfDebug &DD) const; #ifndef NDEBUG + void print(std::ostream *O) { + if (O) print(*O); + } void print(std::ostream &O); void dump(); #endif @@ -275,7 +222,7 @@ protected: std::vector Values; public: - DIE(unsigned Tag) + explicit DIE(unsigned Tag) : Abbrev(Tag, DW_CHILDREN_no) , Offset(0) , Size(0) @@ -289,10 +236,11 @@ public: unsigned getAbbrevNumber() const { return Abbrev.getNumber(); } + unsigned getTag() const { return Abbrev.getTag(); } unsigned getOffset() const { return Offset; } unsigned getSize() const { return Size; } const std::vector &getChildren() const { return Children; } - const std::vector &getValues() const { return Values; } + std::vector &getValues() { return Values; } void setTag(unsigned Tag) { Abbrev.setTag(Tag); } void setOffset(unsigned O) { Offset = O; } void setSize(unsigned S) { Size = S; } @@ -330,6 +278,9 @@ public: void Profile(FoldingSetNodeID &ID) ; #ifndef NDEBUG + void print(std::ostream *O, unsigned IncIndent = 0) { + if (O) print(*O, IncIndent); + } void print(std::ostream &O, unsigned IncIndent = 0); void dump(); #endif @@ -354,36 +305,33 @@ public: /// unsigned Type; - /// Usage - Number of uses of this value. - /// - unsigned Usage; - - DIEValue(unsigned T) + explicit DIEValue(unsigned T) : Type(T) - , Usage(1) {} virtual ~DIEValue() {} + // Accessors unsigned getType() const { return Type; } - unsigned getUsage() const { return Usage; } - void IncUsage() { ++Usage; } // Implement isa/cast/dyncast. static bool classof(const DIEValue *) { return true; } /// EmitValue - Emit value via the Dwarf writer. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const = 0; + virtual void EmitValue(DwarfDebug &DD, unsigned Form) = 0; /// SizeOf - Return the size of a value in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const = 0; + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const = 0; /// Profile - Used to gather unique data for the value folding set. /// virtual void Profile(FoldingSetNodeID &ID) = 0; #ifndef NDEBUG + void print(std::ostream *O) { + if (O) print(*O); + } virtual void print(std::ostream &O) = 0; void dump(); #endif @@ -397,7 +345,7 @@ private: uint64_t Integer; public: - DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {} + explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {} // Implement isa/cast/dyncast. static bool classof(const DIEInteger *) { return true; } @@ -420,33 +368,19 @@ public: /// EmitValue - Emit integer of appropriate size. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const; + virtual void EmitValue(DwarfDebug &DD, unsigned Form); /// SizeOf - Determine size of integer value in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const { - switch (Form) { - case DW_FORM_flag: // Fall thru - case DW_FORM_ref1: // Fall thru - case DW_FORM_data1: return sizeof(int8_t); - case DW_FORM_ref2: // Fall thru - case DW_FORM_data2: return sizeof(int16_t); - case DW_FORM_ref4: // Fall thru - case DW_FORM_data4: return sizeof(int32_t); - case DW_FORM_ref8: // Fall thru - case DW_FORM_data8: return sizeof(int64_t); - case DW_FORM_udata: return SizeULEB128(Integer); - case DW_FORM_sdata: return SizeSLEB128(Integer); - default: assert(0 && "DIE Value form not supported yet"); break; - } - return 0; - } + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; /// Profile - Used to gather unique data for the value folding set. /// - virtual void Profile(FoldingSetNodeID &ID) { + static void Profile(FoldingSetNodeID &ID, unsigned Integer) { + ID.AddInteger(isInteger); ID.AddInteger(Integer); } + virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Integer); } #ifndef NDEBUG virtual void print(std::ostream &O) { @@ -463,7 +397,7 @@ class DIEString : public DIEValue { public: const std::string String; - DIEString(const std::string &S) : DIEValue(isString), String(S) {} + explicit DIEString(const std::string &S) : DIEValue(isString), String(S) {} // Implement isa/cast/dyncast. static bool classof(const DIEString *) { return true; } @@ -471,19 +405,21 @@ public: /// EmitValue - Emit string value. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const; + virtual void EmitValue(DwarfDebug &DD, unsigned Form); /// SizeOf - Determine size of string value in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const { + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const { return String.size() + sizeof(char); // sizeof('\0'); } /// Profile - Used to gather unique data for the value folding set. /// - virtual void Profile(FoldingSetNodeID &ID) { + static void Profile(FoldingSetNodeID &ID, const std::string &String) { + ID.AddInteger(isString); ID.AddString(String); } + virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, String); } #ifndef NDEBUG virtual void print(std::ostream &O) { @@ -500,7 +436,7 @@ public: const DWLabel Label; - DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {} + explicit DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {} // Implement isa/cast/dyncast. static bool classof(const DIEDwarfLabel *) { return true; } @@ -508,17 +444,19 @@ public: /// EmitValue - Emit label value. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const; + virtual void EmitValue(DwarfDebug &DD, unsigned Form); /// SizeOf - Determine size of label value in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const; + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; /// Profile - Used to gather unique data for the value folding set. /// - virtual void Profile(FoldingSetNodeID &ID) { + static void Profile(FoldingSetNodeID &ID, const DWLabel &Label) { + ID.AddInteger(isLabel); Label.Profile(ID); } + virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label); } #ifndef NDEBUG virtual void print(std::ostream &O) { @@ -536,7 +474,8 @@ class DIEObjectLabel : public DIEValue { public: const std::string Label; - DIEObjectLabel(const std::string &L) : DIEValue(isAsIsLabel), Label(L) {} + explicit DIEObjectLabel(const std::string &L) + : DIEValue(isAsIsLabel), Label(L) {} // Implement isa/cast/dyncast. static bool classof(const DIEObjectLabel *) { return true; } @@ -544,17 +483,19 @@ public: /// EmitValue - Emit label value. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const; + virtual void EmitValue(DwarfDebug &DD, unsigned Form); /// SizeOf - Determine size of label value in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const; + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; /// Profile - Used to gather unique data for the value folding set. /// - virtual void Profile(FoldingSetNodeID &ID) { + static void Profile(FoldingSetNodeID &ID, const std::string &Label) { + ID.AddInteger(isAsIsLabel); ID.AddString(Label); } + virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label); } #ifndef NDEBUG virtual void print(std::ostream &O) { @@ -580,18 +521,21 @@ public: /// EmitValue - Emit delta value. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const; + virtual void EmitValue(DwarfDebug &DD, unsigned Form); /// SizeOf - Determine size of delta value in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const; + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; /// Profile - Used to gather unique data for the value folding set. /// - virtual void Profile(FoldingSetNodeID &ID){ + static void Profile(FoldingSetNodeID &ID, const DWLabel &LabelHi, + const DWLabel &LabelLo) { + ID.AddInteger(isDelta); LabelHi.Profile(ID); LabelLo.Profile(ID); } + virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, LabelHi, LabelLo); } #ifndef NDEBUG virtual void print(std::ostream &O) { @@ -611,7 +555,7 @@ class DIEntry : public DIEValue { public: DIE *Entry; - DIEntry(DIE *E) : DIEValue(isEntry), Entry(E) {} + explicit DIEntry(DIE *E) : DIEValue(isEntry), Entry(E) {} // Implement isa/cast/dyncast. static bool classof(const DIEntry *) { return true; } @@ -619,17 +563,23 @@ public: /// EmitValue - Emit debug information entry offset. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const; + virtual void EmitValue(DwarfDebug &DD, unsigned Form); /// SizeOf - Determine size of debug information entry in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const { + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const { return sizeof(int32_t); } /// Profile - Used to gather unique data for the value folding set. /// + static void Profile(FoldingSetNodeID &ID, DIE *Entry) { + ID.AddInteger(isEntry); + ID.AddPointer(Entry); + } virtual void Profile(FoldingSetNodeID &ID) { + ID.AddInteger(isEntry); + if (Entry) { ID.AddPointer(Entry); } else { @@ -665,7 +615,7 @@ public: /// ComputeSize - calculate the size of the block. /// - unsigned ComputeSize(Dwarf &DW); + unsigned ComputeSize(DwarfDebug &DD); /// BestForm - Choose the best form for data. /// @@ -678,16 +628,17 @@ public: /// EmitValue - Emit block data. /// - virtual void EmitValue(const Dwarf &DW, unsigned Form) const; + virtual void EmitValue(DwarfDebug &DD, unsigned Form); /// SizeOf - Determine size of block data in bytes. /// - virtual unsigned SizeOf(const Dwarf &DW, unsigned Form) const; + virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; /// Profile - Used to gather unique data for the value folding set. /// - virtual void DIEBlock::Profile(FoldingSetNodeID &ID) { + virtual void Profile(FoldingSetNodeID &ID) { + ID.AddInteger(isBlock); DIE::Profile(ID); } @@ -775,14 +726,14 @@ public: /// getDieMapSlotFor - Returns the debug information entry map slot for the /// specified debug descriptor. - DIE *&getDieMapSlotFor(DebugInfoDesc *DD) { - return DescToDieMap[DD]; + DIE *&getDieMapSlotFor(DebugInfoDesc *DID) { + return DescToDieMap[DID]; } /// getDIEntrySlotFor - Returns the debug information entry proxy slot for the /// specified debug descriptor. - DIEntry *&getDIEntrySlotFor(DebugInfoDesc *DD) { - return DescToDIEntryMap[DD]; + DIEntry *&getDIEntrySlotFor(DebugInfoDesc *DID) { + return DescToDIEntryMap[DID]; } /// AddDie - Adds or interns the DIE to the compile unit. @@ -805,14 +756,14 @@ public: }; //===----------------------------------------------------------------------===// -/// Dwarf - Emits Dwarf debug and exception handling directives. +/// Dwarf - Emits general Dwarf directives. /// class Dwarf { -private: +protected: //===--------------------------------------------------------------------===// - // Core attributes used by the Dwarf writer. + // Core attributes used by the Dwarf writer. // // @@ -831,7 +782,7 @@ private: const TargetData *TD; /// RI - Register Information. - const MRegisterInfo *RI; + const TargetRegisterInfo *RI; /// M - Current module. /// @@ -841,199 +792,70 @@ private: /// MachineFunction *MF; - /// 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. + /// MMI - Collected machine module information. /// - bool shouldEmit; + MachineModuleInfo *MMI; /// SubprogramCount - The running count of functions being compiled. /// unsigned SubprogramCount; - //===--------------------------------------------------------------------===// - // 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 CompileUnits; - - /// AbbreviationsSet - Used to uniquely define abbreviations. - /// - FoldingSet AbbreviationsSet; - - /// Abbreviations - A list of all the unique abbreviations in use. - /// - std::vector Abbreviations; - - /// ValuesSet - Used to uniquely define values. - /// - FoldingSet ValuesSet; - - /// Values - A list of all the unique values in use. - /// - std::vector Values; - - /// StringPool - A UniqueVector of strings used by indirect references. - /// - UniqueVector StringPool; - - /// UnitMap - Map debug information descriptor to compile unit. - /// - std::map DescToUnitMap; - - /// SectionMap - Provides a unique id per text section. - /// - UniqueVector SectionMap; - - /// SectionSourceLines - Tracks line numbers per text section. - /// - std::vector > SectionSourceLines; + /// Flavor - A unique string indicating what dwarf producer this is, used to + /// unique labels. + const char * const Flavor; + unsigned SetCounter; + Dwarf(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T, + const char *flavor) + : O(OS) + , Asm(A) + , TAI(T) + , TD(Asm->TM.getTargetData()) + , RI(Asm->TM.getRegisterInfo()) + , M(NULL) + , MF(NULL) + , MMI(NULL) + , SubprogramCount(0) + , Flavor(flavor) + , SetCounter(1) + { + } public: //===--------------------------------------------------------------------===// - // Emission and print routines + // Accessors. // + AsmPrinter *getAsm() const { return Asm; } + MachineModuleInfo *getMMI() const { return MMI; } + const TargetAsmInfo *getTargetAsmInfo() const { return TAI; } + const TargetData *getTargetData() const { return TD; } - /// PrintHex - Print a value as a hexidecimal value. - /// - void 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 EOL(const std::string &Comment) const { - if (DwarfVerbose && !Comment.empty()) { - O << "\t" - << TAI->getCommentString() - << " " - << Comment; - } - O << "\n"; - } - - /// EmitAlign - Print a align directive. - /// - void EmitAlign(unsigned Alignment) const { - O << TAI->getAlignDirective() << Alignment << "\n"; - } - - /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an - /// unsigned leb128 value. - void EmitULEB128Bytes(unsigned Value) const { - if (TAI->hasLEB128()) { - O << "\t.uleb128\t" - << Value; - } else { - O << TAI->getData8bitsDirective(); - PrintULEB128(O, Value); - } - } - - /// EmitSLEB128Bytes - print an assembler byte data directive to compose a - /// signed leb128 value. - void EmitSLEB128Bytes(int Value) const { - if (TAI->hasLEB128()) { - O << "\t.sleb128\t" - << Value; - } else { - O << TAI->getData8bitsDirective(); - PrintSLEB128(O, Value); - } - } - - /// EmitInt8 - Emit a byte directive and value. - /// - void EmitInt8(int Value) const { - O << TAI->getData8bitsDirective(); - PrintHex(Value & 0xFF); - } - - /// EmitInt16 - Emit a short directive and value. - /// - void EmitInt16(int Value) const { - O << TAI->getData16bitsDirective(); - PrintHex(Value & 0xFFFF); - } - - /// EmitInt32 - Emit a long directive and value. - /// - void EmitInt32(int Value) const { - O << TAI->getData32bitsDirective(); - PrintHex(Value); - } - - /// EmitInt64 - Emit a long long directive and value. - /// - void EmitInt64(uint64_t Value) const { - if (TAI->getData64bitsDirective()) { + void PrintRelDirective(bool Force32Bit = false, bool isInSection = false) + const { + if (isInSection && TAI->getDwarfSectionOffsetDirective()) + O << TAI->getDwarfSectionOffsetDirective(); + else if (Force32Bit || TD->getPointerSize() == sizeof(int32_t)) + O << TAI->getData32bitsDirective(); + else O << TAI->getData64bitsDirective(); - PrintHex(Value); - } else { - if (TD->isBigEndian()) { - EmitInt32(unsigned(Value >> 32)); O << "\n"; - EmitInt32(unsigned(Value)); - } else { - EmitInt32(unsigned(Value)); O << "\n"; - EmitInt32(unsigned(Value >> 32)); - } - } - } - - /// EmitString - Emit a string with quotes and a null terminator. - /// Special characters are emitted properly. - /// \literal (Eg. '\t') \endliteral - void EmitString(const std::string &String) const { - O << TAI->getAsciiDirective() - << "\""; - 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) & 7)); - O << char('0' + ((C >> 3) & 7)); - O << char('0' + ((C >> 0) & 7)); - 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 PrintLabelName(DWLabel Label) const { PrintLabelName(Label.Tag, Label.Number); } void PrintLabelName(const char *Tag, unsigned Number) const { - O << TAI->getPrivateGlobalPrefix() - << "debug_" - << Tag; + O << TAI->getPrivateGlobalPrefix() << Tag; + if (Number) O << Number; + } + + void PrintLabelName(const char *Tag, unsigned Number, + const char *Suffix) const { + O << TAI->getPrivateGlobalPrefix() << Tag; if (Number) O << Number; + O << Suffix; } /// EmitLabel - Emit location label for internal use by Dwarf. @@ -1048,127 +870,326 @@ public: /// EmitReference - Emit a reference to a label. /// - void EmitReference(DWLabel Label) const { - EmitReference(Label.Tag, Label.Number); + void EmitReference(DWLabel Label, bool IsPCRelative = false, + bool Force32Bit = false) const { + EmitReference(Label.Tag, Label.Number, IsPCRelative, Force32Bit); } - void EmitReference(const char *Tag, unsigned Number) const { - if (TAI->getAddressSize() == 4) - O << TAI->getData32bitsDirective(); - else - O << TAI->getData64bitsDirective(); - + void EmitReference(const char *Tag, unsigned Number, + bool IsPCRelative = false, bool Force32Bit = false) const { + PrintRelDirective(Force32Bit); PrintLabelName(Tag, Number); + + if (IsPCRelative) O << "-" << TAI->getPCSymbol(); } - void EmitReference(const std::string &Name) const { - if (TAI->getAddressSize() == 4) - O << TAI->getData32bitsDirective(); - else - O << TAI->getData64bitsDirective(); - + void EmitReference(const std::string &Name, bool IsPCRelative = false, + bool Force32Bit = false) const { + PrintRelDirective(Force32Bit); + O << Name; + + if (IsPCRelative) O << "-" << TAI->getPCSymbol(); } /// 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(DWLabel LabelHi, DWLabel LabelLo, + bool IsSmall = false) { + EmitDifference(LabelHi.Tag, LabelHi.Number, + LabelLo.Tag, LabelLo.Number, + IsSmall); } void EmitDifference(const char *TagHi, unsigned NumberHi, - const char *TagLo, unsigned NumberLo) const { + const char *TagLo, unsigned NumberLo, + bool IsSmall = false) { if (TAI->needsSet()) { - static unsigned SetCounter = 0; - O << "\t.set\t"; - PrintLabelName("set", SetCounter); + PrintLabelName("set", SetCounter, Flavor); O << ","; PrintLabelName(TagHi, NumberHi); O << "-"; PrintLabelName(TagLo, NumberLo); O << "\n"; - - if (TAI->getAddressSize() == sizeof(int32_t)) - O << TAI->getData32bitsDirective(); - else - O << TAI->getData64bitsDirective(); - - PrintLabelName("set", SetCounter); - + + PrintRelDirective(IsSmall); + PrintLabelName("set", SetCounter, Flavor); ++SetCounter; } else { - if (TAI->getAddressSize() == sizeof(int32_t)) - O << TAI->getData32bitsDirective(); - else - O << TAI->getData64bitsDirective(); + PrintRelDirective(IsSmall); PrintLabelName(TagHi, NumberHi); O << "-"; PrintLabelName(TagLo, NumberLo); } } - - /// AssignAbbrevNumber - Define a unique number for the abbreviation. - /// - void AssignAbbrevNumber(DIEAbbrev &Abbrev) { - // Profile the node so that we can make it unique. - FoldingSetNodeID ID; - Abbrev.Profile(ID); - - // Check the set for priors. - DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev); - - // If it's newly added. - if (InSet == &Abbrev) { - // Add to abbreviation list. - Abbreviations.push_back(&Abbrev); - // Assign the vector position + 1 as its number. - Abbrev.setNumber(Abbreviations.size()); + + void EmitSectionOffset(const char* Label, const char* Section, + unsigned LabelNumber, unsigned SectionNumber, + bool IsSmall = false, bool isEH = false) { + bool printAbsolute = false; + if (TAI->needsSet()) { + O << "\t.set\t"; + PrintLabelName("set", SetCounter, Flavor); + O << ","; + PrintLabelName(Label, LabelNumber); + + if (isEH) + printAbsolute = TAI->isAbsoluteEHSectionOffsets(); + else + printAbsolute = TAI->isAbsoluteDebugSectionOffsets(); + + if (!printAbsolute) { + O << "-"; + PrintLabelName(Section, SectionNumber); + } + O << "\n"; + + PrintRelDirective(IsSmall); + + PrintLabelName("set", SetCounter, Flavor); + ++SetCounter; } else { - // Assign existing abbreviation number. - Abbrev.setNumber(InSet->getNumber()); - } - } + PrintRelDirective(IsSmall, true); + + PrintLabelName(Label, LabelNumber); - /// NewString - Add a string to the constant pool and returns a label. - /// - DWLabel NewString(const std::string &String) { - unsigned StringID = StringPool.insert(String); - return DWLabel("string", StringID); + if (isEH) + printAbsolute = TAI->isAbsoluteEHSectionOffsets(); + else + printAbsolute = TAI->isAbsoluteDebugSectionOffsets(); + + if (!printAbsolute) { + O << "-"; + PrintLabelName(Section, SectionNumber); + } + } } - /// NewDIEntry - Creates a new DIEntry to be a proxy for a debug information - /// entry. - DIEntry *NewDIEntry(DIE *Entry = NULL) { - DIEntry *Value; - - if (Entry) { - FoldingSetNodeID ID; - ID.AddPointer(Entry); - void *Where; - Value = static_cast(ValuesSet.FindNodeOrInsertPos(ID, Where)); + /// EmitFrameMoves - Emit frame instructions to describe the layout of the + /// frame. + void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID, + const std::vector &Moves, bool isEH) { + int stackGrowth = + Asm->TM.getFrameInfo()->getStackGrowthDirection() == + TargetFrameInfo::StackGrowsUp ? + TD->getPointerSize() : -TD->getPointerSize(); + bool IsLocal = BaseLabel && strcmp(BaseLabel, "label") == 0; + + for (unsigned i = 0, N = Moves.size(); i < N; ++i) { + const MachineMove &Move = Moves[i]; + unsigned LabelID = Move.getLabelID(); - if (Value) { - Value->IncUsage(); - return Value; + if (LabelID) { + LabelID = MMI->MappedLabel(LabelID); + + // Throw out move if the label is invalid. + if (!LabelID) continue; } - Value = new DIEntry(Entry); - ValuesSet.InsertNode(Value, Where); - } else { - Value = new DIEntry(Entry); + const MachineLocation &Dst = Move.getDestination(); + const MachineLocation &Src = Move.getSource(); + + // Advance row if new location. + if (BaseLabel && LabelID && (BaseLabelID != LabelID || !IsLocal)) { + Asm->EmitInt8(DW_CFA_advance_loc4); + Asm->EOL("DW_CFA_advance_loc4"); + EmitDifference("label", LabelID, BaseLabel, BaseLabelID, true); + Asm->EOL(); + + BaseLabelID = LabelID; + BaseLabel = "label"; + IsLocal = true; + } + + // If advancing cfa. + if (Dst.isRegister() && Dst.getRegister() == MachineLocation::VirtualFP) { + if (!Src.isRegister()) { + if (Src.getRegister() == MachineLocation::VirtualFP) { + Asm->EmitInt8(DW_CFA_def_cfa_offset); + Asm->EOL("DW_CFA_def_cfa_offset"); + } else { + Asm->EmitInt8(DW_CFA_def_cfa); + Asm->EOL("DW_CFA_def_cfa"); + Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Src.getRegister(), isEH)); + Asm->EOL("Register"); + } + + int Offset = -Src.getOffset(); + + Asm->EmitULEB128Bytes(Offset); + Asm->EOL("Offset"); + } else { + assert(0 && "Machine move no supported yet."); + } + } else if (Src.isRegister() && + Src.getRegister() == MachineLocation::VirtualFP) { + if (Dst.isRegister()) { + Asm->EmitInt8(DW_CFA_def_cfa_register); + Asm->EOL("DW_CFA_def_cfa_register"); + Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getRegister(), isEH)); + Asm->EOL("Register"); + } else { + assert(0 && "Machine move no supported yet."); + } + } else { + unsigned Reg = RI->getDwarfRegNum(Src.getRegister(), isEH); + int Offset = Dst.getOffset() / stackGrowth; + + if (Offset < 0) { + Asm->EmitInt8(DW_CFA_offset_extended_sf); + Asm->EOL("DW_CFA_offset_extended_sf"); + Asm->EmitULEB128Bytes(Reg); + Asm->EOL("Reg"); + Asm->EmitSLEB128Bytes(Offset); + Asm->EOL("Offset"); + } else if (Reg < 64) { + Asm->EmitInt8(DW_CFA_offset + Reg); + Asm->EOL("DW_CFA_offset + Reg (" + utostr(Reg) + ")"); + Asm->EmitULEB128Bytes(Offset); + Asm->EOL("Offset"); + } else { + Asm->EmitInt8(DW_CFA_offset_extended); + Asm->EOL("DW_CFA_offset_extended"); + Asm->EmitULEB128Bytes(Reg); + Asm->EOL("Reg"); + Asm->EmitULEB128Bytes(Offset); + Asm->EOL("Offset"); + } + } } - - Values.push_back(Value); - return Value; } - - /// SetDIEntry - Set a DIEntry once the debug information entry is defined. - /// - void SetDIEntry(DIEntry *Value, DIE *Entry) { - Value->Entry = Entry; - // Add to values set if not already there. If it is, we merely have a - // duplicate in the values list (no harm.) - ValuesSet.GetOrInsertNode(Value); + +}; + +//===----------------------------------------------------------------------===// +/// DwarfDebug - Emits Dwarf debug directives. +/// +class DwarfDebug : public Dwarf { + +private: + //===--------------------------------------------------------------------===// + // 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 MMI. + std::vector CompileUnits; + + /// AbbreviationsSet - Used to uniquely define abbreviations. + /// + FoldingSet AbbreviationsSet; + + /// Abbreviations - A list of all the unique abbreviations in use. + /// + std::vector Abbreviations; + + /// ValuesSet - Used to uniquely define values. + /// + FoldingSet ValuesSet; + + /// Values - A list of all the unique values in use. + /// + std::vector Values; + + /// StringPool - A UniqueVector of strings used by indirect references. + /// + UniqueVector StringPool; + + /// UnitMap - Map debug information descriptor to compile unit. + /// + std::map DescToUnitMap; + + /// SectionMap - Provides a unique id per text section. + /// + UniqueVector SectionMap; + + /// SectionSourceLines - Tracks line numbers per text section. + /// + std::vector > SectionSourceLines; + + /// didInitial - Flag to indicate if initial emission has been done. + /// + bool didInitial; + + /// shouldEmit - Flag to indicate if debug information should be emitted. + /// + bool shouldEmit; + + struct FunctionDebugFrameInfo { + unsigned Number; + std::vector Moves; + + FunctionDebugFrameInfo(unsigned Num, const std::vector &M): + Number(Num), Moves(M) { } + }; + + std::vector DebugFrames; + +public: + + /// ShouldEmitDwarf - Returns true if Dwarf declarations should be made. + /// + bool ShouldEmitDwarf() const { return shouldEmit; } + + /// AssignAbbrevNumber - Define a unique number for the abbreviation. + /// + void AssignAbbrevNumber(DIEAbbrev &Abbrev) { + // Profile the node so that we can make it unique. + FoldingSetNodeID ID; + Abbrev.Profile(ID); + + // Check the set for priors. + DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev); + + // If it's newly added. + if (InSet == &Abbrev) { + // Add to abbreviation list. + Abbreviations.push_back(&Abbrev); + // Assign the vector position + 1 as its number. + Abbrev.setNumber(Abbreviations.size()); + } else { + // Assign existing abbreviation number. + Abbrev.setNumber(InSet->getNumber()); + } + } + + /// NewString - Add a string to the constant pool and returns a label. + /// + DWLabel NewString(const std::string &String) { + unsigned StringID = StringPool.insert(String); + return DWLabel("string", StringID); + } + + /// NewDIEntry - Creates a new DIEntry to be a proxy for a debug information + /// entry. + DIEntry *NewDIEntry(DIE *Entry = NULL) { + DIEntry *Value; + + if (Entry) { + FoldingSetNodeID ID; + DIEntry::Profile(ID, Entry); + void *Where; + Value = static_cast(ValuesSet.FindNodeOrInsertPos(ID, Where)); + + if (Value) return Value; + + Value = new DIEntry(Entry); + ValuesSet.InsertNode(Value, Where); + } else { + Value = new DIEntry(Entry); + } + + Values.push_back(Value); + return Value; + } + + /// SetDIEntry - Set a DIEntry once the debug information entry is defined. + /// + void SetDIEntry(DIEntry *Value, DIE *Entry) { + Value->Entry = Entry; + // Add to values set if not already there. If it is, we merely have a + // duplicate in the values list (no harm.) + ValuesSet.GetOrInsertNode(Value); } /// AddUInt - Add an unsigned integer attribute data and value. @@ -1177,15 +1198,13 @@ public: if (!Form) Form = DIEInteger::BestForm(false, Integer); FoldingSetNodeID ID; - ID.AddInteger(Integer); + DIEInteger::Profile(ID, Integer); void *Where; DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where); if (!Value) { Value = new DIEInteger(Integer); ValuesSet.InsertNode(Value, Where); Values.push_back(Value); - } else { - Value->IncUsage(); } Die->AddValue(Attribute, Form, Value); @@ -1197,15 +1216,13 @@ public: if (!Form) Form = DIEInteger::BestForm(true, Integer); FoldingSetNodeID ID; - ID.AddInteger((uint64_t)Integer); + DIEInteger::Profile(ID, (uint64_t)Integer); void *Where; DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where); if (!Value) { Value = new DIEInteger(Integer); ValuesSet.InsertNode(Value, Where); Values.push_back(Value); - } else { - Value->IncUsage(); } Die->AddValue(Attribute, Form, Value); @@ -1216,15 +1233,13 @@ public: void AddString(DIE *Die, unsigned Attribute, unsigned Form, const std::string &String) { FoldingSetNodeID ID; - ID.AddString(String); + DIEString::Profile(ID, String); void *Where; DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where); if (!Value) { Value = new DIEString(String); ValuesSet.InsertNode(Value, Where); Values.push_back(Value); - } else { - Value->IncUsage(); } Die->AddValue(Attribute, Form, Value); @@ -1235,15 +1250,13 @@ public: void AddLabel(DIE *Die, unsigned Attribute, unsigned Form, const DWLabel &Label) { FoldingSetNodeID ID; - Label.Profile(ID); + DIEDwarfLabel::Profile(ID, Label); void *Where; DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where); if (!Value) { Value = new DIEDwarfLabel(Label); ValuesSet.InsertNode(Value, Where); Values.push_back(Value); - } else { - Value->IncUsage(); } Die->AddValue(Attribute, Form, Value); @@ -1254,15 +1267,13 @@ public: void AddObjectLabel(DIE *Die, unsigned Attribute, unsigned Form, const std::string &Label) { FoldingSetNodeID ID; - ID.AddString(Label); + DIEObjectLabel::Profile(ID, Label); void *Where; DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where); if (!Value) { Value = new DIEObjectLabel(Label); ValuesSet.InsertNode(Value, Where); Values.push_back(Value); - } else { - Value->IncUsage(); } Die->AddValue(Attribute, Form, Value); @@ -1273,16 +1284,13 @@ public: void AddDelta(DIE *Die, unsigned Attribute, unsigned Form, const DWLabel &Hi, const DWLabel &Lo) { FoldingSetNodeID ID; - Hi.Profile(ID); - Lo.Profile(ID); + DIEDelta::Profile(ID, Hi, Lo); void *Where; DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where); if (!Value) { Value = new DIEDelta(Hi, Lo); ValuesSet.InsertNode(Value, Where); Values.push_back(Value); - } else { - Value->IncUsage(); } Die->AddValue(Attribute, Form, Value); @@ -1307,8 +1315,9 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } else { - Value->IncUsage(); + // Already exists, reuse the previous one. delete Block; + Block = cast(Value); } Die->AddValue(Attribute, Block->BestForm(), Value); @@ -1331,7 +1340,7 @@ private: /// provided. void AddAddress(DIE *Die, unsigned Attribute, const MachineLocation &Location) { - unsigned Reg = RI->getDwarfRegNum(Location.getRegister()); + unsigned Reg = RI->getDwarfRegNum(Location.getRegister(), false); DIEBlock *Block = new DIEBlock(); if (Location.isRegister()) { @@ -1386,7 +1395,7 @@ private: /// DIE *ConstructPointerType(CompileUnit *Unit, const std::string &Name) { DIE Buffer(DW_TAG_pointer_type); - AddUInt(&Buffer, DW_AT_byte_size, 0, TAI->getAddressSize()); + AddUInt(&Buffer, DW_AT_byte_size, 0, TD->getPointerSize()); if (!Name.empty()) AddString(&Buffer, DW_AT_name, DW_FORM_string, Name); return Unit->AddDie(Buffer); } @@ -1395,14 +1404,13 @@ private: /// void AddType(DIE *Entity, TypeDesc *TyDesc, CompileUnit *Unit) { if (!TyDesc) { - AddBasicType(Entity, Unit, "", DW_ATE_signed, 4); + AddBasicType(Entity, Unit, "", DW_ATE_signed, sizeof(int32_t)); } else { // Check for pre-existence. DIEntry *&Slot = Unit->getDIEntrySlotFor(TyDesc); // If it exists then use the existing value. if (Slot) { - Slot->IncUsage(); Entity->AddValue(DW_AT_type, DW_FORM_ref4, Slot); return; } @@ -1444,8 +1452,12 @@ private: Buffer.setTag(DW_TAG_base_type); AddUInt(&Buffer, DW_AT_encoding, DW_FORM_data1, BasicTy->getEncoding()); } else if (DerivedTypeDesc *DerivedTy = dyn_cast(TyDesc)) { - // Pointers, tyepdefs et al. - Buffer.setTag(DerivedTy->getTag()); + // Fetch tag. + unsigned Tag = DerivedTy->getTag(); + // FIXME - Workaround for templates. + if (Tag == DW_TAG_inheritance) Tag = DW_TAG_reference_type; + // Pointers, typedefs et al. + Buffer.setTag(Tag); // Map to main type, void will not have a type. if (TypeDesc *FromTy = DerivedTy->getFromType()) AddType(&Buffer, FromTy, Unit); @@ -1474,7 +1486,8 @@ private: Size = 0; // Construct an anonymous type for index type. - DIE *IndexTy = ConstructBasicType(Unit, "", DW_ATE_signed, 4); + DIE *IndexTy = ConstructBasicType(Unit, "", DW_ATE_signed, + sizeof(int32_t)); // Add subranges to array type. for(unsigned i = 0, N = Elements.size(); i < N; ++i) { @@ -1508,7 +1521,6 @@ private: // Extract the basic information. const std::string &Name = MemberDesc->getName(); - TypeDesc *MemTy = MemberDesc->getFromType(); uint64_t Size = MemberDesc->getSize(); uint64_t Align = MemberDesc->getAlign(); uint64_t Offset = MemberDesc->getOffset(); @@ -1527,10 +1539,19 @@ private: uint64_t FieldAlign = Align; uint64_t FieldOffset = Offset; - if (TypeDesc *FromTy = MemberDesc->getFromType()) { - AddType(Member, FromTy, Unit); - FieldSize = FromTy->getSize(); - FieldAlign = FromTy->getSize(); + // Set the member type. + TypeDesc *FromTy = MemberDesc->getFromType(); + AddType(Member, FromTy, Unit); + + // Walk up typedefs until a real size is found. + while (FromTy) { + if (FromTy->getTag() != DW_TAG_typedef) { + FieldSize = FromTy->getSize(); + FieldAlign = FromTy->getSize(); + break; + } + + FromTy = cast(FromTy)->getFromType(); } // Unless we have a bit field. @@ -1577,11 +1598,13 @@ private: DIE *Static = new DIE(DW_TAG_variable); // Add name and mangled name. - const std::string &Name = StaticDesc->getDisplayName(); - const std::string &MangledName = StaticDesc->getName(); + const std::string &Name = StaticDesc->getName(); + const std::string &LinkageName = StaticDesc->getLinkageName(); AddString(Static, DW_AT_name, DW_FORM_string, Name); - AddString(Static, DW_AT_MIPS_linkage_name, DW_FORM_string, - MangledName); + if (!LinkageName.empty()) { + AddString(Static, DW_AT_MIPS_linkage_name, DW_FORM_string, + LinkageName); + } // Add location. AddSourceLine(Static, StaticDesc->getFile(), StaticDesc->getLine()); @@ -1591,7 +1614,8 @@ private: AddType(Static, StaticTy, Unit); // Add flags. - AddUInt(Static, DW_AT_external, DW_FORM_flag, 1); + if (!StaticDesc->isStatic()) + AddUInt(Static, DW_AT_external, DW_FORM_flag, 1); AddUInt(Static, DW_AT_declaration, DW_FORM_flag, 1); Buffer.AddChild(Static); @@ -1603,17 +1627,15 @@ private: DIE *Method = new DIE(DW_TAG_subprogram); // Add name and mangled name. - const std::string &Name = MethodDesc->getDisplayName(); - const std::string &MangledName = MethodDesc->getName(); - bool IsCTor = false; + const std::string &Name = MethodDesc->getName(); + const std::string &LinkageName = MethodDesc->getLinkageName(); + + AddString(Method, DW_AT_name, DW_FORM_string, Name); + bool IsCTor = TyDesc->getName() == Name; - if (Name.empty()) { - AddString(Method, DW_AT_name, DW_FORM_string, MangledName); - IsCTor = TyDesc->getName() == MangledName; - } else { - AddString(Method, DW_AT_name, DW_FORM_string, Name); + if (!LinkageName.empty()) { AddString(Method, DW_AT_MIPS_linkage_name, DW_FORM_string, - MangledName); + LinkageName); } // Add location. @@ -1641,7 +1663,8 @@ private: } // Add flags. - AddUInt(Method, DW_AT_external, DW_FORM_flag, 1); + if (!MethodDesc->isStatic()) + AddUInt(Method, DW_AT_external, DW_FORM_flag, 1); AddUInt(Method, DW_AT_declaration, DW_FORM_flag, 1); Buffer.AddChild(Method); @@ -1695,8 +1718,11 @@ private: CompileUnit *NewCompileUnit(CompileUnitDesc *UnitDesc, unsigned ID) { // Construct debug information entry. DIE *Die = new DIE(DW_TAG_compile_unit); - AddDelta(Die, DW_AT_stmt_list, DW_FORM_data4, DWLabel("section_line", 0), - DWLabel("section_line", 0)); + if (TAI->isAbsoluteDebugSectionOffsets()) + AddLabel(Die, DW_AT_stmt_list, DW_FORM_data4, DWLabel("section_line", 0)); + else + AddDelta(Die, DW_AT_stmt_list, DW_FORM_data4, DWLabel("section_line", 0), + DWLabel("section_line", 0)); AddString(Die, DW_AT_producer, DW_FORM_string, UnitDesc->getProducer()); AddUInt (Die, DW_AT_language, DW_FORM_data1, UnitDesc->getLanguage()); AddString(Die, DW_AT_name, DW_FORM_string, UnitDesc->getFileName()); @@ -1711,15 +1737,18 @@ private: return Unit; } + /// GetBaseCompileUnit - Get the main compile unit. + /// + CompileUnit *GetBaseCompileUnit() const { + CompileUnit *Unit = CompileUnits[0]; + assert(Unit && "Missing compile unit."); + return Unit; + } + /// FindCompileUnit - Get the compile unit for the given descriptor. /// CompileUnit *FindCompileUnit(CompileUnitDesc *UnitDesc) { -#if 1 - // FIXME - Using only one compile unit. Needs to me fixed at the FE. - CompileUnit *Unit = CompileUnits[0]; -#else CompileUnit *Unit = DescToUnitMap[UnitDesc]; -#endif assert(Unit && "Missing compile unit."); return Unit; } @@ -1730,7 +1759,7 @@ private: // Get the compile unit context. CompileUnitDesc *UnitDesc = static_cast(GVD->getContext()); - CompileUnit *Unit = FindCompileUnit(UnitDesc); + CompileUnit *Unit = GetBaseCompileUnit(); // Check for pre-existence. DIE *&Slot = Unit->getDieMapSlotFor(GVD); @@ -1739,31 +1768,28 @@ private: // Get the global variable itself. GlobalVariable *GV = GVD->getGlobalVariable(); - const std::string &Name = GVD->hasMangledName() ? GVD->getDisplayName() - : GVD->getName(); - const std::string &MangledName = GVD->hasMangledName() ? GVD->getName() - : ""; + const std::string &Name = GVD->getName(); + const std::string &FullName = GVD->getFullName(); + const std::string &LinkageName = GVD->getLinkageName(); // Create the global's variable DIE. DIE *VariableDie = new DIE(DW_TAG_variable); AddString(VariableDie, DW_AT_name, DW_FORM_string, Name); - if (!MangledName.empty()) { + if (!LinkageName.empty()) { AddString(VariableDie, DW_AT_MIPS_linkage_name, DW_FORM_string, - MangledName); + LinkageName); } - AddType(VariableDie, GVD->getType(), Unit); - AddUInt(VariableDie, DW_AT_external, DW_FORM_flag, 1); + AddType(VariableDie, GVD->getType(), Unit); + if (!GVD->isStatic()) + AddUInt(VariableDie, DW_AT_external, DW_FORM_flag, 1); // Add source line info if available. AddSourceLine(VariableDie, UnitDesc, GVD->getLine()); - // Work up linkage name. - const std::string LinkageName = Asm->getGlobalLinkName(GV); - // Add address. DIEBlock *Block = new DIEBlock(); AddUInt(Block, 0, DW_FORM_data1, DW_OP_addr); - AddObjectLabel(Block, 0, DW_FORM_udata, LinkageName); - AddBlock(VariableDie, DW_AT_location, 0, Block); + AddObjectLabel(Block, 0, DW_FORM_udata, Asm->getGlobalLinkName(GV)); + AddBlock(VariableDie, DW_AT_location, 0, Block); // Add to map. Slot = VariableDie; @@ -1773,7 +1799,7 @@ private: // Expose as global. // FIXME - need to check external flag. - Unit->AddGlobal(Name, VariableDie); + Unit->AddGlobal(FullName, VariableDie); return VariableDie; } @@ -1784,27 +1810,26 @@ private: // Get the compile unit context. CompileUnitDesc *UnitDesc = static_cast(SPD->getContext()); - CompileUnit *Unit = FindCompileUnit(UnitDesc); + CompileUnit *Unit = GetBaseCompileUnit(); // Check for pre-existence. DIE *&Slot = Unit->getDieMapSlotFor(SPD); if (Slot) return Slot; // Gather the details (simplify add attribute code.) - const std::string &Name = SPD->hasMangledName() ? SPD->getDisplayName() - : SPD->getName(); - const std::string &MangledName = SPD->hasMangledName() ? SPD->getName() - : ""; - unsigned IsExternal = SPD->isStatic() ? 0 : 1; + const std::string &Name = SPD->getName(); + const std::string &FullName = SPD->getFullName(); + const std::string &LinkageName = SPD->getLinkageName(); DIE *SubprogramDie = new DIE(DW_TAG_subprogram); AddString(SubprogramDie, DW_AT_name, DW_FORM_string, Name); - if (!MangledName.empty()) { + if (!LinkageName.empty()) { AddString(SubprogramDie, DW_AT_MIPS_linkage_name, DW_FORM_string, - MangledName); + LinkageName); } if (SPD->getType()) AddType(SubprogramDie, SPD->getType(), Unit); - AddUInt(SubprogramDie, DW_AT_external, DW_FORM_flag, IsExternal); + if (!SPD->isStatic()) + AddUInt(SubprogramDie, DW_AT_external, DW_FORM_flag, 1); AddUInt(SubprogramDie, DW_AT_prototyped, DW_FORM_flag, 1); // Add source line info if available. @@ -1817,7 +1842,7 @@ private: Unit->getDie()->AddChild(SubprogramDie); // Expose as global. - Unit->AddGlobal(Name, SubprogramDie); + Unit->AddGlobal(FullName, SubprogramDie); return SubprogramDie; } @@ -1850,16 +1875,18 @@ private: // Add variable address. MachineLocation Location; - RI->getLocation(*MF, DV->getFrameIndex(), Location); + Location.set(RI->getFrameRegister(*MF), + RI->getFrameIndexOffset(*MF, DV->getFrameIndex())); AddAddress(VariableDie, DW_AT_location, Location); - + return VariableDie; } /// ConstructScope - Construct the components of a scope. /// void ConstructScope(DebugScope *ParentScope, - DIE *ParentDie, CompileUnit *Unit) { + unsigned ParentStartID, unsigned ParentEndID, + DIE *ParentDie, CompileUnit *Unit) { // Add variables to scope. std::vector &Variables = ParentScope->getVariables(); for (unsigned i = 0, N = Variables.size(); i < N; ++i) { @@ -1875,34 +1902,39 @@ private: // FIXME - Ignore inlined functions for the time being. if (!Scope->getParent()) continue; - unsigned StartID = Scope->getStartLabelID(); - unsigned EndID = Scope->getEndLabelID(); - - // Throw out scope if block is discarded. - if (StartID && !DebugInfo->isLabelValid(StartID)) continue; - if (EndID && !DebugInfo->isLabelValid(EndID)) continue; - - DIE *ScopeDie = new DIE(DW_TAG_lexical_block); + unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID()); + unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID()); + + // Ignore empty scopes. + if (StartID == EndID && StartID != 0) continue; + if (Scope->getScopes().empty() && Scope->getVariables().empty()) continue; - // Add the scope bounds. - if (StartID) { - AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr, - DWLabel("loc", StartID)); + if (StartID == ParentStartID && EndID == ParentEndID) { + // Just add stuff to the parent scope. + ConstructScope(Scope, ParentStartID, ParentEndID, ParentDie, Unit); } else { - AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr, - DWLabel("func_begin", SubprogramCount)); - } - if (EndID) { - AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr, - DWLabel("loc", EndID)); - } else { - AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr, - DWLabel("func_end", SubprogramCount)); + DIE *ScopeDie = new DIE(DW_TAG_lexical_block); + + // Add the scope bounds. + if (StartID) { + AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr, + DWLabel("label", StartID)); + } else { + AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr, + DWLabel("func_begin", SubprogramCount)); + } + if (EndID) { + AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr, + DWLabel("label", EndID)); + } else { + AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr, + DWLabel("func_end", SubprogramCount)); + } + + // Add the scope contents. + ConstructScope(Scope, StartID, EndID, ScopeDie, Unit); + ParentDie->AddChild(ScopeDie); } - - // Add the scope contents. - ConstructScope(Scope, ScopeDie, Unit); - ParentDie->AddChild(ScopeDie); } } @@ -1916,9 +1948,7 @@ private: SubprogramDesc *SPD = cast(RootScope->getDesc()); // Get the compile unit context. - CompileUnitDesc *UnitDesc = - static_cast(SPD->getContext()); - CompileUnit *Unit = FindCompileUnit(UnitDesc); + CompileUnit *Unit = GetBaseCompileUnit(); // Get the subprogram die. DIE *SPDie = Unit->getDieMapSlotFor(SPD); @@ -1931,8 +1961,8 @@ private: DWLabel("func_end", SubprogramCount)); MachineLocation Location(RI->getFrameRegister(*MF)); AddAddress(SPDie, DW_AT_frame_base, Location); - - ConstructScope(RootScope, SPDie, Unit); + + ConstructScope(RootScope, 0, 0, SPDie, Unit); } /// EmitInitial - Emit initial Dwarf declarations. This is necessary for cc @@ -1943,9 +1973,9 @@ private: didInitial = true; // Dwarf sections base addresses. - if (TAI->getDwarfRequiresFrameSection()) { + if (TAI->doesDwarfRequireFrameSection()) { Asm->SwitchToDataSection(TAI->getDwarfFrameSection()); - EmitLabel("section_frame", 0); + EmitLabel("section_debug_frame", 0); } Asm->SwitchToDataSection(TAI->getDwarfInfoSection()); EmitLabel("section_info", 0); @@ -1970,29 +2000,26 @@ private: EmitLabel("text_begin", 0); Asm->SwitchToDataSection(TAI->getDataSection()); EmitLabel("data_begin", 0); - - // Emit common frame information. - EmitInitialDebugFrame(); } /// EmitDIE - Recusively Emits a debug information entry. /// - void EmitDIE(DIE *Die) const { + void EmitDIE(DIE *Die) { // Get the abbreviation for this DIE. unsigned AbbrevNumber = Die->getAbbrevNumber(); const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; - O << "\n"; + Asm->EOL(); // Emit the code (index) for the abbreviation. - EmitULEB128Bytes(AbbrevNumber); - EOL(std::string("Abbrev [" + - utostr(AbbrevNumber) + - "] 0x" + utohexstr(Die->getOffset()) + - ":0x" + utohexstr(Die->getSize()) + " " + - TagString(Abbrev->getTag()))); - - const std::vector &Values = Die->getValues(); + Asm->EmitULEB128Bytes(AbbrevNumber); + Asm->EOL(std::string("Abbrev [" + + utostr(AbbrevNumber) + + "] 0x" + utohexstr(Die->getOffset()) + + ":0x" + utohexstr(Die->getSize()) + " " + + TagString(Abbrev->getTag()))); + + std::vector &Values = Die->getValues(); const std::vector &AbbrevData = Abbrev->getData(); // Emit the DIE attribute values. @@ -2003,7 +2030,7 @@ private: switch (Attr) { case DW_AT_sibling: { - EmitInt32(Die->SiblingOffset()); + Asm->EmitInt32(Die->SiblingOffset()); break; } default: { @@ -2013,7 +2040,7 @@ private: } } - EOL(AttributeString(Attr)); + Asm->EOL(AttributeString(Attr)); } // Emit the DIE children if any. @@ -2024,7 +2051,7 @@ private: EmitDIE(Children[j]); } - EmitInt8(0); EOL("End Of Children Mark"); + Asm->EmitInt8(0); Asm->EOL("End Of Children Mark"); } } @@ -2048,7 +2075,7 @@ private: Die->setOffset(Offset); // Start the size with the size of abbreviation code. - Offset += SizeULEB128(AbbrevNumber); + Offset += Asm->SizeULEB128(AbbrevNumber); const std::vector &Values = Die->getValues(); const std::vector &AbbrevData = Abbrev->getData(); @@ -2079,131 +2106,48 @@ private: /// SizeAndOffsets - Compute the size and offset of all the DIEs. /// void SizeAndOffsets() { - // Process each compile unit. - for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) { - CompileUnit *Unit = CompileUnits[i]; - if (Unit->hasContent()) { - // Compute size of compile 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) - SizeAndOffsetDie(Unit->getDie(), Offset, (i + 1) == N); - } - } - } - - /// EmitFrameMoves - Emit frame instructions to describe the layout of the - /// frame. - void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID, - std::vector &Moves) { - for (unsigned i = 0, N = Moves.size(); i < N; ++i) { - MachineMove *Move = Moves[i]; - unsigned LabelID = Move->getLabelID(); - - // Throw out move if the label is invalid. - if (LabelID && !DebugInfo->isLabelValid(LabelID)) continue; - - const MachineLocation &Dst = Move->getDestination(); - const MachineLocation &Src = Move->getSource(); - - // Advance row if new location. - if (BaseLabel && LabelID && BaseLabelID != LabelID) { - EmitInt8(DW_CFA_advance_loc4); - EOL("DW_CFA_advance_loc4"); - EmitDifference("loc", LabelID, BaseLabel, BaseLabelID); - EOL(""); - - BaseLabelID = LabelID; - BaseLabel = "loc"; - } - - int stackGrowth = - Asm->TM.getFrameInfo()->getStackGrowthDirection() == - TargetFrameInfo::StackGrowsUp ? - TAI->getAddressSize() : -TAI->getAddressSize(); - - // If advancing cfa. - if (Dst.isRegister() && Dst.getRegister() == MachineLocation::VirtualFP) { - if (!Src.isRegister()) { - if (Src.getRegister() == MachineLocation::VirtualFP) { - EmitInt8(DW_CFA_def_cfa_offset); - EOL("DW_CFA_def_cfa_offset"); - } else { - EmitInt8(DW_CFA_def_cfa); - EOL("DW_CFA_def_cfa"); - - EmitULEB128Bytes(RI->getDwarfRegNum(Src.getRegister())); - EOL("Register"); - } - - int Offset = Src.getOffset() / stackGrowth; - - EmitULEB128Bytes(Offset); - EOL("Offset"); - } else { - assert(0 && "Machine move no supported yet."); - } - } else { - unsigned Reg = RI->getDwarfRegNum(Src.getRegister()); - int Offset = Dst.getOffset() / stackGrowth; - - if (Offset < 0) { - EmitInt8(DW_CFA_offset_extended_sf); - EOL("DW_CFA_offset_extended_sf"); - EmitULEB128Bytes(Reg); - EOL("Reg"); - EmitSLEB128Bytes(Offset); - EOL("Offset"); - } else if (Reg < 64) { - EmitInt8(DW_CFA_offset + Reg); - EOL("DW_CFA_offset + Reg"); - EmitULEB128Bytes(Offset); - EOL("Offset"); - } else { - EmitInt8(DW_CFA_offset_extended); - EOL("DW_CFA_offset_extended"); - EmitULEB128Bytes(Reg); - EOL("Reg"); - EmitULEB128Bytes(Offset); - EOL("Offset"); - } - } - } + // Process base compile unit. + CompileUnit *Unit = GetBaseCompileUnit(); + // Compute size of compile 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) + SizeAndOffsetDie(Unit->getDie(), Offset, true); } /// EmitDebugInfo - Emit the debug info section. /// - void EmitDebugInfo() const { + void EmitDebugInfo() { // Start debug info section. Asm->SwitchToDataSection(TAI->getDwarfInfoSection()); - // Process each compile unit. - for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) { - CompileUnit *Unit = CompileUnits[i]; - - if (Unit->hasContent()) { - DIE *Die = Unit->getDie(); - // Emit the compile units header. - EmitLabel("info_begin", Unit->getID()); - // Emit size of content not including length itself - unsigned ContentSize = Die->getSize() + - sizeof(int16_t) + // DWARF version number - sizeof(int32_t) + // Offset Into Abbrev. Section - sizeof(int8_t); // Pointer Size (in bytes) - - EmitInt32(ContentSize); EOL("Length of Compilation Unit Info"); - EmitInt16(DWARF_VERSION); EOL("DWARF version number"); - EmitDifference("abbrev_begin", 0, "section_abbrev", 0); - EOL("Offset Into Abbrev. Section"); - EmitInt8(TAI->getAddressSize()); EOL("Address Size (in bytes)"); - - EmitDIE(Die); - EmitLabel("info_end", Unit->getID()); - } - - O << "\n"; - } + CompileUnit *Unit = GetBaseCompileUnit(); + DIE *Die = Unit->getDie(); + // Emit the compile units header. + EmitLabel("info_begin", Unit->getID()); + // Emit size of content not including length itself + unsigned ContentSize = Die->getSize() + + sizeof(int16_t) + // DWARF version number + sizeof(int32_t) + // Offset Into Abbrev. Section + sizeof(int8_t) + // Pointer Size (in bytes) + sizeof(int32_t); // FIXME - extra pad for gdb bug. + + Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info"); + Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number"); + EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false); + Asm->EOL("Offset Into Abbrev. Section"); + Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)"); + + EmitDIE(Die); + // FIXME - extra padding for gdb bug. + Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); + Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); + Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); + Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB"); + EmitLabel("info_end", Unit->getID()); + + Asm->EOL(); } /// EmitAbbreviations - Emit the abbreviation section. @@ -2222,23 +2166,32 @@ private: const DIEAbbrev *Abbrev = Abbreviations[i]; // Emit the abbrevations code (base 1 index.) - EmitULEB128Bytes(Abbrev->getNumber()); EOL("Abbreviation Code"); + Asm->EmitULEB128Bytes(Abbrev->getNumber()); + Asm->EOL("Abbreviation Code"); // Emit the abbreviations data. Abbrev->Emit(*this); - O << "\n"; + Asm->EOL(); } + // Mark end of abbreviations. + Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)"); + EmitLabel("abbrev_end", 0); - O << "\n"; + Asm->EOL(); } } /// EmitDebugLines - Emit source line information. /// - void EmitDebugLines() const { + void EmitDebugLines() { + // If there are no lines to emit (such as when we're using .loc directives + // to emit .debug_line information) don't emit a .debug_line header. + if (SectionSourceLines.empty()) + return; + // 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). @@ -2249,58 +2202,62 @@ private: // Construct the section header. - EmitDifference("line_end", 0, "line_begin", 0); - EOL("Length of Source Line Info"); + EmitDifference("line_end", 0, "line_begin", 0, true); + Asm->EOL("Length of Source Line Info"); EmitLabel("line_begin", 0); - EmitInt16(DWARF_VERSION); EOL("DWARF version number"); + Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number"); - EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0); - EOL("Prolog Length"); + EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true); + Asm->EOL("Prolog Length"); EmitLabel("line_prolog_begin", 0); - EmitInt8(1); EOL("Minimum Instruction Length"); + Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length"); - EmitInt8(1); EOL("Default is_stmt_start flag"); + Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag"); - EmitInt8(MinLineDelta); EOL("Line Base Value (Special Opcodes)"); + Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)"); - EmitInt8(MaxLineDelta); EOL("Line Range Value (Special Opcodes)"); + Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)"); - EmitInt8(-MinLineDelta); EOL("Special Opcode Base"); + Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base"); // Line number standard opcode encodings argument count - EmitInt8(0); EOL("DW_LNS_copy arg count"); - EmitInt8(1); EOL("DW_LNS_advance_pc arg count"); - EmitInt8(1); EOL("DW_LNS_advance_line arg count"); - EmitInt8(1); EOL("DW_LNS_set_file arg count"); - EmitInt8(1); EOL("DW_LNS_set_column arg count"); - EmitInt8(0); EOL("DW_LNS_negate_stmt arg count"); - EmitInt8(0); EOL("DW_LNS_set_basic_block arg count"); - EmitInt8(0); EOL("DW_LNS_const_add_pc arg count"); - EmitInt8(1); EOL("DW_LNS_fixed_advance_pc arg count"); - - const UniqueVector &Directories = DebugInfo->getDirectories(); + Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count"); + Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count"); + Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count"); + Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count"); + Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count"); + Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count"); + Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count"); + Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count"); + Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count"); + + const UniqueVector &Directories = MMI->getDirectories(); const UniqueVector - &SourceFiles = DebugInfo->getSourceFiles(); + &SourceFiles = MMI->getSourceFiles(); // Emit directories. for (unsigned DirectoryID = 1, NDID = Directories.size(); DirectoryID <= NDID; ++DirectoryID) { - EmitString(Directories[DirectoryID]); EOL("Directory"); + Asm->EmitString(Directories[DirectoryID]); Asm->EOL("Directory"); } - EmitInt8(0); EOL("End of directories"); + Asm->EmitInt8(0); Asm->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"); + Asm->EmitString(SourceFile.getName()); + Asm->EOL("Source"); + Asm->EmitULEB128Bytes(SourceFile.getDirectoryID()); + Asm->EOL("Directory #"); + Asm->EmitULEB128Bytes(0); + Asm->EOL("Mod date"); + Asm->EmitULEB128Bytes(0); + Asm->EOL("File size"); } - EmitInt8(0); EOL("End of files"); + Asm->EmitInt8(0); Asm->EOL("End of files"); EmitLabel("line_prolog_end", 0); @@ -2309,12 +2266,7 @@ private: // Isolate current sections line info. const std::vector &LineInfos = SectionSourceLines[j]; - if (DwarfVerbose) { - O << "\t" - << TAI->getCommentString() << " " - << "Section " - << SectionMap[j + 1].c_str() << "\n"; - } + Asm->EOL(std::string("Section ") + SectionMap[j + 1]); // Dwarf assumes we start with first line of first source file. unsigned Source = 1; @@ -2323,32 +2275,28 @@ private: // Construct rows of the address, source, line, column matrix. for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { const SourceLineInfo &LineInfo = LineInfos[i]; - unsigned LabelID = LineInfo.getLabelID(); - - // Source line labels are validated at the MachineDebugInfo level. + unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID()); + if (!LabelID) continue; - if (DwarfVerbose) { - unsigned SourceID = LineInfo.getSourceID(); - const SourceFileInfo &SourceFile = SourceFiles[SourceID]; - unsigned DirectoryID = SourceFile.getDirectoryID(); - O << "\t" - << TAI->getCommentString() << " " - << Directories[DirectoryID] - << SourceFile.getName() << ":" - << LineInfo.getLine() << "\n"; - } + unsigned SourceID = LineInfo.getSourceID(); + const SourceFileInfo &SourceFile = SourceFiles[SourceID]; + unsigned DirectoryID = SourceFile.getDirectoryID(); + Asm->EOL(Directories[DirectoryID] + + SourceFile.getName() + + ":" + + utostr_32(LineInfo.getLine())); // Define the line address. - EmitInt8(0); EOL("Extended Op"); - EmitInt8(4 + 1); EOL("Op size"); - EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address"); - EmitReference("loc", LabelID); EOL("Location label"); + Asm->EmitInt8(0); Asm->EOL("Extended Op"); + Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); + Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); + EmitReference("label", LabelID); Asm->EOL("Location label"); // If change of source, then switch to the new source. if (Source != LineInfo.getSourceID()) { Source = LineInfo.getSourceID(); - EmitInt8(DW_LNS_set_file); EOL("DW_LNS_set_file"); - EmitULEB128Bytes(Source); EOL("New Source"); + Asm->EmitInt8(DW_LNS_set_file); Asm->EOL("DW_LNS_set_file"); + Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source"); } // If change of line. @@ -2363,102 +2311,111 @@ private: // If delta is small enough and in range... if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { // ... then use fast opcode. - EmitInt8(Delta - MinLineDelta); EOL("Line Delta"); + Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta"); } else { // ... otherwise use long hand. - EmitInt8(DW_LNS_advance_line); EOL("DW_LNS_advance_line"); - EmitSLEB128Bytes(Offset); EOL("Line Offset"); - EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy"); + Asm->EmitInt8(DW_LNS_advance_line); Asm->EOL("DW_LNS_advance_line"); + Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset"); + Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy"); } } else { // Copy the previous row (different address or source) - EmitInt8(DW_LNS_copy); EOL("DW_LNS_copy"); + Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy"); } } // Define last address of section. - EmitInt8(0); EOL("Extended Op"); - EmitInt8(4 + 1); EOL("Op size"); - EmitInt8(DW_LNE_set_address); EOL("DW_LNE_set_address"); - EmitReference("section_end", j + 1); EOL("Section end label"); + Asm->EmitInt8(0); Asm->EOL("Extended Op"); + Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size"); + Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address"); + EmitReference("section_end", j + 1); Asm->EOL("Section end label"); // Mark end of matrix. - EmitInt8(0); EOL("DW_LNE_end_sequence"); - EmitULEB128Bytes(1); O << "\n"; - EmitInt8(1); O << "\n"; + Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence"); + Asm->EmitULEB128Bytes(1); Asm->EOL(); + Asm->EmitInt8(1); Asm->EOL(); } EmitLabel("line_end", 0); - O << "\n"; + Asm->EOL(); } - /// EmitInitialDebugFrame - Emit common frame info into a debug frame section. + /// EmitCommonDebugFrame - Emit common frame info into a debug frame section. /// - void EmitInitialDebugFrame() { - if (!TAI->getDwarfRequiresFrameSection()) + void EmitCommonDebugFrame() { + if (!TAI->doesDwarfRequireFrameSection()) return; int stackGrowth = Asm->TM.getFrameInfo()->getStackGrowthDirection() == TargetFrameInfo::StackGrowsUp ? - TAI->getAddressSize() : -TAI->getAddressSize(); + TD->getPointerSize() : -TD->getPointerSize(); // Start the dwarf frame section. Asm->SwitchToDataSection(TAI->getDwarfFrameSection()); - EmitLabel("frame_common", 0); - EmitDifference("frame_common_end", 0, - "frame_common_begin", 0); - EOL("Length of Common Information Entry"); - - EmitLabel("frame_common_begin", 0); - EmitInt32(DW_CIE_ID); EOL("CIE Identifier Tag"); - EmitInt8(DW_CIE_VERSION); EOL("CIE Version"); - EmitString(""); EOL("CIE Augmentation"); - EmitULEB128Bytes(1); EOL("CIE Code Alignment Factor"); - EmitSLEB128Bytes(stackGrowth); EOL("CIE Data Alignment Factor"); - EmitInt8(RI->getDwarfRegNum(RI->getRARegister())); EOL("CIE RA Column"); - - std::vector Moves; + EmitLabel("debug_frame_common", 0); + EmitDifference("debug_frame_common_end", 0, + "debug_frame_common_begin", 0, true); + Asm->EOL("Length of Common Information Entry"); + + EmitLabel("debug_frame_common_begin", 0); + Asm->EmitInt32((int)DW_CIE_ID); + Asm->EOL("CIE Identifier Tag"); + Asm->EmitInt8(DW_CIE_VERSION); + Asm->EOL("CIE Version"); + Asm->EmitString(""); + Asm->EOL("CIE Augmentation"); + Asm->EmitULEB128Bytes(1); + Asm->EOL("CIE Code Alignment Factor"); + Asm->EmitSLEB128Bytes(stackGrowth); + Asm->EOL("CIE Data Alignment Factor"); + Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); + Asm->EOL("CIE RA Column"); + + std::vector Moves; RI->getInitialFrameState(Moves); - EmitFrameMoves(NULL, 0, Moves); - for (unsigned i = 0, N = Moves.size(); i < N; ++i) delete Moves[i]; - EmitAlign(2); - EmitLabel("frame_common_end", 0); + EmitFrameMoves(NULL, 0, Moves, false); + + Asm->EmitAlignment(2); + EmitLabel("debug_frame_common_end", 0); - O << "\n"; + Asm->EOL(); } /// EmitFunctionDebugFrame - Emit per function frame info into a debug frame /// section. - void EmitFunctionDebugFrame() { + void EmitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { + if (!TAI->doesDwarfRequireFrameSection()) + return; + // Start the dwarf frame section. Asm->SwitchToDataSection(TAI->getDwarfFrameSection()); - EmitDifference("frame_end", SubprogramCount, - "frame_begin", SubprogramCount); - EOL("Length of Frame Information Entry"); - - EmitLabel("frame_begin", SubprogramCount); + EmitDifference("debug_frame_end", DebugFrameInfo.Number, + "debug_frame_begin", DebugFrameInfo.Number, true); + Asm->EOL("Length of Frame Information Entry"); - EmitDifference("frame_common", 0, "section_frame", 0); - EOL("FDE CIE offset"); + EmitLabel("debug_frame_begin", DebugFrameInfo.Number); - EmitReference("func_begin", SubprogramCount); EOL("FDE initial location"); - EmitDifference("func_end", SubprogramCount, - "func_begin", SubprogramCount); - EOL("FDE address range"); - - std::vector &Moves = DebugInfo->getFrameMoves(); + EmitSectionOffset("debug_frame_common", "section_debug_frame", + 0, 0, true, false); + Asm->EOL("FDE CIE offset"); + + EmitReference("func_begin", DebugFrameInfo.Number); + Asm->EOL("FDE initial location"); + EmitDifference("func_end", DebugFrameInfo.Number, + "func_begin", DebugFrameInfo.Number); + Asm->EOL("FDE address range"); - EmitFrameMoves("func_begin", SubprogramCount, Moves); + EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves, false); - EmitAlign(2); - EmitLabel("frame_end", SubprogramCount); + Asm->EmitAlignment(2); + EmitLabel("debug_frame_end", DebugFrameInfo.Number); - O << "\n"; + Asm->EOL(); } /// EmitDebugPubNames - Emit visible names into a debug pubnames section. @@ -2467,43 +2424,39 @@ private: // Start the dwarf pubnames section. Asm->SwitchToDataSection(TAI->getDwarfPubNamesSection()); - // Process each compile unit. - for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) { - CompileUnit *Unit = CompileUnits[i]; - - if (Unit->hasContent()) { - EmitDifference("pubnames_end", Unit->getID(), - "pubnames_begin", Unit->getID()); - EOL("Length of Public Names Info"); - - EmitLabel("pubnames_begin", Unit->getID()); - - EmitInt16(DWARF_VERSION); EOL("DWARF Version"); - - EmitDifference("info_begin", Unit->getID(), "section_info", 0); - EOL("Offset of Compilation Unit Info"); + CompileUnit *Unit = GetBaseCompileUnit(); + + EmitDifference("pubnames_end", Unit->getID(), + "pubnames_begin", Unit->getID(), true); + Asm->EOL("Length of Public Names Info"); + + EmitLabel("pubnames_begin", Unit->getID()); + + Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF Version"); - EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID()); - EOL("Compilation Unit Length"); - - std::map &Globals = Unit->getGlobals(); - - for (std::map::iterator GI = Globals.begin(), - GE = Globals.end(); - GI != GE; ++GI) { - const std::string &Name = GI->first; - DIE * Entity = GI->second; - - EmitInt32(Entity->getOffset()); EOL("DIE offset"); - EmitString(Name); EOL("External Name"); - } - - EmitInt32(0); EOL("End Mark"); - EmitLabel("pubnames_end", Unit->getID()); + EmitSectionOffset("info_begin", "section_info", + Unit->getID(), 0, true, false); + Asm->EOL("Offset of Compilation Unit Info"); + + EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),true); + Asm->EOL("Compilation Unit Length"); + + std::map &Globals = Unit->getGlobals(); + + for (std::map::iterator GI = Globals.begin(), + GE = Globals.end(); + GI != GE; ++GI) { + const std::string &Name = GI->first; + DIE * Entity = GI->second; - O << "\n"; - } + Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset"); + Asm->EmitString(Name); Asm->EOL("External Name"); } + + Asm->EmitInt32(0); Asm->EOL("End Mark"); + EmitLabel("pubnames_end", Unit->getID()); + + Asm->EOL(); } /// EmitDebugStr - Emit visible names into a debug str section. @@ -2521,10 +2474,10 @@ private: EmitLabel("string", StringID); // Emit the string itself. const std::string &String = StringPool[StringID]; - EmitString(String); O << "\n"; + Asm->EmitString(String); Asm->EOL(); } - O << "\n"; + Asm->EOL(); } } @@ -2534,7 +2487,7 @@ private: // Start the dwarf loc section. Asm->SwitchToDataSection(TAI->getDwarfLocSection()); - O << "\n"; + Asm->EOL(); } /// EmitDebugARanges - Emit visible names into a debug aranges section. @@ -2545,37 +2498,32 @@ private: // FIXME - Mock up #if 0 - // Process each compile unit. - for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) { - CompileUnit *Unit = CompileUnits[i]; + CompileUnit *Unit = GetBaseCompileUnit(); - if (Unit->hasContent()) { - // Don't include size of length - EmitInt32(0x1c); EOL("Length of Address Ranges Info"); - - EmitInt16(DWARF_VERSION); EOL("Dwarf Version"); - - EmitReference("info_begin", Unit->getID()); - EOL("Offset of Compilation Unit Info"); + // Don't include size of length + Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info"); + + Asm->EmitInt16(DWARF_VERSION); Asm->EOL("Dwarf Version"); + + EmitReference("info_begin", Unit->getID()); + Asm->EOL("Offset of Compilation Unit Info"); - EmitInt8(TAI->getAddressSize()); EOL("Size of Address"); + Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address"); - EmitInt8(0); EOL("Size of Segment Descriptor"); + Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor"); - EmitInt16(0); EOL("Pad (1)"); - EmitInt16(0); EOL("Pad (2)"); + Asm->EmitInt16(0); Asm->EOL("Pad (1)"); + Asm->EmitInt16(0); Asm->EOL("Pad (2)"); - // Range 1 - EmitReference("text_begin", 0); EOL("Address"); - EmitDifference("text_end", 0, "text_begin", 0); EOL("Length"); + // Range 1 + EmitReference("text_begin", 0); Asm->EOL("Address"); + EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length"); - EmitInt32(0); EOL("EOM (1)"); - EmitInt32(0); EOL("EOM (2)"); - - O << "\n"; - } - } + Asm->EmitInt32(0); Asm->EOL("EOM (1)"); + Asm->EmitInt32(0); Asm->EOL("EOM (2)"); #endif + + Asm->EOL(); } /// EmitDebugRanges - Emit visible names into a debug ranges section. @@ -2584,7 +2532,7 @@ private: // Start the dwarf ranges section. Asm->SwitchToDataSection(TAI->getDwarfRangesSection()); - O << "\n"; + Asm->EOL(); } /// EmitDebugMacInfo - Emit visible names into a debug macinfo section. @@ -2593,16 +2541,17 @@ private: // Start the dwarf macinfo section. Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection()); - O << "\n"; + Asm->EOL(); } /// ConstructCompileUnitDIEs - Create a compile unit DIE for each source and /// header file. void ConstructCompileUnitDIEs() { - const UniqueVector CUW = DebugInfo->getCompileUnits(); + const UniqueVector CUW = MMI->getCompileUnits(); for (unsigned i = 1, N = CUW.size(); i <= N; ++i) { - CompileUnit *Unit = NewCompileUnit(CUW[i], i); + unsigned ID = MMI->RecordSource(CUW[i]); + CompileUnit *Unit = NewCompileUnit(CUW[i], ID); CompileUnits.push_back(Unit); } } @@ -2611,7 +2560,7 @@ private: /// global variables. void ConstructGlobalDIEs() { std::vector GlobalVariables = - DebugInfo->getAnchoredDescriptors(*M); + MMI->getAnchoredDescriptors(*M); for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) { GlobalVariableDesc *GVD = GlobalVariables[i]; @@ -2623,7 +2572,7 @@ private: /// subprograms. void ConstructSubprogramDIEs() { std::vector Subprograms = - DebugInfo->getAnchoredDescriptors(*M); + MMI->getAnchoredDescriptors(*M); for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) { SubprogramDesc *SPD = Subprograms[i]; @@ -2631,26 +2580,12 @@ private: } } - /// ShouldEmitDwarf - Returns true if Dwarf declarations should be made. - /// - bool ShouldEmitDwarf() const { return shouldEmit; } - public: //===--------------------------------------------------------------------===// // Main entry points. // - Dwarf(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T) - : O(OS) - , Asm(A) - , TAI(T) - , TD(Asm->TM.getTargetData()) - , RI(Asm->TM.getRegisterInfo()) - , M(NULL) - , MF(NULL) - , DebugInfo(NULL) - , didInitial(false) - , shouldEmit(false) - , SubprogramCount(0) + DwarfDebug(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T) + : Dwarf(OS, A, T, "dbg") , CompileUnits() , AbbreviationsSet(InitAbbreviationsSetSize) , Abbreviations() @@ -2660,30 +2595,25 @@ public: , DescToUnitMap() , SectionMap() , SectionSourceLines() + , didInitial(false) + , shouldEmit(false) { } - virtual ~Dwarf() { + virtual ~DwarfDebug() { for (unsigned i = 0, N = CompileUnits.size(); i < N; ++i) delete CompileUnits[i]; for (unsigned j = 0, M = Values.size(); j < M; ++j) delete Values[j]; } - // Accessors. - // - const TargetAsmInfo *getTargetAsmInfo() const { return TAI; } - - /// SetDebugInfo - Set DebugInfo when it's known that pass manager has - /// created it. Set by the target AsmPrinter. - void SetDebugInfo(MachineDebugInfo *DI) { + /// SetModuleInfo - Set machine module information when it's known that pass + /// manager has created it. Set by the target AsmPrinter. + void SetModuleInfo(MachineModuleInfo *mmi) { // Make sure initial declarations are made. - if (!DebugInfo && DI->hasInfo()) { - DebugInfo = DI; + if (!MMI && mmi->hasDebugInfo()) { + MMI = mmi; shouldEmit = true; - // Emit initial sections - EmitInitial(); - // Create all the compile unit DIEs. ConstructCompileUnitDIEs(); @@ -2694,7 +2624,24 @@ public: ConstructSubprogramDIEs(); // Prime section data. - SectionMap.insert(std::string("\t") + TAI->getTextSection()); + SectionMap.insert(TAI->getTextSection()); + + // Print out .file directives to specify files for .loc directives. These + // are printed out early so that they precede any .loc directives. + if (TAI->hasDotLocAndDotFile()) { + const UniqueVector &SourceFiles = MMI->getSourceFiles(); + const UniqueVector &Directories = MMI->getDirectories(); + for (unsigned i = 1, e = SourceFiles.size(); i <= e; ++i) { + sys::Path FullPath(Directories[SourceFiles[i].getDirectoryID()]); + bool AppendOk = FullPath.appendComponent(SourceFiles[i].getName()); + assert(AppendOk && "Could not append filename to directory!"); + Asm->EmitFile(i, FullPath.toString()); + Asm->EOL(); + } + } + + // Emit initial sections + EmitInitial(); } } @@ -2704,14 +2651,12 @@ public: this->M = M; if (!ShouldEmitDwarf()) return; - EOL("Dwarf Begin Module"); } /// EndModule - Emit all Dwarf sections that should come after the content. /// void EndModule() { if (!ShouldEmitDwarf()) return; - EOL("Dwarf End Module"); // Standard sections final addresses. Asm->SwitchToTextSection(TAI->getTextSection()); @@ -2724,7 +2669,15 @@ public: Asm->SwitchToTextSection(SectionMap[i].c_str()); EmitLabel("section_end", i); } - + + // Emit common frame information. + EmitCommonDebugFrame(); + + // Emit function debug frame information + for (std::vector::iterator I = DebugFrames.begin(), + E = DebugFrames.end(); I != E; ++I) + EmitFunctionDebugFrame(*I); + // Compute DIE offsets and sizes. SizeAndOffsets(); @@ -2762,26 +2715,29 @@ public: this->MF = MF; if (!ShouldEmitDwarf()) return; - EOL("Dwarf Begin Function"); // Begin accumulating function debug information. - DebugInfo->BeginFunction(MF); + MMI->BeginFunction(MF); // Assumes in correct section after the entry point. EmitLabel("func_begin", ++SubprogramCount); - } + // Emit label for the implicitly defined dbg.stoppoint at the start of + // the function. + const SourceLineInfo &LineInfo = MMI->getSourceLines()[0]; + Asm->printLabel(LineInfo.getLabelID()); + } + /// EndFunction - Gather and emit post-function debug information. /// void EndFunction() { if (!ShouldEmitDwarf()) return; - EOL("Dwarf End Function"); // Define end label for subprogram. EmitLabel("func_end", SubprogramCount); // Get function line info. - const std::vector &LineInfos = DebugInfo->getSourceLines(); + const std::vector &LineInfos = MMI->getSourceLines(); if (!LineInfos.empty()) { // Get section line info. @@ -2794,16 +2750,689 @@ public: } // Construct scopes for subprogram. - ConstructRootScope(DebugInfo->getRootScope()); + ConstructRootScope(MMI->getRootScope()); + + DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount, + MMI->getFrameMoves())); + } +}; + +//===----------------------------------------------------------------------===// +/// DwarfException - Emits Dwarf exception handling directives. +/// +class DwarfException : public Dwarf { + +private: + struct FunctionEHFrameInfo { + std::string FnName; + unsigned Number; + unsigned PersonalityIndex; + bool hasCalls; + bool hasLandingPads; + std::vector Moves; + const Function * function; + + FunctionEHFrameInfo(const std::string &FN, unsigned Num, unsigned P, + bool hC, bool hL, + const std::vector &M, + const Function *f): + FnName(FN), Number(Num), PersonalityIndex(P), + hasCalls(hC), hasLandingPads(hL), Moves(M), function (f) { } + }; + + std::vector EHFrames; - // Emit function frame information. - EmitFunctionDebugFrame(); + /// shouldEmit - Flag to indicate if debug information should be emitted. + /// + bool shouldEmit; + + /// EmitCommonEHFrame - Emit the common eh unwind frame. + /// + void EmitCommonEHFrame(const Function *Personality, unsigned Index) { + // Size and sign of stack growth. + int stackGrowth = + Asm->TM.getFrameInfo()->getStackGrowthDirection() == + TargetFrameInfo::StackGrowsUp ? + TD->getPointerSize() : -TD->getPointerSize(); + + // Begin eh frame section. + Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection()); + O << "EH_frame" << Index << ":\n"; + EmitLabel("section_eh_frame", Index); + + // Define base labels. + EmitLabel("eh_frame_common", Index); + + // Define the eh frame length. + EmitDifference("eh_frame_common_end", Index, + "eh_frame_common_begin", Index, true); + Asm->EOL("Length of Common Information Entry"); + + // EH frame header. + EmitLabel("eh_frame_common_begin", Index); + Asm->EmitInt32((int)0); + Asm->EOL("CIE Identifier Tag"); + Asm->EmitInt8(DW_CIE_VERSION); + Asm->EOL("CIE Version"); + + // The personality presence indicates that language specific information + // will show up in the eh frame. + Asm->EmitString(Personality ? "zPLR" : "zR"); + Asm->EOL("CIE Augmentation"); + + // Round out reader. + Asm->EmitULEB128Bytes(1); + Asm->EOL("CIE Code Alignment Factor"); + Asm->EmitSLEB128Bytes(stackGrowth); + Asm->EOL("CIE Data Alignment Factor"); + Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), true)); + Asm->EOL("CIE RA Column"); + + // If there is a personality, we need to indicate the functions location. + if (Personality) { + Asm->EmitULEB128Bytes(7); + Asm->EOL("Augmentation Size"); + + if (TAI->getNeedsIndirectEncoding()) + Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect); + else + Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4); + + Asm->EOL("Personality (pcrel sdata4 indirect)"); + + PrintRelDirective(TAI->getShortenEHDataOn64Bit()); + O << TAI->getPersonalityPrefix(); + Asm->EmitExternalGlobal((const GlobalVariable *)(Personality)); + O << TAI->getPersonalitySuffix(); + if (!TAI->getShortenEHDataOn64Bit()) { + O << "-" << TAI->getPCSymbol(); + } + Asm->EOL("Personality"); + + Asm->EmitULEB128Bytes(DW_EH_PE_pcrel); + Asm->EOL("LSDA Encoding (pcrel)"); + Asm->EmitULEB128Bytes(DW_EH_PE_pcrel); + Asm->EOL("FDE Encoding (pcrel)"); + } else { + Asm->EmitULEB128Bytes(1); + Asm->EOL("Augmentation Size"); + Asm->EmitULEB128Bytes(DW_EH_PE_pcrel); + Asm->EOL("FDE Encoding (pcrel)"); + } + + // Indicate locations of general callee saved registers in frame. + std::vector Moves; + RI->getInitialFrameState(Moves); + EmitFrameMoves(NULL, 0, Moves, true); + + Asm->EmitAlignment(2); + EmitLabel("eh_frame_common_end", Index); - // Reset the line numbers for the next function. - DebugInfo->ClearLineInfo(); + Asm->EOL(); + } + + /// EmitEHFrame - Emit function exception frame information. + /// + void EmitEHFrame(const FunctionEHFrameInfo &EHFrameInfo) { + Function::LinkageTypes linkage = EHFrameInfo.function->getLinkage(); - // Clear function debug information. - DebugInfo->EndFunction(); + Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection()); + + // Externally visible entry into the functions eh frame info. + // If the corresponding function is static, this should not be + // externally visible. + if (linkage != Function::InternalLinkage) { + if (const char *GlobalEHDirective = TAI->getGlobalEHDirective()) + O << GlobalEHDirective << EHFrameInfo.FnName << "\n"; + } + + // If corresponding function is weak definition, this should be too. + if ((linkage == Function::WeakLinkage || + linkage == Function::LinkOnceLinkage) && + TAI->getWeakDefDirective()) + O << TAI->getWeakDefDirective() << EHFrameInfo.FnName << "\n"; + + // If there are no calls then you can't unwind. This may mean we can + // omit the EH Frame, but some environments do not handle weak absolute + // symbols. + if (!EHFrameInfo.hasCalls && + ((linkage != Function::WeakLinkage && + linkage != Function::LinkOnceLinkage) || + !TAI->getWeakDefDirective() || + TAI->getSupportsWeakOmittedEHFrame())) + { + O << EHFrameInfo.FnName << " = 0\n"; + // This name has no connection to the function, so it might get + // dead-stripped when the function is not, erroneously. Prohibit + // dead-stripping unconditionally. + if (const char *UsedDirective = TAI->getUsedDirective()) + O << UsedDirective << EHFrameInfo.FnName << "\n\n"; + } else { + O << EHFrameInfo.FnName << ":\n"; + + // EH frame header. + EmitDifference("eh_frame_end", EHFrameInfo.Number, + "eh_frame_begin", EHFrameInfo.Number, true); + Asm->EOL("Length of Frame Information Entry"); + + EmitLabel("eh_frame_begin", EHFrameInfo.Number); + + EmitSectionOffset("eh_frame_begin", "eh_frame_common", + EHFrameInfo.Number, EHFrameInfo.PersonalityIndex, + true, true); + Asm->EOL("FDE CIE offset"); + + EmitReference("eh_func_begin", EHFrameInfo.Number, true); + Asm->EOL("FDE initial location"); + EmitDifference("eh_func_end", EHFrameInfo.Number, + "eh_func_begin", EHFrameInfo.Number); + Asm->EOL("FDE address range"); + + // If there is a personality and landing pads then point to the language + // specific data area in the exception table. + if (EHFrameInfo.PersonalityIndex) { + Asm->EmitULEB128Bytes(TAI->getShortenEHDataOn64Bit() ? 8 : 4); + Asm->EOL("Augmentation size"); + + if (EHFrameInfo.hasLandingPads) { + EmitReference("exception", EHFrameInfo.Number, true); + } else if (TD->getPointerSize() == 8) { + Asm->EmitInt64((int)0); + } else { + Asm->EmitInt32((int)0); + } + Asm->EOL("Language Specific Data Area"); + } else { + Asm->EmitULEB128Bytes(0); + Asm->EOL("Augmentation size"); + } + + // Indicate locations of function specific callee saved registers in + // frame. + EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves, true); + + Asm->EmitAlignment(2); + EmitLabel("eh_frame_end", EHFrameInfo.Number); + + // If the function is marked used, this table should be also. We cannot + // make the mark unconditional in this case, since retaining the table + // also retains the function in this case, and there is code around + // that depends on unused functions (calling undefined externals) being + // dead-stripped to link correctly. Yes, there really is. + if (MMI->getUsedFunctions().count(EHFrameInfo.function)) + if (const char *UsedDirective = TAI->getUsedDirective()) + O << UsedDirective << EHFrameInfo.FnName << "\n\n"; + } + } + + /// EmitExceptionTable - Emit landing pads and actions. + /// + /// The general organization of the table is complex, but the basic concepts + /// are easy. First there is a header which describes the location and + /// organization of the three components that follow. + /// 1. The landing pad site information describes the range of code covered + /// by the try. In our case it's an accumulation of the ranges covered + /// by the invokes in the try. There is also a reference to the landing + /// pad that handles the exception once processed. Finally an index into + /// the actions table. + /// 2. The action table, in our case, is composed of pairs of type ids + /// and next action offset. Starting with the action index from the + /// landing pad site, each type Id is checked for a match to the current + /// exception. If it matches then the exception and type id are passed + /// on to the landing pad. Otherwise the next action is looked up. This + /// chain is terminated with a next action of zero. If no type id is + /// found the the frame is unwound and handling continues. + /// 3. Type id table contains references to all the C++ typeinfo for all + /// catches in the function. This tables is reversed indexed base 1. + + /// SharedTypeIds - How many leading type ids two landing pads have in common. + static unsigned SharedTypeIds(const LandingPadInfo *L, + const LandingPadInfo *R) { + const std::vector &LIds = L->TypeIds, &RIds = R->TypeIds; + unsigned LSize = LIds.size(), RSize = RIds.size(); + unsigned MinSize = LSize < RSize ? LSize : RSize; + unsigned Count = 0; + + for (; Count != MinSize; ++Count) + if (LIds[Count] != RIds[Count]) + return Count; + + return Count; + } + + /// PadLT - Order landing pads lexicographically by type id. + static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R) { + const std::vector &LIds = L->TypeIds, &RIds = R->TypeIds; + unsigned LSize = LIds.size(), RSize = RIds.size(); + unsigned MinSize = LSize < RSize ? LSize : RSize; + + for (unsigned i = 0; i != MinSize; ++i) + if (LIds[i] != RIds[i]) + return LIds[i] < RIds[i]; + + return LSize < RSize; + } + + struct KeyInfo { + static inline unsigned getEmptyKey() { return -1U; } + static inline unsigned getTombstoneKey() { return -2U; } + static unsigned getHashValue(const unsigned &Key) { return Key; } + static bool isEqual(unsigned LHS, unsigned RHS) { return LHS == RHS; } + static bool isPod() { return true; } + }; + + /// ActionEntry - Structure describing an entry in the actions table. + struct ActionEntry { + int ValueForTypeID; // The value to write - may not be equal to the type id. + int NextAction; + struct ActionEntry *Previous; + }; + + /// PadRange - Structure holding a try-range and the associated landing pad. + struct PadRange { + // The index of the landing pad. + unsigned PadIndex; + // The index of the begin and end labels in the landing pad's label lists. + unsigned RangeIndex; + }; + + typedef DenseMap RangeMapType; + + /// CallSiteEntry - Structure describing an entry in the call-site table. + struct CallSiteEntry { + // The 'try-range' is BeginLabel .. EndLabel. + unsigned BeginLabel; // zero indicates the start of the function. + unsigned EndLabel; // zero indicates the end of the function. + // The landing pad starts at PadLabel. + unsigned PadLabel; // zero indicates that there is no landing pad. + unsigned Action; + }; + + void EmitExceptionTable() { + // Map all labels and get rid of any dead landing pads. + MMI->TidyLandingPads(); + + const std::vector &TypeInfos = MMI->getTypeInfos(); + const std::vector &FilterIds = MMI->getFilterIds(); + const std::vector &PadInfos = MMI->getLandingPads(); + if (PadInfos.empty()) return; + + // Sort the landing pads in order of their type ids. This is used to fold + // duplicate actions. + SmallVector LandingPads; + LandingPads.reserve(PadInfos.size()); + for (unsigned i = 0, N = PadInfos.size(); i != N; ++i) + LandingPads.push_back(&PadInfos[i]); + std::sort(LandingPads.begin(), LandingPads.end(), PadLT); + + // Negative type ids index into FilterIds, positive type ids index into + // TypeInfos. The value written for a positive type id is just the type + // id itself. For a negative type id, however, the value written is the + // (negative) byte offset of the corresponding FilterIds entry. The byte + // offset is usually equal to the type id, because the FilterIds entries + // are written using a variable width encoding which outputs one byte per + // entry as long as the value written is not too large, but can differ. + // This kind of complication does not occur for positive type ids because + // type infos are output using a fixed width encoding. + // FilterOffsets[i] holds the byte offset corresponding to FilterIds[i]. + SmallVector FilterOffsets; + FilterOffsets.reserve(FilterIds.size()); + int Offset = -1; + for(std::vector::const_iterator I = FilterIds.begin(), + E = FilterIds.end(); I != E; ++I) { + FilterOffsets.push_back(Offset); + Offset -= Asm->SizeULEB128(*I); + } + + // Compute the actions table and gather the first action index for each + // landing pad site. + SmallVector Actions; + SmallVector FirstActions; + FirstActions.reserve(LandingPads.size()); + + int FirstAction = 0; + unsigned SizeActions = 0; + for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) { + const LandingPadInfo *LP = LandingPads[i]; + const std::vector &TypeIds = LP->TypeIds; + const unsigned NumShared = i ? SharedTypeIds(LP, LandingPads[i-1]) : 0; + unsigned SizeSiteActions = 0; + + if (NumShared < TypeIds.size()) { + unsigned SizeAction = 0; + ActionEntry *PrevAction = 0; + + if (NumShared) { + const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size(); + assert(Actions.size()); + PrevAction = &Actions.back(); + SizeAction = Asm->SizeSLEB128(PrevAction->NextAction) + + Asm->SizeSLEB128(PrevAction->ValueForTypeID); + for (unsigned j = NumShared; j != SizePrevIds; ++j) { + SizeAction -= Asm->SizeSLEB128(PrevAction->ValueForTypeID); + SizeAction += -PrevAction->NextAction; + PrevAction = PrevAction->Previous; + } + } + + // Compute the actions. + for (unsigned I = NumShared, M = TypeIds.size(); I != M; ++I) { + int TypeID = TypeIds[I]; + assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!"); + int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID; + unsigned SizeTypeID = Asm->SizeSLEB128(ValueForTypeID); + + int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0; + SizeAction = SizeTypeID + Asm->SizeSLEB128(NextAction); + SizeSiteActions += SizeAction; + + ActionEntry Action = {ValueForTypeID, NextAction, PrevAction}; + Actions.push_back(Action); + + PrevAction = &Actions.back(); + } + + // Record the first action of the landing pad site. + FirstAction = SizeActions + SizeSiteActions - SizeAction + 1; + } // else identical - re-use previous FirstAction + + FirstActions.push_back(FirstAction); + + // Compute this sites contribution to size. + SizeActions += SizeSiteActions; + } + + // Compute the call-site table. The entry for an invoke has a try-range + // containing the call, a non-zero landing pad and an appropriate action. + // The entry for an ordinary call has a try-range containing the call and + // zero for the landing pad and the action. Calls marked 'nounwind' have + // no entry and must not be contained in the try-range of any entry - they + // form gaps in the table. Entries must be ordered by try-range address. + SmallVector CallSites; + + RangeMapType PadMap; + // Invokes and nounwind calls have entries in PadMap (due to being bracketed + // by try-range labels when lowered). Ordinary calls do not, so appropriate + // try-ranges for them need be deduced. + for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) { + const LandingPadInfo *LandingPad = LandingPads[i]; + for (unsigned j = 0, E = LandingPad->BeginLabels.size(); j != E; ++j) { + unsigned BeginLabel = LandingPad->BeginLabels[j]; + assert(!PadMap.count(BeginLabel) && "Duplicate landing pad labels!"); + PadRange P = { i, j }; + PadMap[BeginLabel] = P; + } + } + + // The end label of the previous invoke or nounwind try-range. + unsigned LastLabel = 0; + + // Whether there is a potentially throwing instruction (currently this means + // an ordinary call) between the end of the previous try-range and now. + bool SawPotentiallyThrowing = false; + + // Whether the last callsite entry was for an invoke. + bool PreviousIsInvoke = false; + + // Visit all instructions in order of address. + for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); + I != E; ++I) { + for (MachineBasicBlock::const_iterator MI = I->begin(), E = I->end(); + MI != E; ++MI) { + if (MI->getOpcode() != TargetInstrInfo::LABEL) { + SawPotentiallyThrowing |= MI->getDesc().isCall(); + continue; + } + + unsigned BeginLabel = MI->getOperand(0).getImm(); + assert(BeginLabel && "Invalid label!"); + + // End of the previous try-range? + if (BeginLabel == LastLabel) + SawPotentiallyThrowing = false; + + // Beginning of a new try-range? + RangeMapType::iterator L = PadMap.find(BeginLabel); + if (L == PadMap.end()) + // Nope, it was just some random label. + continue; + + PadRange P = L->second; + const LandingPadInfo *LandingPad = LandingPads[P.PadIndex]; + + assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] && + "Inconsistent landing pad map!"); + + // If some instruction between the previous try-range and this one may + // throw, create a call-site entry with no landing pad for the region + // between the try-ranges. + if (SawPotentiallyThrowing) { + CallSiteEntry Site = {LastLabel, BeginLabel, 0, 0}; + CallSites.push_back(Site); + PreviousIsInvoke = false; + } + + LastLabel = LandingPad->EndLabels[P.RangeIndex]; + assert(BeginLabel && LastLabel && "Invalid landing pad!"); + + if (LandingPad->LandingPadLabel) { + // This try-range is for an invoke. + CallSiteEntry Site = {BeginLabel, LastLabel, + LandingPad->LandingPadLabel, FirstActions[P.PadIndex]}; + + // Try to merge with the previous call-site. + if (PreviousIsInvoke) { + CallSiteEntry &Prev = CallSites[CallSites.size()-1]; + if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) { + // Extend the range of the previous entry. + Prev.EndLabel = Site.EndLabel; + continue; + } + } + + // Otherwise, create a new call-site. + CallSites.push_back(Site); + PreviousIsInvoke = true; + } else { + // Create a gap. + PreviousIsInvoke = false; + } + } + } + // If some instruction between the previous try-range and the end of the + // function may throw, create a call-site entry with no landing pad for the + // region following the try-range. + if (SawPotentiallyThrowing) { + CallSiteEntry Site = {LastLabel, 0, 0, 0}; + CallSites.push_back(Site); + } + + // Final tallies. + unsigned SizeSites = CallSites.size() * (sizeof(int32_t) + // Site start. + sizeof(int32_t) + // Site length. + sizeof(int32_t)); // Landing pad. + for (unsigned i = 0, e = CallSites.size(); i < e; ++i) + SizeSites += Asm->SizeULEB128(CallSites[i].Action); + + unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize(); + + unsigned TypeOffset = sizeof(int8_t) + // Call site format + Asm->SizeULEB128(SizeSites) + // Call-site table length + SizeSites + SizeActions + SizeTypes; + + unsigned TotalSize = sizeof(int8_t) + // LPStart format + sizeof(int8_t) + // TType format + Asm->SizeULEB128(TypeOffset) + // TType base offset + TypeOffset; + + unsigned SizeAlign = (4 - TotalSize) & 3; + + // Begin the exception table. + Asm->SwitchToDataSection(TAI->getDwarfExceptionSection()); + O << "GCC_except_table" << SubprogramCount << ":\n"; + Asm->EmitAlignment(2); + for (unsigned i = 0; i != SizeAlign; ++i) { + Asm->EmitInt8(0); + Asm->EOL("Padding"); + } + EmitLabel("exception", SubprogramCount); + + // Emit the header. + Asm->EmitInt8(DW_EH_PE_omit); + Asm->EOL("LPStart format (DW_EH_PE_omit)"); + Asm->EmitInt8(DW_EH_PE_absptr); + Asm->EOL("TType format (DW_EH_PE_absptr)"); + Asm->EmitULEB128Bytes(TypeOffset); + Asm->EOL("TType base offset"); + Asm->EmitInt8(DW_EH_PE_udata4); + Asm->EOL("Call site format (DW_EH_PE_udata4)"); + Asm->EmitULEB128Bytes(SizeSites); + Asm->EOL("Call-site table length"); + + // Emit the landing pad site information. + for (unsigned i = 0; i < CallSites.size(); ++i) { + CallSiteEntry &S = CallSites[i]; + const char *BeginTag; + unsigned BeginNumber; + + if (!S.BeginLabel) { + BeginTag = "eh_func_begin"; + BeginNumber = SubprogramCount; + } else { + BeginTag = "label"; + BeginNumber = S.BeginLabel; + } + + EmitSectionOffset(BeginTag, "eh_func_begin", BeginNumber, SubprogramCount, + TAI->getShortenEHDataOn64Bit(), true); + Asm->EOL("Region start"); + + if (!S.EndLabel) { + EmitDifference("eh_func_end", SubprogramCount, BeginTag, BeginNumber, + TAI->getShortenEHDataOn64Bit()); + } else { + EmitDifference("label", S.EndLabel, BeginTag, BeginNumber, + TAI->getShortenEHDataOn64Bit()); + } + Asm->EOL("Region length"); + + if (!S.PadLabel) { + if (TD->getPointerSize() == sizeof(int32_t) || TAI->getShortenEHDataOn64Bit()) + Asm->EmitInt32(0); + else + Asm->EmitInt64(0); + } else { + EmitSectionOffset("label", "eh_func_begin", S.PadLabel, SubprogramCount, + TAI->getShortenEHDataOn64Bit(), true); + } + Asm->EOL("Landing pad"); + + Asm->EmitULEB128Bytes(S.Action); + Asm->EOL("Action"); + } + + // Emit the actions. + for (unsigned I = 0, N = Actions.size(); I != N; ++I) { + ActionEntry &Action = Actions[I]; + + Asm->EmitSLEB128Bytes(Action.ValueForTypeID); + Asm->EOL("TypeInfo index"); + Asm->EmitSLEB128Bytes(Action.NextAction); + Asm->EOL("Next action"); + } + + // Emit the type ids. + for (unsigned M = TypeInfos.size(); M; --M) { + GlobalVariable *GV = TypeInfos[M - 1]; + + PrintRelDirective(); + + if (GV) + O << Asm->getGlobalLinkName(GV); + else + O << "0"; + + Asm->EOL("TypeInfo"); + } + + // Emit the filter typeids. + for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) { + unsigned TypeID = FilterIds[j]; + Asm->EmitULEB128Bytes(TypeID); + Asm->EOL("Filter TypeInfo index"); + } + + Asm->EmitAlignment(2); + } + +public: + //===--------------------------------------------------------------------===// + // Main entry points. + // + DwarfException(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T) + : Dwarf(OS, A, T, "eh") + , shouldEmit(false) + {} + + virtual ~DwarfException() {} + + /// SetModuleInfo - Set machine module information when it's known that pass + /// manager has created it. Set by the target AsmPrinter. + void SetModuleInfo(MachineModuleInfo *mmi) { + MMI = mmi; + } + + /// BeginModule - Emit all exception information that should come prior to the + /// content. + void BeginModule(Module *M) { + this->M = M; + } + + /// EndModule - Emit all exception information that should come after the + /// content. + void EndModule() { + if (!shouldEmit) return; + + const std::vector Personalities = MMI->getPersonalities(); + for (unsigned i =0; i < Personalities.size(); ++i) + EmitCommonEHFrame(Personalities[i], i); + + for (std::vector::iterator I = EHFrames.begin(), + E = EHFrames.end(); I != E; ++I) + EmitEHFrame(*I); + } + + /// BeginFunction - Gather pre-function exception information. Assumes being + /// emitted immediately after the function entry point. + void BeginFunction(MachineFunction *MF) { + this->MF = MF; + + if (MMI && + ExceptionHandling && + TAI->doesSupportExceptionHandling()) { + shouldEmit = true; + // Assumes in correct section after the entry point. + EmitLabel("eh_func_begin", ++SubprogramCount); + } + } + + /// EndFunction - Gather and emit post-function exception information. + /// + void EndFunction() { + if (!shouldEmit) return; + + EmitLabel("eh_func_end", SubprogramCount); + EmitExceptionTable(); + + // Save EH frame information + EHFrames. + push_back(FunctionEHFrameInfo(getAsm()->getCurrentFunctionEHName(MF), + SubprogramCount, + MMI->getPersonalityIndex(), + MF->getFrameInfo()->hasCalls(), + !MMI->getLandingPads().empty(), + MMI->getFrameMoves(), + MF->getFunction())); } }; @@ -2813,31 +3442,31 @@ public: /// Emit - Print the abbreviation using the specified Dwarf writer. /// -void DIEAbbrev::Emit(const Dwarf &DW) const { +void DIEAbbrev::Emit(const DwarfDebug &DD) const { // Emit its Dwarf tag type. - DW.EmitULEB128Bytes(Tag); - DW.EOL(TagString(Tag)); + DD.getAsm()->EmitULEB128Bytes(Tag); + DD.getAsm()->EOL(TagString(Tag)); // Emit whether it has children DIEs. - DW.EmitULEB128Bytes(ChildrenFlag); - DW.EOL(ChildrenString(ChildrenFlag)); + DD.getAsm()->EmitULEB128Bytes(ChildrenFlag); + DD.getAsm()->EOL(ChildrenString(ChildrenFlag)); // For each attribute description. for (unsigned i = 0, N = Data.size(); i < N; ++i) { const DIEAbbrevData &AttrData = Data[i]; // Emit attribute type. - DW.EmitULEB128Bytes(AttrData.getAttribute()); - DW.EOL(AttributeString(AttrData.getAttribute())); + DD.getAsm()->EmitULEB128Bytes(AttrData.getAttribute()); + DD.getAsm()->EOL(AttributeString(AttrData.getAttribute())); // Emit form type. - DW.EmitULEB128Bytes(AttrData.getForm()); - DW.EOL(FormEncodingString(AttrData.getForm())); + DD.getAsm()->EmitULEB128Bytes(AttrData.getForm()); + DD.getAsm()->EOL(FormEncodingString(AttrData.getForm())); } // Mark end of abbreviation. - DW.EmitULEB128Bytes(0); DW.EOL("EOM(1)"); - DW.EmitULEB128Bytes(0); DW.EOL("EOM(2)"); + DD.getAsm()->EmitULEB128Bytes(0); DD.getAsm()->EOL("EOM(1)"); + DD.getAsm()->EmitULEB128Bytes(0); DD.getAsm()->EOL("EOM(2)"); } #ifndef NDEBUG @@ -2858,14 +3487,14 @@ void DIEAbbrev::print(std::ostream &O) { << "\n"; } } -void DIEAbbrev::dump() { print(std::cerr); } +void DIEAbbrev::dump() { print(cerr); } #endif //===----------------------------------------------------------------------===// #ifndef NDEBUG void DIEValue::dump() { - print(std::cerr); + print(cerr); } #endif @@ -2873,91 +3502,117 @@ void DIEValue::dump() { /// EmitValue - Emit integer of appropriate size. /// -void DIEInteger::EmitValue(const Dwarf &DW, unsigned Form) const { +void DIEInteger::EmitValue(DwarfDebug &DD, unsigned Form) { + switch (Form) { + case DW_FORM_flag: // Fall thru + case DW_FORM_ref1: // Fall thru + case DW_FORM_data1: DD.getAsm()->EmitInt8(Integer); break; + case DW_FORM_ref2: // Fall thru + case DW_FORM_data2: DD.getAsm()->EmitInt16(Integer); break; + case DW_FORM_ref4: // Fall thru + case DW_FORM_data4: DD.getAsm()->EmitInt32(Integer); break; + case DW_FORM_ref8: // Fall thru + case DW_FORM_data8: DD.getAsm()->EmitInt64(Integer); break; + case DW_FORM_udata: DD.getAsm()->EmitULEB128Bytes(Integer); break; + case DW_FORM_sdata: DD.getAsm()->EmitSLEB128Bytes(Integer); break; + default: assert(0 && "DIE Value form not supported yet"); break; + } +} + +/// SizeOf - Determine size of integer value in bytes. +/// +unsigned DIEInteger::SizeOf(const DwarfDebug &DD, unsigned Form) const { switch (Form) { case DW_FORM_flag: // Fall thru case DW_FORM_ref1: // Fall thru - case DW_FORM_data1: DW.EmitInt8(Integer); break; + case DW_FORM_data1: return sizeof(int8_t); case DW_FORM_ref2: // Fall thru - case DW_FORM_data2: DW.EmitInt16(Integer); break; + case DW_FORM_data2: return sizeof(int16_t); case DW_FORM_ref4: // Fall thru - case DW_FORM_data4: DW.EmitInt32(Integer); break; + case DW_FORM_data4: return sizeof(int32_t); case DW_FORM_ref8: // Fall thru - case DW_FORM_data8: DW.EmitInt64(Integer); break; - case DW_FORM_udata: DW.EmitULEB128Bytes(Integer); break; - case DW_FORM_sdata: DW.EmitSLEB128Bytes(Integer); break; + case DW_FORM_data8: return sizeof(int64_t); + case DW_FORM_udata: return DD.getAsm()->SizeULEB128(Integer); + case DW_FORM_sdata: return DD.getAsm()->SizeSLEB128(Integer); default: assert(0 && "DIE Value form not supported yet"); break; } + return 0; } //===----------------------------------------------------------------------===// /// EmitValue - Emit string value. /// -void DIEString::EmitValue(const Dwarf &DW, unsigned Form) const { - DW.EmitString(String); +void DIEString::EmitValue(DwarfDebug &DD, unsigned Form) { + DD.getAsm()->EmitString(String); } //===----------------------------------------------------------------------===// /// EmitValue - Emit label value. /// -void DIEDwarfLabel::EmitValue(const Dwarf &DW, unsigned Form) const { - DW.EmitReference(Label); +void DIEDwarfLabel::EmitValue(DwarfDebug &DD, unsigned Form) { + bool IsSmall = Form == DW_FORM_data4; + DD.EmitReference(Label, false, IsSmall); } /// SizeOf - Determine size of label value in bytes. /// -unsigned DIEDwarfLabel::SizeOf(const Dwarf &DW, unsigned Form) const { - return DW.getTargetAsmInfo()->getAddressSize(); +unsigned DIEDwarfLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const { + if (Form == DW_FORM_data4) return 4; + return DD.getTargetData()->getPointerSize(); } //===----------------------------------------------------------------------===// /// EmitValue - Emit label value. /// -void DIEObjectLabel::EmitValue(const Dwarf &DW, unsigned Form) const { - DW.EmitReference(Label); +void DIEObjectLabel::EmitValue(DwarfDebug &DD, unsigned Form) { + bool IsSmall = Form == DW_FORM_data4; + DD.EmitReference(Label, false, IsSmall); } /// SizeOf - Determine size of label value in bytes. /// -unsigned DIEObjectLabel::SizeOf(const Dwarf &DW, unsigned Form) const { - return DW.getTargetAsmInfo()->getAddressSize(); +unsigned DIEObjectLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const { + if (Form == DW_FORM_data4) return 4; + return DD.getTargetData()->getPointerSize(); } //===----------------------------------------------------------------------===// /// EmitValue - Emit delta value. /// -void DIEDelta::EmitValue(const Dwarf &DW, unsigned Form) const { - DW.EmitDifference(LabelHi, LabelLo); +void DIEDelta::EmitValue(DwarfDebug &DD, unsigned Form) { + bool IsSmall = Form == DW_FORM_data4; + DD.EmitDifference(LabelHi, LabelLo, IsSmall); } /// SizeOf - Determine size of delta value in bytes. /// -unsigned DIEDelta::SizeOf(const Dwarf &DW, unsigned Form) const { - return DW.getTargetAsmInfo()->getAddressSize(); +unsigned DIEDelta::SizeOf(const DwarfDebug &DD, unsigned Form) const { + if (Form == DW_FORM_data4) return 4; + return DD.getTargetData()->getPointerSize(); } //===----------------------------------------------------------------------===// /// EmitValue - Emit debug information entry offset. /// -void DIEntry::EmitValue(const Dwarf &DW, unsigned Form) const { - DW.EmitInt32(Entry->getOffset()); +void DIEntry::EmitValue(DwarfDebug &DD, unsigned Form) { + DD.getAsm()->EmitInt32(Entry->getOffset()); } //===----------------------------------------------------------------------===// /// ComputeSize - calculate the size of the block. /// -unsigned DIEBlock::ComputeSize(Dwarf &DW) { +unsigned DIEBlock::ComputeSize(DwarfDebug &DD) { if (!Size) { const std::vector &AbbrevData = Abbrev.getData(); for (unsigned i = 0, N = Values.size(); i < N; ++i) { - Size += Values[i]->SizeOf(DW, AbbrevData[i].getForm()); + Size += Values[i]->SizeOf(DD, AbbrevData[i].getForm()); } } return Size; @@ -2965,31 +3620,31 @@ unsigned DIEBlock::ComputeSize(Dwarf &DW) { /// EmitValue - Emit block data. /// -void DIEBlock::EmitValue(const Dwarf &DW, unsigned Form) const { +void DIEBlock::EmitValue(DwarfDebug &DD, unsigned Form) { switch (Form) { - case DW_FORM_block1: DW.EmitInt8(Size); break; - case DW_FORM_block2: DW.EmitInt16(Size); break; - case DW_FORM_block4: DW.EmitInt32(Size); break; - case DW_FORM_block: DW.EmitULEB128Bytes(Size); break; - default: assert(0 && "Improper form for block"); break; + case DW_FORM_block1: DD.getAsm()->EmitInt8(Size); break; + case DW_FORM_block2: DD.getAsm()->EmitInt16(Size); break; + case DW_FORM_block4: DD.getAsm()->EmitInt32(Size); break; + case DW_FORM_block: DD.getAsm()->EmitULEB128Bytes(Size); break; + default: assert(0 && "Improper form for block"); break; } const std::vector &AbbrevData = Abbrev.getData(); for (unsigned i = 0, N = Values.size(); i < N; ++i) { - DW.EOL(""); - Values[i]->EmitValue(DW, AbbrevData[i].getForm()); + DD.getAsm()->EOL(); + Values[i]->EmitValue(DD, AbbrevData[i].getForm()); } } /// SizeOf - Determine size of block data in bytes. /// -unsigned DIEBlock::SizeOf(const Dwarf &DW, unsigned Form) const { +unsigned DIEBlock::SizeOf(const DwarfDebug &DD, unsigned Form) const { switch (Form) { case DW_FORM_block1: return Size + sizeof(int8_t); case DW_FORM_block2: return Size + sizeof(int16_t); case DW_FORM_block4: return Size + sizeof(int32_t); - case DW_FORM_block: return Size + SizeULEB128(Size); + case DW_FORM_block: return Size + DD.getAsm()->SizeULEB128(Size); default: assert(0 && "Improper form for block"); break; } return 0; @@ -3074,7 +3729,7 @@ void DIE::print(std::ostream &O, unsigned IncIndent) { } void DIE::dump() { - print(std::cerr); + print(cerr); } #endif @@ -3084,39 +3739,51 @@ void DIE::dump() { DwarfWriter::DwarfWriter(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T) { - DW = new Dwarf(OS, A, T); + DE = new DwarfException(OS, A, T); + DD = new DwarfDebug(OS, A, T); } DwarfWriter::~DwarfWriter() { - delete DW; + delete DE; + delete DD; } -/// SetDebugInfo - Set DebugInfo when it's known that pass manager has -/// created it. Set by the target AsmPrinter. -void DwarfWriter::SetDebugInfo(MachineDebugInfo *DI) { - DW->SetDebugInfo(DI); +/// SetModuleInfo - Set machine module info when it's known that pass manager +/// has created it. Set by the target AsmPrinter. +void DwarfWriter::SetModuleInfo(MachineModuleInfo *MMI) { + DD->SetModuleInfo(MMI); + DE->SetModuleInfo(MMI); } /// BeginModule - Emit all Dwarf sections that should come prior to the /// content. void DwarfWriter::BeginModule(Module *M) { - DW->BeginModule(M); + DE->BeginModule(M); + DD->BeginModule(M); } /// EndModule - Emit all Dwarf sections that should come after the content. /// void DwarfWriter::EndModule() { - DW->EndModule(); + DE->EndModule(); + DD->EndModule(); } /// BeginFunction - Gather pre-function debug information. Assumes being /// emitted immediately after the function entry point. void DwarfWriter::BeginFunction(MachineFunction *MF) { - DW->BeginFunction(MF); + DE->BeginFunction(MF); + DD->BeginFunction(MF); } /// EndFunction - Gather and emit post-function debug information. /// void DwarfWriter::EndFunction() { - DW->EndFunction(); + DD->EndFunction(); + DE->EndFunction(); + + if (MachineModuleInfo *MMI = DD->getMMI() ? DD->getMMI() : DE->getMMI()) { + // Clear function debug information. + MMI->EndFunction(); + } }