From ffe31d7bf1e070650b0ff9ebfac815ea172a82bb Mon Sep 17 00:00:00 2001 From: Anton Korobeynikov Date: Sat, 16 Aug 2008 12:57:46 +0000 Subject: [PATCH] Move SLEB/ULEB size calculation routines from AsmPrinter to TargetAsmInfo. This makes JIT asmprinter-free. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@54843 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/AsmPrinter.h | 8 - include/llvm/Target/TargetAsmInfo.h | 10 + lib/CodeGen/AsmPrinter.cpp | 29 +- lib/CodeGen/DwarfWriter.cpp | 801 ++++++++++---------- lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp | 79 +- lib/Target/TargetAsmInfo.cpp | 23 + 6 files changed, 474 insertions(+), 476 deletions(-) diff --git a/include/llvm/CodeGen/AsmPrinter.h b/include/llvm/CodeGen/AsmPrinter.h index b5f26952996..1bd2d517756 100644 --- a/include/llvm/CodeGen/AsmPrinter.h +++ b/include/llvm/CodeGen/AsmPrinter.h @@ -212,18 +212,10 @@ namespace llvm { /// representing an unsigned leb128 value. void PrintULEB128(unsigned Value) const; - /// SizeULEB128 - Compute the number of bytes required for an unsigned - /// leb128 value. - static unsigned SizeULEB128(unsigned Value); - /// PrintSLEB128 - Print a series of hexidecimal values(separated by commas) /// representing a signed leb128 value. void PrintSLEB128(int Value) const; - /// SizeSLEB128 - Compute the number of bytes required for a signed leb128 - /// value. - static unsigned SizeSLEB128(int Value); - //===------------------------------------------------------------------===// // Emission and print routines // diff --git a/include/llvm/Target/TargetAsmInfo.h b/include/llvm/Target/TargetAsmInfo.h index 8eb951578b9..c346d0ed987 100644 --- a/include/llvm/Target/TargetAsmInfo.h +++ b/include/llvm/Target/TargetAsmInfo.h @@ -570,6 +570,16 @@ namespace llvm { virtual const Section* SelectSectionForMachineConst(const Type *Ty) const; + /// getSLEB128Size - Compute the number of bytes required for a signed + /// leb128 value. + + static unsigned getSLEB128Size(int Value); + + /// getULEB128Size - Compute the number of bytes required for an unsigned + /// leb128 value. + + static unsigned getULEB128Size(unsigned Value); + // Accessors. // const char *getTextSection() const { diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp index b01ae7d6b58..16f26c42992 100644 --- a/lib/CodeGen/AsmPrinter.cpp +++ b/lib/CodeGen/AsmPrinter.cpp @@ -493,23 +493,12 @@ void AsmPrinter::PrintULEB128(unsigned Value) const { } while (Value); } -/// SizeULEB128 - Compute the number of bytes required for an unsigned leb128 -/// value. -unsigned AsmPrinter::SizeULEB128(unsigned Value) { - unsigned Size = 0; - do { - Value >>= 7; - Size += sizeof(int8_t); - } while (Value); - return Size; -} - /// PrintSLEB128 - Print a series of hexidecimal values (separated by commas) /// representing a signed leb128 value. void AsmPrinter::PrintSLEB128(int Value) const { int Sign = Value >> (8 * sizeof(Value) - 1); bool IsMore; - + do { unsigned Byte = Value & 0x7f; Value >>= 7; @@ -520,22 +509,6 @@ void AsmPrinter::PrintSLEB128(int Value) const { } while (IsMore); } -/// SizeSLEB128 - Compute the number of bytes required for a signed leb128 -/// value. -unsigned AsmPrinter::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; -} - //===--------------------------------------------------------------------===// // Emission and print routines // diff --git a/lib/CodeGen/DwarfWriter.cpp b/lib/CodeGen/DwarfWriter.cpp index 335623cda6e..5d6acc30ba8 100644 --- a/lib/CodeGen/DwarfWriter.cpp +++ b/lib/CodeGen/DwarfWriter.cpp @@ -42,7 +42,7 @@ using namespace llvm; using namespace llvm::dwarf; namespace llvm { - + //===----------------------------------------------------------------------===// /// Configuration values for initial hash set sizes (log2). @@ -59,26 +59,26 @@ class DIEValue; //===----------------------------------------------------------------------===// /// DWLabel - Labels are used to track locations in the assembler file. -/// Labels appear in the form @verbatim @endverbatim, -/// where the tag is a category of label (Ex. location) and number is a value +/// 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. /// const char *Tag; - + /// Number - Value to make label unique. /// unsigned Number; DWLabel(const char *T, unsigned N) : Tag(T), Number(N) {} - + void Profile(FoldingSetNodeID &ID) const { ID.AddString(std::string(Tag)); ID.AddInteger(Number); } - + #ifndef NDEBUG void print(std::ostream *O) const { if (O) print(*O); @@ -98,17 +98,17 @@ private: /// Attribute - Dwarf attribute code. /// unsigned Attribute; - + /// Form - Dwarf form code. - /// - unsigned Form; - + /// + unsigned Form; + public: DIEAbbrevData(unsigned A, unsigned F) : Attribute(A) , Form(F) {} - + // Accessors. unsigned getAttribute() const { return Attribute; } unsigned getForm() const { return Form; } @@ -129,7 +129,7 @@ private: /// Tag - Dwarf tag code. /// unsigned Tag; - + /// Unique number for node. /// unsigned Number; @@ -150,7 +150,7 @@ public: , Data() {} ~DIEAbbrev() {} - + // Accessors. unsigned getTag() const { return Tag; } unsigned getNumber() const { return Number; } @@ -159,34 +159,34 @@ public: void setTag(unsigned T) { Tag = T; } void setChildrenFlag(unsigned CF) { ChildrenFlag = CF; } void setNumber(unsigned N) { Number = N; } - + /// AddAttribute - Adds another set of attribute information to the /// abbreviation. void AddAttribute(unsigned Attribute, unsigned Form) { Data.push_back(DIEAbbrevData(Attribute, Form)); } - + /// AddFirstAttribute - Adds a set of attribute information to the front /// of the abbreviation. void AddFirstAttribute(unsigned Attribute, unsigned Form) { Data.insert(Data.begin(), DIEAbbrevData(Attribute, Form)); } - + /// Profile - Used to gather unique data for the abbreviation folding set. /// void Profile(FoldingSetNodeID &ID) { ID.AddInteger(Tag); ID.AddInteger(ChildrenFlag); - + // For each attribute description. for (unsigned i = 0, N = Data.size(); i < N; ++i) Data[i].Profile(ID); } - + /// Emit - Print the abbreviation using the specified Dwarf writer. /// - void Emit(const DwarfDebug &DD) const; - + void Emit(const DwarfDebug &DD) const; + #ifndef NDEBUG void print(std::ostream *O) { if (O) print(*O); @@ -204,23 +204,23 @@ protected: /// Abbrev - Buffer for constructing abbreviation. /// DIEAbbrev Abbrev; - + /// Offset - Offset in debug info section. /// unsigned Offset; - + /// Size - Size of instance + children. /// unsigned Size; - + /// Children DIEs. /// std::vector Children; - + /// Attributes values. /// SmallVector Values; - + public: explicit DIE(unsigned Tag) : Abbrev(Tag, DW_CHILDREN_no) @@ -230,7 +230,7 @@ public: , Values() {} virtual ~DIE(); - + // Accessors. DIEAbbrev &getAbbrev() { return Abbrev; } unsigned getAbbrevNumber() const { @@ -244,18 +244,18 @@ public: void setTag(unsigned Tag) { Abbrev.setTag(Tag); } void setOffset(unsigned O) { Offset = O; } void setSize(unsigned S) { Size = S; } - + /// AddValue - Add a value and attributes to a DIE. /// void AddValue(unsigned Attribute, unsigned Form, DIEValue *Value) { Abbrev.AddAttribute(Attribute, Form); Values.push_back(Value); } - + /// SiblingOffset - Return the offset of the debug information entry's /// sibling. unsigned SiblingOffset() const { return Offset + Size; } - + /// AddSiblingOffset - Add a sibling offset field to the front of the DIE. /// void AddSiblingOffset(); @@ -266,17 +266,17 @@ public: Abbrev.setChildrenFlag(DW_CHILDREN_yes); Children.push_back(Child); } - + /// Detach - Detaches objects connected to it after copying. /// void Detach() { Children.clear(); } - + /// Profile - Used to gather unique data for the value folding set. /// void Profile(FoldingSetNodeID &ID) ; - + #ifndef NDEBUG void print(std::ostream *O, unsigned IncIndent = 0) { if (O) print(*O, IncIndent); @@ -301,34 +301,34 @@ public: isEntry, isBlock }; - + /// Type - Type of data stored in the value. /// unsigned Type; - + explicit DIEValue(unsigned T) : Type(T) {} virtual ~DIEValue() {} - + // Accessors unsigned getType() const { return Type; } - + // Implement isa/cast/dyncast. static bool classof(const DIEValue *) { return true; } - + /// EmitValue - Emit value via the Dwarf writer. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form) = 0; - + /// SizeOf - Return the size of a value in bytes. /// 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); @@ -340,18 +340,18 @@ public: //===----------------------------------------------------------------------===// /// DWInteger - An integer value DIE. -/// +/// class DIEInteger : public DIEValue { private: uint64_t Integer; - + public: explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {} // Implement isa/cast/dyncast. static bool classof(const DIEInteger *) { return true; } static bool classof(const DIEValue *I) { return I->Type == isInteger; } - + /// BestForm - Choose the best form for integer. /// static unsigned BestForm(bool IsSigned, uint64_t Integer) { @@ -366,15 +366,15 @@ public: } return DW_FORM_data8; } - + /// EmitValue - Emit integer of appropriate size. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of integer value in bytes. /// virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; - + /// Profile - Used to gather unique data for the value folding set. /// static void Profile(FoldingSetNodeID &ID, unsigned Integer) { @@ -382,7 +382,7 @@ public: ID.AddInteger(Integer); } virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Integer); } - + #ifndef NDEBUG virtual void print(std::ostream &O) { O << "Int: " << (int64_t)Integer @@ -393,27 +393,27 @@ public: //===----------------------------------------------------------------------===// /// DIEString - A string value DIE. -/// +/// class DIEString : public DIEValue { public: const std::string String; - + explicit DIEString(const std::string &S) : DIEValue(isString), String(S) {} // Implement isa/cast/dyncast. static bool classof(const DIEString *) { return true; } static bool classof(const DIEValue *S) { return S->Type == isString; } - + /// EmitValue - Emit string value. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of string value in bytes. /// 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. /// static void Profile(FoldingSetNodeID &ID, const std::string &String) { @@ -421,7 +421,7 @@ public: ID.AddString(String); } virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, String); } - + #ifndef NDEBUG virtual void print(std::ostream &O) { O << "Str: \"" << String << "\""; @@ -436,21 +436,21 @@ class DIEDwarfLabel : public DIEValue { public: const DWLabel Label; - + explicit DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {} // Implement isa/cast/dyncast. static bool classof(const DIEDwarfLabel *) { return true; } static bool classof(const DIEValue *L) { return L->Type == isLabel; } - + /// EmitValue - Emit label value. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of label value in bytes. /// virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; - + /// Profile - Used to gather unique data for the value folding set. /// static void Profile(FoldingSetNodeID &ID, const DWLabel &Label) { @@ -458,7 +458,7 @@ public: Label.Profile(ID); } virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label); } - + #ifndef NDEBUG virtual void print(std::ostream &O) { O << "Lbl: "; @@ -474,22 +474,22 @@ public: class DIEObjectLabel : public DIEValue { public: const std::string Label; - + explicit DIEObjectLabel(const std::string &L) : DIEValue(isAsIsLabel), Label(L) {} // Implement isa/cast/dyncast. static bool classof(const DIEObjectLabel *) { return true; } static bool classof(const DIEValue *L) { return L->Type == isAsIsLabel; } - + /// EmitValue - Emit label value. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of label value in bytes. /// virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; - + /// Profile - Used to gather unique data for the value folding set. /// static void Profile(FoldingSetNodeID &ID, const std::string &Label) { @@ -514,7 +514,7 @@ public: const DWLabel Section; bool IsEH : 1; bool UseSet : 1; - + DIESectionOffset(const DWLabel &Lab, const DWLabel &Sec, bool isEH = false, bool useSet = true) : DIEValue(isSectionOffset), Label(Lab), Section(Sec), @@ -523,15 +523,15 @@ public: // Implement isa/cast/dyncast. static bool classof(const DIESectionOffset *) { return true; } static bool classof(const DIEValue *D) { return D->Type == isSectionOffset; } - + /// EmitValue - Emit section offset. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of section offset value in bytes. /// virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; - + /// Profile - Used to gather unique data for the value folding set. /// static void Profile(FoldingSetNodeID &ID, const DWLabel &Label, @@ -557,27 +557,27 @@ public: //===----------------------------------------------------------------------===// /// DIEDelta - A simple label difference DIE. -/// +/// class DIEDelta : public DIEValue { public: const DWLabel LabelHi; const DWLabel LabelLo; - + DIEDelta(const DWLabel &Hi, const DWLabel &Lo) : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {} // Implement isa/cast/dyncast. static bool classof(const DIEDelta *) { return true; } static bool classof(const DIEValue *D) { return D->Type == isDelta; } - + /// EmitValue - Emit delta value. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of delta value in bytes. /// virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; - + /// Profile - Used to gather unique data for the value folding set. /// static void Profile(FoldingSetNodeID &ID, const DWLabel &LabelHi, @@ -605,23 +605,23 @@ public: class DIEntry : public DIEValue { public: DIE *Entry; - + explicit DIEntry(DIE *E) : DIEValue(isEntry), Entry(E) {} - + // Implement isa/cast/dyncast. static bool classof(const DIEntry *) { return true; } static bool classof(const DIEValue *E) { return E->Type == isEntry; } - + /// EmitValue - Emit debug information entry offset. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of debug information entry in bytes. /// 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) { @@ -630,14 +630,14 @@ public: } virtual void Profile(FoldingSetNodeID &ID) { ID.AddInteger(isEntry); - + if (Entry) { ID.AddPointer(Entry); } else { ID.AddPointer(this); } } - + #ifndef NDEBUG virtual void print(std::ostream &O) { O << "Die: 0x" << std::hex << (intptr_t)Entry << std::dec; @@ -651,7 +651,7 @@ public: class DIEBlock : public DIEValue, public DIE { public: unsigned Size; // Size in bytes excluding size header. - + DIEBlock() : DIEValue(isBlock) , DIE(0) @@ -659,15 +659,15 @@ public: {} ~DIEBlock() { } - + // Implement isa/cast/dyncast. static bool classof(const DIEBlock *) { return true; } static bool classof(const DIEValue *E) { return E->Type == isBlock; } - + /// ComputeSize - calculate the size of the block. /// unsigned ComputeSize(DwarfDebug &DD); - + /// BestForm - Choose the best form for data. /// unsigned BestForm() const { @@ -680,11 +680,11 @@ public: /// EmitValue - Emit block data. /// virtual void EmitValue(DwarfDebug &DD, unsigned Form); - + /// SizeOf - Determine size of block data in bytes. /// virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const; - + /// Profile - Used to gather unique data for the value folding set. /// @@ -692,7 +692,7 @@ public: ID.AddInteger(isBlock); DIE::Profile(ID); } - + #ifndef NDEBUG virtual void print(std::ostream &O) { O << "Blk: "; @@ -709,15 +709,15 @@ private: /// Desc - Compile unit debug descriptor. /// CompileUnitDesc *Desc; - + /// ID - File identifier for source. /// unsigned ID; - + /// Die - Compile unit debug information entry. /// DIE *Die; - + /// DescToDieMap - Tracks the mapping of unit level debug informaton /// descriptors to debug information entries. std::map DescToDieMap; @@ -733,11 +733,11 @@ private: /// DiesSet - Used to uniquely define dies within the compile unit. /// FoldingSet DiesSet; - + /// Dies - List of all dies in the compile unit. /// std::vector Dies; - + public: CompileUnit(CompileUnitDesc *CUD, unsigned I, DIE *D) : Desc(CUD) @@ -749,14 +749,14 @@ public: , DiesSet(InitDiesSetSize) , Dies() {} - + ~CompileUnit() { delete Die; - + for (unsigned i = 0, N = Dies.size(); i < N; ++i) delete Dies[i]; } - + // Accessors. CompileUnitDesc *getDesc() const { return Desc; } unsigned getID() const { return ID; } @@ -774,19 +774,19 @@ public: void AddGlobal(const std::string &Name, DIE *Die) { Globals[Name] = Die; } - + /// getDieMapSlotFor - Returns the debug information entry map slot for the /// specified debug descriptor. DIE *&getDieMapSlotFor(DebugInfoDesc *DID) { return DescToDieMap[DID]; } - + /// getDIEntrySlotFor - Returns the debug information entry proxy slot for the /// specified debug descriptor. DIEntry *&getDIEntrySlotFor(DebugInfoDesc *DID) { return DescToDIEntryMap[DID]; } - + /// AddDie - Adds or interns the DIE to the compile unit. /// DIE *AddDie(DIE &Buffer) { @@ -794,20 +794,20 @@ public: Buffer.Profile(ID); void *Where; DIE *Die = DiesSet.FindNodeOrInsertPos(ID, Where); - + if (!Die) { Die = new DIE(Buffer); DiesSet.InsertNode(Die, Where); this->Die->AddChild(Die); Buffer.Detach(); } - + return Die; } }; //===----------------------------------------------------------------------===// -/// Dwarf - Emits general Dwarf directives. +/// Dwarf - Emits general Dwarf directives. /// class Dwarf { @@ -816,7 +816,7 @@ protected: //===--------------------------------------------------------------------===// // Core attributes used by the Dwarf writer. // - + // /// O - Stream to .s file. /// @@ -825,32 +825,32 @@ protected: /// Asm - Target of Dwarf emission. /// AsmPrinter *Asm; - + /// TAI - Target asm information. const TargetAsmInfo *TAI; - + /// TD - Target data. const TargetData *TD; - + /// RI - Register Information. const TargetRegisterInfo *RI; - + /// M - Current module. /// Module *M; - + /// MF - Current machine function. /// MachineFunction *MF; - + /// MMI - Collected machine module information. /// MachineModuleInfo *MMI; - + /// SubprogramCount - The running count of functions being compiled. /// unsigned SubprogramCount; - + /// Flavor - A unique string indicating what dwarf producer this is, used to /// unique labels. const char * const Flavor; @@ -891,7 +891,7 @@ public: else O << TAI->getData64bitsDirective(); } - + /// PrintLabelName - Print label name in form used by Dwarf writer. /// void PrintLabelName(DWLabel Label) const { @@ -901,14 +901,14 @@ public: 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. /// void EmitLabel(DWLabel Label) const { @@ -918,7 +918,7 @@ public: PrintLabelName(Tag, Number); O << ":\n"; } - + /// EmitReference - Emit a reference to a label. /// void EmitReference(DWLabel Label, bool IsPCRelative = false, @@ -929,15 +929,15 @@ public: bool IsPCRelative = false, bool Force32Bit = false) const { PrintRelDirective(Force32Bit); PrintLabelName(Tag, Number); - + if (IsPCRelative) O << "-" << TAI->getPCSymbol(); } void EmitReference(const std::string &Name, bool IsPCRelative = false, bool Force32Bit = false) const { PrintRelDirective(Force32Bit); - + O << Name; - + if (IsPCRelative) O << "-" << TAI->getPCSymbol(); } @@ -967,7 +967,7 @@ public: ++SetCounter; } else { PrintRelDirective(IsSmall); - + PrintLabelName(TagHi, NumberHi); O << "-"; PrintLabelName(TagLo, NumberLo); @@ -993,25 +993,25 @@ public: if (!printAbsolute) { O << "-"; PrintLabelName(Section, SectionNumber); - } + } O << "\n"; PrintRelDirective(IsSmall); - + PrintLabelName("set", SetCounter, Flavor); ++SetCounter; } else { PrintRelDirective(IsSmall, true); - + PrintLabelName(Label, LabelNumber); if (!printAbsolute) { O << "-"; PrintLabelName(Section, SectionNumber); } - } + } } - + /// EmitFrameMoves - Emit frame instructions to describe the layout of the /// frame. void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID, @@ -1025,29 +1025,29 @@ public: for (unsigned i = 0, N = Moves.size(); i < N; ++i) { const MachineMove &Move = Moves[i]; unsigned LabelID = Move.getLabelID(); - + if (LabelID) { LabelID = MMI->MappedLabel(LabelID); - + // Throw out move if the label is invalid. if (!LabelID) continue; } - + 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()) { @@ -1060,9 +1060,9 @@ public: Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Src.getRegister(), isEH)); Asm->EOL("Register"); } - + int Offset = -Src.getOffset(); - + Asm->EmitULEB128Bytes(Offset); Asm->EOL("Offset"); } else { @@ -1081,7 +1081,7 @@ public: } 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"); @@ -1112,7 +1112,7 @@ public: }; //===----------------------------------------------------------------------===// -/// DwarfDebug - Emits Dwarf debug directives. +/// DwarfDebug - Emits Dwarf debug directives. /// class DwarfDebug : public Dwarf { @@ -1120,11 +1120,11 @@ 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; @@ -1132,15 +1132,15 @@ private: /// 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; @@ -1148,11 +1148,11 @@ private: /// 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; @@ -1160,7 +1160,7 @@ private: /// didInitial - Flag to indicate if initial emission has been done. /// bool didInitial; - + /// shouldEmit - Flag to indicate if debug information should be emitted. /// bool shouldEmit; @@ -1174,26 +1174,26 @@ private: }; 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. + // Add to abbreviation list. Abbreviations.push_back(&Abbrev); // Assign the vector position + 1 as its number. Abbrev.setNumber(Abbreviations.size()); @@ -1209,30 +1209,30 @@ public: 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) { @@ -1256,10 +1256,10 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } - + Die->AddValue(Attribute, Form, Value); } - + /// AddSInt - Add an signed integer attribute data and value. /// void AddSInt(DIE *Die, unsigned Attribute, unsigned Form, int64_t Integer) { @@ -1274,10 +1274,10 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } - + Die->AddValue(Attribute, Form, Value); } - + /// AddString - Add a std::string attribute data and value. /// void AddString(DIE *Die, unsigned Attribute, unsigned Form, @@ -1291,10 +1291,10 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } - + Die->AddValue(Attribute, Form, Value); } - + /// AddLabel - Add a Dwarf label attribute data and value. /// void AddLabel(DIE *Die, unsigned Attribute, unsigned Form, @@ -1308,10 +1308,10 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } - + Die->AddValue(Attribute, Form, Value); } - + /// AddObjectLabel - Add an non-Dwarf label attribute data and value. /// void AddObjectLabel(DIE *Die, unsigned Attribute, unsigned Form, @@ -1325,10 +1325,10 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } - + Die->AddValue(Attribute, Form, Value); } - + /// AddSectionOffset - Add a section offset label attribute data and value. /// void AddSectionOffset(DIE *Die, unsigned Attribute, unsigned Form, @@ -1343,10 +1343,10 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } - + Die->AddValue(Attribute, Form, Value); } - + /// AddDelta - Add a label delta attribute data and value. /// void AddDelta(DIE *Die, unsigned Attribute, unsigned Form, @@ -1360,10 +1360,10 @@ public: ValuesSet.InsertNode(Value, Where); Values.push_back(Value); } - + Die->AddValue(Attribute, Form, Value); } - + /// AddDIEntry - Add a DIE attribute data and value. /// void AddDIEntry(DIE *Die, unsigned Attribute, unsigned Form, DIE *Entry) { @@ -1387,7 +1387,7 @@ public: delete Block; Block = cast(Value); } - + Die->AddValue(Attribute, Block->BestForm(), Value); } @@ -1410,7 +1410,7 @@ private: const MachineLocation &Location) { unsigned Reg = RI->getDwarfRegNum(Location.getRegister(), false); DIEBlock *Block = new DIEBlock(); - + if (Location.isRegister()) { if (Reg < 32) { AddUInt(Block, 0, DW_FORM_data1, DW_OP_reg0 + Reg); @@ -1427,10 +1427,10 @@ private: } AddUInt(Block, 0, DW_FORM_sdata, Location.getOffset()); } - + AddBlock(Die, Attribute, 0, Block); } - + /// AddBasicType - Add a new basic type attribute to the specified entity. /// void AddBasicType(DIE *Entity, CompileUnit *Unit, @@ -1439,7 +1439,7 @@ private: DIE *Die = ConstructBasicType(Unit, Name, Encoding, Size); AddDIEntry(Entity, DW_AT_type, DW_FORM_ref4, Die); } - + /// ConstructBasicType - Construct a new basic type. /// DIE *ConstructBasicType(CompileUnit *Unit, @@ -1451,14 +1451,14 @@ private: if (!Name.empty()) AddString(&Buffer, DW_AT_name, DW_FORM_string, Name); return Unit->AddDie(Buffer); } - + /// AddPointerType - Add a new pointer type attribute to the specified entity. /// void AddPointerType(DIE *Entity, CompileUnit *Unit, const std::string &Name) { DIE *Die = ConstructPointerType(Unit, Name); AddDIEntry(Entity, DW_AT_type, DW_FORM_ref4, Die); } - + /// ConstructPointerType - Construct a new pointer type. /// DIE *ConstructPointerType(CompileUnit *Unit, const std::string &Name) { @@ -1467,7 +1467,7 @@ private: if (!Name.empty()) AddString(&Buffer, DW_AT_name, DW_FORM_string, Name); return Unit->AddDie(Buffer); } - + /// AddType - Add a new type attribute to the specified entity. /// void AddType(DIE *Entity, TypeDesc *TyDesc, CompileUnit *Unit) { @@ -1476,13 +1476,13 @@ private: } else { // Check for pre-existence. DIEntry *&Slot = Unit->getDIEntrySlotFor(TyDesc); - + // If it exists then use the existing value. if (Slot) { Entity->AddValue(DW_AT_type, DW_FORM_ref4, Slot); return; } - + if (SubprogramDesc *SubprogramTy = dyn_cast(TyDesc)) { // FIXME - Not sure why programs and variables are coming through here. // Short cut for handling subprogram types (not really a TyDesc.) @@ -1492,14 +1492,14 @@ private: // FIXME - Not sure why programs and variables are coming through here. // Short cut for handling global variable types (not really a TyDesc.) AddPointerType(Entity, Unit, GlobalTy->getName()); - } else { + } else { // Set up proxy. Slot = NewDIEntry(); - + // Construct type. DIE Buffer(DW_TAG_base_type); ConstructType(Buffer, TyDesc, Unit); - + // Add debug information entry to entity and unit. DIE *Die = Unit->AddDie(Buffer); SetDIEntry(Slot, Die); @@ -1507,14 +1507,14 @@ private: } } } - + /// ConstructType - Adds all the required attributes to the type. /// void ConstructType(DIE &Buffer, TypeDesc *TyDesc, CompileUnit *Unit) { // Get core information. const std::string &Name = TyDesc->getName(); uint64_t Size = TyDesc->getSize() >> 3; - + if (BasicTypeDesc *BasicTy = dyn_cast(TyDesc)) { // Fundamental types like int, float, bool Buffer.setTag(DW_TAG_base_type); @@ -1524,7 +1524,7 @@ private: unsigned Tag = DerivedTy->getTag(); // FIXME - Workaround for templates. if (Tag == DW_TAG_inheritance) Tag = DW_TAG_reference_type; - // Pointers, typedefs et al. + // Pointers, typedefs et al. Buffer.setTag(Tag); // Map to main type, void will not have a type. if (TypeDesc *FromTy = DerivedTy->getFromType()) @@ -1532,15 +1532,15 @@ private: } else if (CompositeTypeDesc *CompTy = dyn_cast(TyDesc)){ // Fetch tag. unsigned Tag = CompTy->getTag(); - + // Set tag accordingly. if (Tag == DW_TAG_vector_type) Buffer.setTag(DW_TAG_array_type); - else + else Buffer.setTag(Tag); std::vector &Elements = CompTy->getElements(); - + switch (Tag) { case DW_TAG_vector_type: AddUInt(&Buffer, DW_AT_GNU_vector, DW_FORM_flag, 1); @@ -1549,21 +1549,21 @@ private: // Add element type. if (TypeDesc *FromTy = CompTy->getFromType()) AddType(&Buffer, FromTy, Unit); - + // Don't emit size attribute. Size = 0; - + // Construct an anonymous type for index type. 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) { SubrangeDesc *SRD = cast(Elements[i]); int64_t Lo = SRD->getLo(); int64_t Hi = SRD->getHi(); DIE *Subrange = new DIE(DW_TAG_subrange_type); - + // If a range is available. if (Lo != Hi) { AddDIEntry(Subrange, DW_AT_type, DW_FORM_ref4, IndexTy); @@ -1571,7 +1571,7 @@ private: if (Lo) AddSInt(Subrange, DW_AT_lower_bound, 0, Lo); AddSInt(Subrange, DW_AT_upper_bound, 0, Hi); } - + Buffer.AddChild(Subrange); } break; @@ -1581,36 +1581,36 @@ private: // Add elements to structure type. for(unsigned i = 0, N = Elements.size(); i < N; ++i) { DebugInfoDesc *Element = Elements[i]; - + if (DerivedTypeDesc *MemberDesc = dyn_cast(Element)){ // Add field or base class. - + unsigned Tag = MemberDesc->getTag(); - + // Extract the basic information. const std::string &Name = MemberDesc->getName(); uint64_t Size = MemberDesc->getSize(); uint64_t Align = MemberDesc->getAlign(); uint64_t Offset = MemberDesc->getOffset(); - + // Construct member debug information entry. DIE *Member = new DIE(Tag); - + // Add name if not "". if (!Name.empty()) AddString(Member, DW_AT_name, DW_FORM_string, Name); // Add location if available. AddSourceLine(Member, MemberDesc->getFile(), MemberDesc->getLine()); - + // Most of the time the field info is the same as the members. uint64_t FieldSize = Size; uint64_t FieldAlign = Align; uint64_t FieldOffset = Offset; - + // 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) { @@ -1618,10 +1618,10 @@ private: FieldAlign = FromTy->getSize(); break; } - + FromTy = cast(FromTy)->getFromType(); } - + // Unless we have a bit field. if (Tag == DW_TAG_member && FieldSize != Size) { // Construct the alignment mask. @@ -1632,16 +1632,16 @@ private: FieldOffset = HiMark - FieldSize; // Now normalize offset to the field. Offset -= FieldOffset; - + // Maybe we need to work from the other end. if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size); - + // Add size and offset. AddUInt(Member, DW_AT_byte_size, 0, FieldSize >> 3); AddUInt(Member, DW_AT_bit_size, 0, Size); AddUInt(Member, DW_AT_bit_offset, 0, Offset); } - + // Add computation for offset. DIEBlock *Block = new DIEBlock(); AddUInt(Block, 0, DW_FORM_data1, DW_OP_plus_uconst); @@ -1656,15 +1656,15 @@ private: } else if (Tag == DW_TAG_inheritance) { AddUInt(Member, DW_AT_accessibility, 0, DW_ACCESS_public); } - + Buffer.AddChild(Member); } else if (GlobalVariableDesc *StaticDesc = dyn_cast(Element)) { // Add static member. - + // Construct member debug information entry. DIE *Static = new DIE(DW_TAG_variable); - + // Add name and mangled name. const std::string &Name = StaticDesc->getName(); const std::string &LinkageName = StaticDesc->getLinkageName(); @@ -1673,54 +1673,54 @@ private: AddString(Static, DW_AT_MIPS_linkage_name, DW_FORM_string, LinkageName); } - + // Add location. AddSourceLine(Static, StaticDesc->getFile(), StaticDesc->getLine()); - + // Add type. if (TypeDesc *StaticTy = StaticDesc->getType()) AddType(Static, StaticTy, Unit); - + // Add flags. if (!StaticDesc->isStatic()) AddUInt(Static, DW_AT_external, DW_FORM_flag, 1); AddUInt(Static, DW_AT_declaration, DW_FORM_flag, 1); - + Buffer.AddChild(Static); } else if (SubprogramDesc *MethodDesc = dyn_cast(Element)) { // Add member function. - + // Construct member debug information entry. DIE *Method = new DIE(DW_TAG_subprogram); - + // Add name and mangled name. const std::string &Name = MethodDesc->getName(); const std::string &LinkageName = MethodDesc->getLinkageName(); - - AddString(Method, DW_AT_name, DW_FORM_string, Name); + + AddString(Method, DW_AT_name, DW_FORM_string, Name); bool IsCTor = TyDesc->getName() == Name; - + if (!LinkageName.empty()) { AddString(Method, DW_AT_MIPS_linkage_name, DW_FORM_string, LinkageName); } - + // Add location. AddSourceLine(Method, MethodDesc->getFile(), MethodDesc->getLine()); - + // Add type. if (CompositeTypeDesc *MethodTy = dyn_cast_or_null(MethodDesc->getType())) { // Get argument information. std::vector &Args = MethodTy->getElements(); - + // If not a ctor. if (!IsCTor) { // Add return type. AddType(Method, dyn_cast(Args[0]), Unit); } - + // Add arguments. for(unsigned i = 1, N = Args.size(); i < N; ++i) { DIE *Arg = new DIE(DW_TAG_formal_parameter); @@ -1734,7 +1734,7 @@ private: if (!MethodDesc->isStatic()) AddUInt(Method, DW_AT_external, DW_FORM_flag, 1); AddUInt(Method, DW_AT_declaration, DW_FORM_flag, 1); - + Buffer.AddChild(Method); } } @@ -1759,20 +1759,20 @@ private: AddUInt(&Buffer, DW_AT_prototyped, DW_FORM_flag, 1); // Add return type. AddType(&Buffer, dyn_cast(Elements[0]), Unit); - + // Add arguments. for(unsigned i = 1, N = Elements.size(); i < N; ++i) { DIE *Arg = new DIE(DW_TAG_formal_parameter); AddType(Arg, cast(Elements[i]), Unit); Buffer.AddChild(Arg); } - + break; } default: break; } } - + // Add size if non-zero (derived types don't have a size.) if (Size) AddUInt(&Buffer, DW_AT_byte_size, 0, Size); // Add name if not anonymous or intermediate type. @@ -1792,13 +1792,13 @@ private: AddUInt (Die, DW_AT_language, DW_FORM_data1, UnitDesc->getLanguage()); AddString(Die, DW_AT_name, DW_FORM_string, UnitDesc->getFileName()); AddString(Die, DW_AT_comp_dir, DW_FORM_string, UnitDesc->getDirectory()); - + // Construct compile unit. CompileUnit *Unit = new CompileUnit(UnitDesc, ID, Die); - + // Add Unit to compile unit map. DescToUnitMap[UnitDesc] = Unit; - + return Unit; } @@ -1829,7 +1829,7 @@ private: // Check for pre-existence. DIE *&Slot = Unit->getDieMapSlotFor(GVD); if (Slot) return Slot; - + // Get the global variable itself. GlobalVariable *GV = GVD->getGlobalVariable(); @@ -1846,26 +1846,26 @@ private: 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()); - + // Add address. DIEBlock *Block = new DIEBlock(); AddUInt(Block, 0, DW_FORM_data1, DW_OP_addr); AddObjectLabel(Block, 0, DW_FORM_udata, Asm->getGlobalLinkName(GV)); AddBlock(VariableDie, DW_AT_location, 0, Block); - + // Add to map. Slot = VariableDie; - + // Add to context owner. Unit->getDie()->AddChild(VariableDie); - + // Expose as global. // FIXME - need to check external flag. Unit->AddGlobal(FullName, VariableDie); - + return VariableDie; } @@ -1880,12 +1880,12 @@ private: // 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->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 (!LinkageName.empty()) { @@ -1896,19 +1896,19 @@ private: 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. AddSourceLine(SubprogramDie, UnitDesc, SPD->getLine()); // Add to map. Slot = SubprogramDie; - + // Add to context owner. Unit->getDie()->AddChild(SubprogramDie); - + // Expose as global. Unit->AddGlobal(FullName, SubprogramDie); - + return SubprogramDie; } @@ -1934,10 +1934,10 @@ private: // Add source line info if available. AddSourceLine(VariableDie, VD->getFile(), VD->getLine()); - + // Add variable type. - AddType(VariableDie, VD->getType(), Unit); - + AddType(VariableDie, VD->getType(), Unit); + // Add variable address. MachineLocation Location; Location.set(RI->getFrameRegister(*MF), @@ -1958,7 +1958,7 @@ private: DIE *VariableDie = NewScopeVariable(Variables[i], Unit); if (VariableDie) ParentDie->AddChild(VariableDie); } - + // Add nested scopes. std::vector &Scopes = ParentScope->getScopes(); for (unsigned j = 0, M = Scopes.size(); j < M; ++j) { @@ -1966,20 +1966,20 @@ private: DebugScope *Scope = Scopes[j]; // FIXME - Ignore inlined functions for the time being. if (!Scope->getParent()) continue; - + 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; - + if (StartID == ParentStartID && EndID == ParentEndID) { // Just add stuff to the parent scope. ConstructScope(Scope, ParentStartID, ParentEndID, ParentDie, Unit); } else { DIE *ScopeDie = new DIE(DW_TAG_lexical_block); - + // Add the scope bounds. if (StartID) { AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr, @@ -1995,7 +1995,7 @@ private: 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); @@ -2008,17 +2008,17 @@ private: void ConstructRootScope(DebugScope *RootScope) { // Exit if there is no root scope. if (!RootScope) return; - - // Get the subprogram debug information entry. + + // Get the subprogram debug information entry. SubprogramDesc *SPD = cast(RootScope->getDesc()); - + // Get the compile unit context. CompileUnit *Unit = GetBaseCompileUnit(); - + // Get the subprogram die. DIE *SPDie = Unit->getDieMapSlotFor(SPD); assert(SPDie && "Missing subprogram descriptor"); - + // Add the function bounds. AddLabel(SPDie, DW_AT_low_pc, DW_FORM_addr, DWLabel("func_begin", SubprogramCount)); @@ -2036,7 +2036,7 @@ private: // Check to see if we already emitted intial headers. if (didInitial) return; didInitial = true; - + // Dwarf sections base addresses. if (TAI->doesDwarfRequireFrameSection()) { Asm->SwitchToDataSection(TAI->getDwarfFrameSection()); @@ -2073,7 +2073,7 @@ private: // Get the abbreviation for this DIE. unsigned AbbrevNumber = Die->getAbbrevNumber(); const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; - + Asm->EOL(); // Emit the code (index) for the abbreviation. @@ -2087,16 +2087,16 @@ private: TagString(Abbrev->getTag()))); else Asm->EOL(); - + SmallVector &Values = Die->getValues(); const SmallVector &AbbrevData = Abbrev->getData(); - + // Emit the DIE attribute values. for (unsigned i = 0, N = Values.size(); i < N; ++i) { unsigned Attr = AbbrevData[i].getAttribute(); unsigned Form = AbbrevData[i].getForm(); assert(Form && "Too many attributes for DIE (check abbreviation)"); - + switch (Attr) { case DW_AT_sibling: { Asm->EmitInt32(Die->SiblingOffset()); @@ -2108,18 +2108,18 @@ private: break; } } - + Asm->EOL(AttributeString(Attr)); } - + // Emit the DIE children if any. if (Abbrev->getChildrenFlag() == DW_CHILDREN_yes) { const std::vector &Children = Die->getChildren(); - + for (unsigned j = 0, M = Children.size(); j < M; ++j) { EmitDIE(Children[j]); } - + Asm->EmitInt8(0); Asm->EOL("End Of Children Mark"); } } @@ -2129,23 +2129,23 @@ private: unsigned SizeAndOffsetDie(DIE *Die, unsigned Offset, bool Last) { // Get the children. const std::vector &Children = Die->getChildren(); - + // If not last sibling and has children then add sibling offset attribute. if (!Last && !Children.empty()) Die->AddSiblingOffset(); // Record the abbreviation. AssignAbbrevNumber(Die->getAbbrev()); - + // Get the abbreviation for this DIE. unsigned AbbrevNumber = Die->getAbbrevNumber(); const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1]; // Set DIE offset Die->setOffset(Offset); - + // Start the size with the size of abbreviation code. - Offset += Asm->SizeULEB128(AbbrevNumber); - + Offset += TargetAsmInfo::getULEB128Size(AbbrevNumber); + const SmallVector &Values = Die->getValues(); const SmallVector &AbbrevData = Abbrev->getData(); @@ -2154,16 +2154,16 @@ private: // Size attribute value. Offset += Values[i]->SizeOf(*this, AbbrevData[i].getForm()); } - + // Size the DIE children if any. if (!Children.empty()) { assert(Abbrev->getChildrenFlag() == DW_CHILDREN_yes && "Children flag not set"); - + for (unsigned j = 0, M = Children.size(); j < M; ++j) { Offset = SizeAndOffsetDie(Children[j], Offset, (j + 1) == M); } - + // End of children marker. Offset += sizeof(int8_t); } @@ -2190,7 +2190,7 @@ private: void EmitDebugInfo() { // Start debug info section. Asm->SwitchToDataSection(TAI->getDwarfInfoSection()); - + CompileUnit *Unit = GetBaseCompileUnit(); DIE *Die = Unit->getDie(); // Emit the compile units header. @@ -2201,13 +2201,13 @@ private: 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"); @@ -2215,7 +2215,7 @@ private: 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(); } @@ -2226,36 +2226,36 @@ private: if (!Abbreviations.empty()) { // Start the debug abbrev section. Asm->SwitchToDataSection(TAI->getDwarfAbbrevSection()); - + EmitLabel("abbrev_begin", 0); - + // For each abbrevation. for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) { // Get abbreviation data const DIEAbbrev *Abbrev = Abbreviations[i]; - + // Emit the abbrevations code (base 1 index.) Asm->EmitULEB128Bytes(Abbrev->getNumber()); Asm->EOL("Abbreviation Code"); - + // Emit the abbreviations data. Abbrev->Emit(*this); - + Asm->EOL(); } - + // Mark end of abbreviations. Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)"); EmitLabel("abbrev_end", 0); - + Asm->EOL(); } } /// EmitEndOfLineMatrix - Emit the last address of the section and the end of /// the line matrix. - /// + /// void EmitEndOfLineMatrix(unsigned SectionEnd) { // Define last address of section. Asm->EmitInt8(0); Asm->EOL("Extended Op"); @@ -2284,29 +2284,29 @@ private: // Start the dwarf line section. Asm->SwitchToDataSection(TAI->getDwarfLineSection()); - + // Construct the section header. - + EmitDifference("line_end", 0, "line_begin", 0, true); Asm->EOL("Length of Source Line Info"); EmitLabel("line_begin", 0); - + Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number"); - + EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true); Asm->EOL("Prolog Length"); EmitLabel("line_prolog_begin", 0); - + Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length"); Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag"); Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)"); - + Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)"); Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base"); - + // Line number standard opcode encodings argument count Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count"); Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count"); @@ -2327,7 +2327,7 @@ private: Asm->EmitString(Directories[DirectoryID]); Asm->EOL("Directory"); } Asm->EmitInt8(0); Asm->EOL("End of directories"); - + // Emit files. for (unsigned SourceID = 1, NSID = SourceFiles.size(); SourceID <= NSID; ++SourceID) { @@ -2342,9 +2342,9 @@ private: Asm->EOL("File size"); } Asm->EmitInt8(0); Asm->EOL("End of files"); - + EmitLabel("line_prolog_end", 0); - + // A sequence for each text section. unsigned SecSrcLinesSize = SectionSourceLines.size(); @@ -2360,13 +2360,13 @@ private: // Dwarf assumes we start with first line of first source file. unsigned Source = 1; unsigned Line = 1; - + // Construct rows of the address, source, line, column matrix. for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) { const SourceLineInfo &LineInfo = LineInfos[i]; unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID()); if (!LabelID) continue; - + unsigned SourceID = LineInfo.getSourceID(); const SourceFileInfo &SourceFile = SourceFiles[SourceID]; unsigned DirectoryID = SourceFile.getDirectoryID(); @@ -2383,23 +2383,23 @@ private: 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(); Asm->EmitInt8(DW_LNS_set_file); Asm->EOL("DW_LNS_set_file"); Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source"); } - + // If change of line. if (Line != LineInfo.getLine()) { // Determine offset. int Offset = LineInfo.getLine() - Line; int Delta = Offset - MinLineDelta; - + // Update line. Line = LineInfo.getLine(); - + // If delta is small enough and in range... if (Delta >= 0 && Delta < (MaxLineDelta - 1)) { // ... then use fast opcode. @@ -2424,12 +2424,12 @@ private: // table. The linker and friends expect it to exist. If there's nothing to // put into it, emit an empty table. EmitEndOfLineMatrix(1); - + EmitLabel("line_end", 0); - + Asm->EOL(); } - + /// EmitCommonDebugFrame - Emit common frame info into a debug frame section. /// void EmitCommonDebugFrame() { @@ -2459,10 +2459,10 @@ private: Asm->EmitULEB128Bytes(1); Asm->EOL("CIE Code Alignment Factor"); Asm->EmitSLEB128Bytes(stackGrowth); - Asm->EOL("CIE Data Alignment Factor"); + Asm->EOL("CIE Data Alignment Factor"); Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false)); Asm->EOL("CIE RA Column"); - + std::vector Moves; RI->getInitialFrameState(Moves); @@ -2470,7 +2470,7 @@ private: Asm->EmitAlignment(2, 0, 0, false); EmitLabel("debug_frame_common_end", 0); - + Asm->EOL(); } @@ -2479,14 +2479,14 @@ private: void EmitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) { if (!TAI->doesDwarfRequireFrameSection()) return; - + // Start the dwarf frame section. Asm->SwitchToDataSection(TAI->getDwarfFrameSection()); - + EmitDifference("debug_frame_end", DebugFrameInfo.Number, "debug_frame_begin", DebugFrameInfo.Number, true); Asm->EOL("Length of Frame Information Entry"); - + EmitLabel("debug_frame_begin", DebugFrameInfo.Number); EmitSectionOffset("debug_frame_common", "section_debug_frame", @@ -2498,9 +2498,9 @@ private: EmitDifference("func_end", DebugFrameInfo.Number, "func_begin", DebugFrameInfo.Number); Asm->EOL("FDE address range"); - + EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves, false); - + Asm->EmitAlignment(2, 0, 0, false); EmitLabel("debug_frame_end", DebugFrameInfo.Number); @@ -2512,15 +2512,15 @@ private: void EmitDebugPubNames() { // Start the dwarf pubnames section. Asm->SwitchToDataSection(TAI->getDwarfPubNamesSection()); - - CompileUnit *Unit = GetBaseCompileUnit(); - + + 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"); EmitSectionOffset("info_begin", "section_info", @@ -2529,22 +2529,22 @@ private: 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; - + 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(); } @@ -2555,7 +2555,7 @@ private: if (!StringPool.empty()) { // Start the dwarf str section. Asm->SwitchToDataSection(TAI->getDwarfStrSection()); - + // For each of strings in the string pool. for (unsigned StringID = 1, N = StringPool.size(); StringID <= N; ++StringID) { @@ -2565,7 +2565,7 @@ private: const std::string &String = StringPool[StringID]; Asm->EmitString(String); Asm->EOL(); } - + Asm->EOL(); } } @@ -2575,7 +2575,7 @@ private: void EmitDebugLoc() { // Start the dwarf loc section. Asm->SwitchToDataSection(TAI->getDwarfLocSection()); - + Asm->EOL(); } @@ -2584,16 +2584,16 @@ private: void EmitDebugARanges() { // Start the dwarf aranges section. Asm->SwitchToDataSection(TAI->getDwarfARangesSection()); - + // FIXME - Mock up #if 0 - CompileUnit *Unit = GetBaseCompileUnit(); - + CompileUnit *Unit = GetBaseCompileUnit(); + // 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"); @@ -2611,7 +2611,7 @@ private: Asm->EmitInt32(0); Asm->EOL("EOM (1)"); Asm->EmitInt32(0); Asm->EOL("EOM (2)"); #endif - + Asm->EOL(); } @@ -2620,7 +2620,7 @@ private: void EmitDebugRanges() { // Start the dwarf ranges section. Asm->SwitchToDataSection(TAI->getDwarfRangesSection()); - + Asm->EOL(); } @@ -2629,7 +2629,7 @@ private: void EmitDebugMacInfo() { // Start the dwarf macinfo section. Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection()); - + Asm->EOL(); } @@ -2637,7 +2637,7 @@ private: /// header file. void ConstructCompileUnitDIEs() { const UniqueVector CUW = MMI->getCompileUnits(); - + for (unsigned i = 1, N = CUW.size(); i <= N; ++i) { unsigned ID = MMI->RecordSource(CUW[i]); CompileUnit *Unit = NewCompileUnit(CUW[i], ID); @@ -2650,7 +2650,7 @@ private: void ConstructGlobalDIEs() { std::vector GlobalVariables; MMI->getAnchoredDescriptors(*M, GlobalVariables); - + for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) { GlobalVariableDesc *GVD = GlobalVariables[i]; NewGlobalVariable(GVD); @@ -2662,7 +2662,7 @@ private: void ConstructSubprogramDIEs() { std::vector Subprograms; MMI->getAnchoredDescriptors(*M, Subprograms); - + for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) { SubprogramDesc *SPD = Subprograms[i]; NewSubprogram(SPD); @@ -2702,16 +2702,16 @@ public: if (!MMI && mmi->hasDebugInfo()) { MMI = mmi; shouldEmit = true; - + // Create all the compile unit DIEs. ConstructCompileUnitDIEs(); - + // Create DIEs for each of the externally visible global variables. ConstructGlobalDIEs(); // Create DIEs for each of the externally visible subprograms. ConstructSubprogramDIEs(); - + // Prime section data. SectionMap.insert(TAI->getTextSection()); @@ -2744,13 +2744,13 @@ public: /// void EndModule() { if (!ShouldEmitDwarf()) return; - + // Standard sections final addresses. Asm->SwitchToTextSection(TAI->getTextSection()); EmitLabel("text_end", 0); Asm->SwitchToDataSection(TAI->getDataSection()); EmitLabel("data_end", 0); - + // End text sections. for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) { Asm->SwitchToTextSection(SectionMap[i].c_str()); @@ -2767,45 +2767,45 @@ public: // Compute DIE offsets and sizes. SizeAndOffsets(); - + // Emit all the DIEs into a debug info section EmitDebugInfo(); - + // Corresponding abbreviations into a abbrev section. EmitAbbreviations(); - + // Emit source line correspondence into a debug line section. EmitDebugLines(); - + // Emit info into a debug pubnames section. EmitDebugPubNames(); - + // Emit info into a debug str section. EmitDebugStr(); - + // Emit info into a debug loc section. EmitDebugLoc(); - + // Emit info into a debug aranges section. EmitDebugARanges(); - + // Emit info into a debug ranges section. EmitDebugRanges(); - + // Emit info into a debug macinfo section. EmitDebugMacInfo(); } - /// BeginFunction - Gather pre-function debug information. Assumes being + /// BeginFunction - Gather pre-function debug information. Assumes being /// emitted immediately after the function entry point. void BeginFunction(MachineFunction *MF) { this->MF = MF; - + if (!ShouldEmitDwarf()) return; // Begin accumulating function debug information. MMI->BeginFunction(MF); - + // Assumes in correct section after the entry point. EmitLabel("func_begin", ++SubprogramCount); @@ -2817,15 +2817,15 @@ public: Asm->printLabel(LineInfo.getLabelID()); } } - + /// EndFunction - Gather and emit post-function debug information. /// void EndFunction() { if (!ShouldEmitDwarf()) return; - + // Define end label for subprogram. EmitLabel("func_end", SubprogramCount); - + // Get function line info. const std::vector &LineInfos = MMI->getSourceLines(); @@ -2838,7 +2838,7 @@ public: SectionLineInfos.insert(SectionLineInfos.end(), LineInfos.begin(), LineInfos.end()); } - + // Construct scopes for subprogram. ConstructRootScope(MMI->getRootScope()); @@ -2848,7 +2848,7 @@ public: }; //===----------------------------------------------------------------------===// -/// DwarfException - Emits Dwarf exception handling directives. +/// DwarfException - Emits Dwarf exception handling directives. /// class DwarfException : public Dwarf { @@ -2884,7 +2884,7 @@ private: /// should be emitted. bool shouldEmitTableModule; - /// shouldEmitFrameModule - Per-module flag to indicate if frame moves + /// shouldEmitFrameModule - Per-module flag to indicate if frame moves /// should be emitted. bool shouldEmitMovesModule; @@ -2970,7 +2970,7 @@ private: // On Darwin the linker honors the alignment of eh_frame, which means it // must be 8-byte on 64-bit targets to match what gcc does. Otherwise // you get holes which confuse readers of eh_frame. - Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3, + Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3, 0, 0, false); EmitLabel("eh_frame_common_end", Index); @@ -2993,26 +2993,26 @@ private: } // If corresponding function is weak definition, this should be too. - if ((linkage == Function::WeakLinkage || + 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. + // symbols. // If UnwindTablesMandatory is set we cannot do this optimization; the // unwind info is to be available for non-EH uses. if (!EHFrameInfo.hasCalls && !UnwindTablesMandatory && - ((linkage != Function::WeakLinkage && + ((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 + // 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"; @@ -3023,7 +3023,7 @@ private: 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", @@ -3056,17 +3056,17 @@ private: // Indicate locations of function specific callee saved registers in // frame. EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves, true); - + // On Darwin the linker honors the alignment of eh_frame, which means it // must be 8-byte on 64-bit targets to match what gcc does. Otherwise // you get holes which confuse readers of eh_frame. - Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3, + Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3, 0, 0, false); EmitLabel("eh_frame_end", EHFrameInfo.Number); - - // If the function is marked used, this table should be also. We cannot + + // 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 + // 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)) @@ -3188,7 +3188,7 @@ private: for(std::vector::const_iterator I = FilterIds.begin(), E = FilterIds.end(); I != E; ++I) { FilterOffsets.push_back(Offset); - Offset -= Asm->SizeULEB128(*I); + Offset -= TargetAsmInfo::getULEB128Size(*I); } // Compute the actions table and gather the first action index for each @@ -3213,10 +3213,11 @@ private: const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size(); assert(Actions.size()); PrevAction = &Actions.back(); - SizeAction = Asm->SizeSLEB128(PrevAction->NextAction) + - Asm->SizeSLEB128(PrevAction->ValueForTypeID); + SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) + + TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID); for (unsigned j = NumShared; j != SizePrevIds; ++j) { - SizeAction -= Asm->SizeSLEB128(PrevAction->ValueForTypeID); + SizeAction -= + TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID); SizeAction += -PrevAction->NextAction; PrevAction = PrevAction->Previous; } @@ -3227,10 +3228,10 @@ private: 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); + unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID); int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0; - SizeAction = SizeTypeID + Asm->SizeSLEB128(NextAction); + SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction); SizeSiteActions += SizeAction; ActionEntry Action = {ValueForTypeID, NextAction, PrevAction}; @@ -3364,19 +3365,19 @@ private: SiteLengthSize + LandingPadSize); for (unsigned i = 0, e = CallSites.size(); i < e; ++i) - SizeSites += Asm->SizeULEB128(CallSites[i].Action); + SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action); // Type infos. const unsigned TypeInfoSize = TD->getPointerSize(); // DW_EH_PE_absptr unsigned SizeTypes = TypeInfos.size() * TypeInfoSize; unsigned TypeOffset = sizeof(int8_t) + // Call site format - Asm->SizeULEB128(SizeSites) + // Call-site table length + TargetAsmInfo::getULEB128Size(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 + TargetAsmInfo::getULEB128Size(TypeOffset) + // TType base offset TypeOffset; unsigned SizeAlign = (4 - TotalSize) & 3; @@ -3485,7 +3486,7 @@ public: , shouldEmitTableModule(false) , shouldEmitMovesModule(false) {} - + virtual ~DwarfException() {} /// SetModuleInfo - Set machine module information when it's known that pass @@ -3514,7 +3515,7 @@ public: } } - /// BeginFunction - Gather pre-function exception information. Assumes being + /// BeginFunction - Gather pre-function exception information. Assumes being /// emitted immediately after the function entry point. void BeginFunction(MachineFunction *MF) { this->MF = MF; @@ -3569,19 +3570,19 @@ void DIEAbbrev::Emit(const DwarfDebug &DD) const { // Emit its Dwarf tag type. DD.getAsm()->EmitULEB128Bytes(Tag); DD.getAsm()->EOL(TagString(Tag)); - + // Emit whether it has children DIEs. 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. DD.getAsm()->EmitULEB128Bytes(AttrData.getAttribute()); DD.getAsm()->EOL(AttributeString(AttrData.getAttribute())); - + // Emit form type. DD.getAsm()->EmitULEB128Bytes(AttrData.getForm()); DD.getAsm()->EOL(FormEncodingString(AttrData.getForm())); @@ -3601,7 +3602,7 @@ void DIEAbbrev::print(std::ostream &O) { << " " << ChildrenString(ChildrenFlag) << "\n"; - + for (unsigned i = 0, N = Data.size(); i < N; ++i) { O << " " << AttributeString(Data[i].getAttribute()) @@ -3655,8 +3656,8 @@ unsigned DIEInteger::SizeOf(const DwarfDebug &DD, unsigned Form) const { 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 DD.getAsm()->SizeULEB128(Integer); - case DW_FORM_sdata: return DD.getAsm()->SizeSLEB128(Integer); + case DW_FORM_udata: return TargetAsmInfo::getULEB128Size(Integer); + case DW_FORM_sdata: return TargetAsmInfo::getSLEB128Size(Integer); default: assert(0 && "DIE Value form not supported yet"); break; } return 0; @@ -3701,7 +3702,7 @@ unsigned DIEObjectLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const { if (Form == DW_FORM_data4) return 4; return DD.getTargetData()->getPointerSize(); } - + //===----------------------------------------------------------------------===// /// EmitValue - Emit delta value. @@ -3718,7 +3719,7 @@ unsigned DIESectionOffset::SizeOf(const DwarfDebug &DD, unsigned Form) const { if (Form == DW_FORM_data4) return 4; return DD.getTargetData()->getPointerSize(); } - + //===----------------------------------------------------------------------===// /// EmitValue - Emit delta value. @@ -3742,7 +3743,7 @@ unsigned DIEDelta::SizeOf(const DwarfDebug &DD, unsigned Form) const { void DIEntry::EmitValue(DwarfDebug &DD, unsigned Form) { DD.getAsm()->EmitInt32(Entry->getOffset()); } - + //===----------------------------------------------------------------------===// /// ComputeSize - calculate the size of the block. @@ -3750,7 +3751,7 @@ void DIEntry::EmitValue(DwarfDebug &DD, unsigned Form) { unsigned DIEBlock::ComputeSize(DwarfDebug &DD) { if (!Size) { const SmallVector &AbbrevData = Abbrev.getData(); - + for (unsigned i = 0, N = Values.size(); i < N; ++i) { Size += Values[i]->SizeOf(DD, AbbrevData[i].getForm()); } @@ -3768,7 +3769,7 @@ void DIEBlock::EmitValue(DwarfDebug &DD, unsigned Form) { case DW_FORM_block: DD.getAsm()->EmitULEB128Bytes(Size); break; default: assert(0 && "Improper form for block"); break; } - + const SmallVector &AbbrevData = Abbrev.getData(); for (unsigned i = 0, N = Values.size(); i < N; ++i) { @@ -3784,7 +3785,7 @@ unsigned DIEBlock::SizeOf(const DwarfDebug &DD, unsigned Form) const { 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 + DD.getAsm()->SizeULEB128(Size); + case DW_FORM_block: return Size + TargetAsmInfo::getULEB128Size(Size); default: assert(0 && "Improper form for block"); break; } return 0; @@ -3797,7 +3798,7 @@ DIE::~DIE() { for (unsigned i = 0, N = Children.size(); i < N; ++i) delete Children[i]; } - + /// AddSiblingOffset - Add a sibling offset field to the front of the DIE. /// void DIE::AddSiblingOffset() { @@ -3810,7 +3811,7 @@ void DIE::AddSiblingOffset() { /// void DIE::Profile(FoldingSetNodeID &ID) { Abbrev.Profile(ID); - + for (unsigned i = 0, N = Children.size(); i < N; ++i) ID.AddPointer(Children[i]); @@ -3824,15 +3825,15 @@ void DIE::print(std::ostream &O, unsigned IncIndent) { IndentCount += IncIndent; const std::string Indent(IndentCount, ' '); bool isBlock = Abbrev.getTag() == 0; - + if (!isBlock) { O << Indent << "Die: " << "0x" << std::hex << (intptr_t)this << std::dec << ", Offset: " << Offset << ", Size: " << Size - << "\n"; - + << "\n"; + O << Indent << TagString(Abbrev.getTag()) << " " @@ -3843,7 +3844,7 @@ void DIE::print(std::ostream &O, unsigned IncIndent) { O << "\n"; const SmallVector &Data = Abbrev.getData(); - + IndentCount += 2; for (unsigned i = 0, N = Data.size(); i < N; ++i) { O << Indent; @@ -3864,7 +3865,7 @@ void DIE::print(std::ostream &O, unsigned IncIndent) { for (unsigned j = 0, M = Children.size(); j < M; ++j) { Children[j]->print(O, 4); } - + if (!isBlock) O << "\n"; IndentCount -= IncIndent; } @@ -3910,7 +3911,7 @@ void DwarfWriter::EndModule() { DD->EndModule(); } -/// BeginFunction - Gather pre-function debug information. Assumes being +/// BeginFunction - Gather pre-function debug information. Assumes being /// emitted immediately after the function entry point. void DwarfWriter::BeginFunction(MachineFunction *MF) { DE->BeginFunction(MF); @@ -3922,7 +3923,7 @@ void DwarfWriter::BeginFunction(MachineFunction *MF) { void DwarfWriter::EndFunction() { DD->EndFunction(); DE->EndFunction(); - + if (MachineModuleInfo *MMI = DD->getMMI() ? DD->getMMI() : DE->getMMI()) // Clear function debug information. MMI->EndFunction(); diff --git a/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp b/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp index 842eb25d579..1bbad863d61 100644 --- a/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp +++ b/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp @@ -16,7 +16,6 @@ #include "JITDwarfEmitter.h" #include "llvm/Function.h" #include "llvm/ADT/DenseMap.h" -#include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/MachineCodeEmitter.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineLocation.h" @@ -244,7 +243,7 @@ unsigned char* JITDwarfEmitter::EmitExceptionTable(MachineFunction* MF, for(std::vector::const_iterator I = FilterIds.begin(), E = FilterIds.end(); I != E; ++I) { FilterOffsets.push_back(Offset); - Offset -= AsmPrinter::SizeULEB128(*I); + Offset -= TargetAsmInfo::getULEB128Size(*I); } // Compute the actions table and gather the first action index for each @@ -269,10 +268,10 @@ unsigned char* JITDwarfEmitter::EmitExceptionTable(MachineFunction* MF, const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size(); assert(Actions.size()); PrevAction = &Actions.back(); - SizeAction = AsmPrinter::SizeSLEB128(PrevAction->NextAction) + - AsmPrinter::SizeSLEB128(PrevAction->ValueForTypeID); + SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) + + TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID); for (unsigned j = NumShared; j != SizePrevIds; ++j) { - SizeAction -= AsmPrinter::SizeSLEB128(PrevAction->ValueForTypeID); + SizeAction -= TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID); SizeAction += -PrevAction->NextAction; PrevAction = PrevAction->Previous; } @@ -283,10 +282,10 @@ unsigned char* JITDwarfEmitter::EmitExceptionTable(MachineFunction* MF, int TypeID = TypeIds[I]; assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!"); int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID; - unsigned SizeTypeID = AsmPrinter::SizeSLEB128(ValueForTypeID); + unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID); int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0; - SizeAction = SizeTypeID + AsmPrinter::SizeSLEB128(NextAction); + SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction); SizeSiteActions += SizeAction; ActionEntry Action = {ValueForTypeID, NextAction, PrevAction}; @@ -389,18 +388,18 @@ unsigned char* JITDwarfEmitter::EmitExceptionTable(MachineFunction* MF, sizeof(int32_t) + // Site length. sizeof(int32_t)); // Landing pad. for (unsigned i = 0, e = CallSites.size(); i < e; ++i) - SizeSites += AsmPrinter::SizeULEB128(CallSites[i].Action); + SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action); unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize(); unsigned TypeOffset = sizeof(int8_t) + // Call site format // Call-site table length - AsmPrinter::SizeULEB128(SizeSites) + + TargetAsmInfo::getULEB128Size(SizeSites) + SizeSites + SizeActions + SizeTypes; unsigned TotalSize = sizeof(int8_t) + // LPStart format sizeof(int8_t) + // TType format - AsmPrinter::SizeULEB128(TypeOffset) + // TType base offset + TargetAsmInfo::getULEB128Size(TypeOffset) + // TType base offset TypeOffset; unsigned SizeAlign = (4 - TotalSize) & 3; @@ -684,10 +683,10 @@ JITDwarfEmitter::GetEHFrameSizeInBytes(const Function* Personality, // If there is a personality and landing pads then point to the language // specific data area in the exception table. if (MMI->getPersonalityIndex()) { - FinalSize += AsmPrinter::SizeULEB128(4); + FinalSize += TargetAsmInfo::getULEB128Size(4); FinalSize += PointerSize; } else { - FinalSize += AsmPrinter::SizeULEB128(0); + FinalSize += TargetAsmInfo::getULEB128Size(0); } // Indicate locations of function specific callee saved registers in @@ -715,24 +714,24 @@ unsigned JITDwarfEmitter::GetCommonEHFrameSizeInBytes(const Function* Personalit FinalSize += 4; FinalSize += 1; FinalSize += Personality ? 5 : 3; // "zPLR" or "zR" - FinalSize += AsmPrinter::SizeULEB128(1); - FinalSize += AsmPrinter::SizeSLEB128(stackGrowth); + FinalSize += TargetAsmInfo::getULEB128Size(1); + FinalSize += TargetAsmInfo::getSLEB128Size(stackGrowth); FinalSize += 1; if (Personality) { - FinalSize += AsmPrinter::SizeULEB128(7); + FinalSize += TargetAsmInfo::getULEB128Size(7); // Encoding FinalSize+= 1; //Personality FinalSize += PointerSize; - FinalSize += AsmPrinter::SizeULEB128(dwarf::DW_EH_PE_pcrel); - FinalSize += AsmPrinter::SizeULEB128(dwarf::DW_EH_PE_pcrel); + FinalSize += TargetAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel); + FinalSize += TargetAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel); } else { - FinalSize += AsmPrinter::SizeULEB128(1); - FinalSize += AsmPrinter::SizeULEB128(dwarf::DW_EH_PE_pcrel); + FinalSize += TargetAsmInfo::getULEB128Size(1); + FinalSize += TargetAsmInfo::getULEB128Size(dwarf::DW_EH_PE_pcrel); } std::vector Moves; @@ -784,12 +783,12 @@ JITDwarfEmitter::GetFrameMovesSizeInBytes(intptr_t BaseLabelPtr, } else { ++FinalSize; unsigned RegNum = RI->getDwarfRegNum(Src.getRegister(), true); - FinalSize += AsmPrinter::SizeULEB128(RegNum); + FinalSize += TargetAsmInfo::getULEB128Size(RegNum); } int Offset = -Src.getOffset(); - FinalSize += AsmPrinter::SizeULEB128(Offset); + FinalSize += TargetAsmInfo::getULEB128Size(Offset); } else { assert(0 && "Machine move no supported yet."); } @@ -798,7 +797,7 @@ JITDwarfEmitter::GetFrameMovesSizeInBytes(intptr_t BaseLabelPtr, if (Dst.isRegister()) { ++FinalSize; unsigned RegNum = RI->getDwarfRegNum(Dst.getRegister(), true); - FinalSize += AsmPrinter::SizeULEB128(RegNum); + FinalSize += TargetAsmInfo::getULEB128Size(RegNum); } else { assert(0 && "Machine move no supported yet."); } @@ -808,15 +807,15 @@ JITDwarfEmitter::GetFrameMovesSizeInBytes(intptr_t BaseLabelPtr, if (Offset < 0) { ++FinalSize; - FinalSize += AsmPrinter::SizeULEB128(Reg); - FinalSize += AsmPrinter::SizeSLEB128(Offset); + FinalSize += TargetAsmInfo::getULEB128Size(Reg); + FinalSize += TargetAsmInfo::getSLEB128Size(Offset); } else if (Reg < 64) { ++FinalSize; - FinalSize += AsmPrinter::SizeULEB128(Offset); + FinalSize += TargetAsmInfo::getULEB128Size(Offset); } else { ++FinalSize; - FinalSize += AsmPrinter::SizeULEB128(Reg); - FinalSize += AsmPrinter::SizeULEB128(Offset); + FinalSize += TargetAsmInfo::getULEB128Size(Reg); + FinalSize += TargetAsmInfo::getULEB128Size(Offset); } } } @@ -859,7 +858,7 @@ JITDwarfEmitter::GetExceptionTableSizeInBytes(MachineFunction* MF) const { for(std::vector::const_iterator I = FilterIds.begin(), E = FilterIds.end(); I != E; ++I) { FilterOffsets.push_back(Offset); - Offset -= AsmPrinter::SizeULEB128(*I); + Offset -= TargetAsmInfo::getULEB128Size(*I); } // Compute the actions table and gather the first action index for each @@ -884,10 +883,10 @@ JITDwarfEmitter::GetExceptionTableSizeInBytes(MachineFunction* MF) const { const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size(); assert(Actions.size()); PrevAction = &Actions.back(); - SizeAction = AsmPrinter::SizeSLEB128(PrevAction->NextAction) + - AsmPrinter::SizeSLEB128(PrevAction->ValueForTypeID); + SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) + + TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID); for (unsigned j = NumShared; j != SizePrevIds; ++j) { - SizeAction -= AsmPrinter::SizeSLEB128(PrevAction->ValueForTypeID); + SizeAction -= TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID); SizeAction += -PrevAction->NextAction; PrevAction = PrevAction->Previous; } @@ -898,10 +897,10 @@ JITDwarfEmitter::GetExceptionTableSizeInBytes(MachineFunction* MF) const { int TypeID = TypeIds[I]; assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!"); int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID; - unsigned SizeTypeID = AsmPrinter::SizeSLEB128(ValueForTypeID); + unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID); int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0; - SizeAction = SizeTypeID + AsmPrinter::SizeSLEB128(NextAction); + SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction); SizeSiteActions += SizeAction; ActionEntry Action = {ValueForTypeID, NextAction, PrevAction}; @@ -1004,18 +1003,18 @@ JITDwarfEmitter::GetExceptionTableSizeInBytes(MachineFunction* MF) const { sizeof(int32_t) + // Site length. sizeof(int32_t)); // Landing pad. for (unsigned i = 0, e = CallSites.size(); i < e; ++i) - SizeSites += AsmPrinter::SizeULEB128(CallSites[i].Action); + SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action); unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize(); unsigned TypeOffset = sizeof(int8_t) + // Call site format // Call-site table length - AsmPrinter::SizeULEB128(SizeSites) + + TargetAsmInfo::getULEB128Size(SizeSites) + SizeSites + SizeActions + SizeTypes; unsigned TotalSize = sizeof(int8_t) + // LPStart format sizeof(int8_t) + // TType format - AsmPrinter::SizeULEB128(TypeOffset) + // TType base offset + TargetAsmInfo::getULEB128Size(TypeOffset) + // TType base offset TypeOffset; unsigned SizeAlign = (4 - TotalSize) & 3; @@ -1053,7 +1052,7 @@ JITDwarfEmitter::GetExceptionTableSizeInBytes(MachineFunction* MF) const { // Asm->EOL("Landing pad"); FinalSize += PointerSize; - FinalSize += AsmPrinter::SizeULEB128(S.Action); + FinalSize += TargetAsmInfo::getULEB128Size(S.Action); // Asm->EOL("Action"); } @@ -1062,9 +1061,9 @@ JITDwarfEmitter::GetExceptionTableSizeInBytes(MachineFunction* MF) const { ActionEntry &Action = Actions[I]; //Asm->EOL("TypeInfo index"); - FinalSize += AsmPrinter::SizeSLEB128(Action.ValueForTypeID); + FinalSize += TargetAsmInfo::getSLEB128Size(Action.ValueForTypeID); //Asm->EOL("Next action"); - FinalSize += AsmPrinter::SizeSLEB128(Action.NextAction); + FinalSize += TargetAsmInfo::getSLEB128Size(Action.NextAction); } // Emit the type ids. @@ -1076,7 +1075,7 @@ JITDwarfEmitter::GetExceptionTableSizeInBytes(MachineFunction* MF) const { // Emit the filter typeids. for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) { unsigned TypeID = FilterIds[j]; - FinalSize += AsmPrinter::SizeULEB128(TypeID); + FinalSize += TargetAsmInfo::getULEB128Size(TypeID); //Asm->EOL("Filter TypeInfo index"); } diff --git a/lib/Target/TargetAsmInfo.cpp b/lib/Target/TargetAsmInfo.cpp index 1ef2182033e..cc0745f680a 100644 --- a/lib/Target/TargetAsmInfo.cpp +++ b/lib/Target/TargetAsmInfo.cpp @@ -389,3 +389,26 @@ TargetAsmInfo::getSectionFlags(unsigned Flags) const { return I->second; } + +unsigned TargetAsmInfo::getULEB128Size(unsigned Value) { + unsigned Size = 0; + do { + Value >>= 7; + Size += sizeof(int8_t); + } while (Value); + return Size; +} + +unsigned TargetAsmInfo::getSLEB128Size(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; +}