diff --git a/llvm/lib/CodeGen/DwarfWriter.cpp b/llvm/lib/CodeGen/DwarfWriter.cpp
index 335623c..5d6acc3 100644
--- a/llvm/lib/CodeGen/DwarfWriter.cpp
+++ b/llvm/lib/CodeGen/DwarfWriter.cpp
@@ -42,7 +42,7 @@
 using namespace llvm::dwarf;
 
 namespace llvm {
-  
+
 //===----------------------------------------------------------------------===//
 
 /// Configuration values for initial hash set sizes (log2).
@@ -59,26 +59,26 @@
 
 //===----------------------------------------------------------------------===//
 /// DWLabel - Labels are used to track locations in the assembler file.
-/// Labels appear in the form @verbatim <prefix><Tag><Number> @endverbatim, 
-/// where the tag is a category of label (Ex. location) and number is a value 
+/// Labels appear in the form @verbatim <prefix><Tag><Number> @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 @@
   /// 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 @@
   /// Tag - Dwarf tag code.
   ///
   unsigned Tag;
-  
+
   /// Unique number for node.
   ///
   unsigned Number;
@@ -150,7 +150,7 @@
   , Data()
   {}
   ~DIEAbbrev() {}
-  
+
   // Accessors.
   unsigned getTag()                           const { return Tag; }
   unsigned getNumber()                        const { return Number; }
@@ -159,34 +159,34 @@
   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 @@
   /// 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<DIE *> Children;
-  
+
   /// Attributes values.
   ///
   SmallVector<DIEValue*, 32> Values;
-  
+
 public:
   explicit DIE(unsigned Tag)
   : Abbrev(Tag, DW_CHILDREN_no)
@@ -230,7 +230,7 @@
   , Values()
   {}
   virtual ~DIE();
-  
+
   // Accessors.
   DIEAbbrev &getAbbrev()                           { return Abbrev; }
   unsigned   getAbbrevNumber()               const {
@@ -244,18 +244,18 @@
   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 @@
     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 @@
     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 @@
 
 //===----------------------------------------------------------------------===//
 /// 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 @@
     }
     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 @@
     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 @@
 
 //===----------------------------------------------------------------------===//
 /// 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 @@
     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 @@
 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 @@
     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 @@
 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 @@
   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 @@
   // 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 @@
 
 //===----------------------------------------------------------------------===//
 /// 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 @@
 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 @@
   }
   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 @@
 class DIEBlock : public DIEValue, public DIE {
 public:
   unsigned Size;                        // Size in bytes excluding size header.
-  
+
   DIEBlock()
   : DIEValue(isBlock)
   , DIE(0)
@@ -659,15 +659,15 @@
   {}
   ~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 @@
   /// 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 @@
     ID.AddInteger(isBlock);
     DIE::Profile(ID);
   }
-  
+
 #ifndef NDEBUG
   virtual void print(std::ostream &O) {
     O << "Blk: ";
@@ -709,15 +709,15 @@
   /// 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<DebugInfoDesc *, DIE *> DescToDieMap;
@@ -733,11 +733,11 @@
   /// DiesSet - Used to uniquely define dies within the compile unit.
   ///
   FoldingSet<DIE> DiesSet;
-  
+
   /// Dies - List of all dies in the compile unit.
   ///
   std::vector<DIE *> Dies;
-  
+
 public:
   CompileUnit(CompileUnitDesc *CUD, unsigned I, DIE *D)
   : Desc(CUD)
@@ -749,14 +749,14 @@
   , 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 @@
   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 @@
     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 @@
   //===--------------------------------------------------------------------===//
   // Core attributes used by the Dwarf writer.
   //
-  
+
   //
   /// O - Stream to .s file.
   ///
@@ -825,32 +825,32 @@
   /// 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 @@
     else
       O << TAI->getData64bitsDirective();
   }
-  
+
   /// PrintLabelName - Print label name in form used by Dwarf writer.
   ///
   void PrintLabelName(DWLabel Label) const {
@@ -901,14 +901,14 @@
     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 @@
     PrintLabelName(Tag, Number);
     O << ":\n";
   }
-  
+
   /// EmitReference - Emit a reference to a label.
   ///
   void EmitReference(DWLabel Label, bool IsPCRelative = false,
@@ -929,15 +929,15 @@
                      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 @@
       ++SetCounter;
     } else {
       PrintRelDirective(IsSmall);
-        
+
       PrintLabelName(TagHi, NumberHi);
       O << "-";
       PrintLabelName(TagLo, NumberLo);
@@ -993,25 +993,25 @@
       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 @@
     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 @@
             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 @@
       } 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 @@
 };
 
 //===----------------------------------------------------------------------===//
-/// DwarfDebug - Emits Dwarf debug directives. 
+/// DwarfDebug - Emits Dwarf debug directives.
 ///
 class DwarfDebug : public Dwarf {
 
@@ -1120,11 +1120,11 @@
   //===--------------------------------------------------------------------===//
   // 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<CompileUnit *> CompileUnits;
-  
+
   /// AbbreviationsSet - Used to uniquely define abbreviations.
   ///
   FoldingSet<DIEAbbrev> AbbreviationsSet;
@@ -1132,15 +1132,15 @@
   /// Abbreviations - A list of all the unique abbreviations in use.
   ///
   std::vector<DIEAbbrev *> Abbreviations;
-  
+
   /// ValuesSet - Used to uniquely define values.
   ///
   FoldingSet<DIEValue> ValuesSet;
-  
+
   /// Values - A list of all the unique values in use.
   ///
   std::vector<DIEValue *> Values;
-  
+
   /// StringPool - A UniqueVector of strings used by indirect references.
   ///
   UniqueVector<std::string> StringPool;
@@ -1148,11 +1148,11 @@
   /// UnitMap - Map debug information descriptor to compile unit.
   ///
   std::map<DebugInfoDesc *, CompileUnit *> DescToUnitMap;
-  
+
   /// SectionMap - Provides a unique id per text section.
   ///
   UniqueVector<std::string> SectionMap;
-  
+
   /// SectionSourceLines - Tracks line numbers per text section.
   ///
   std::vector<std::vector<SourceLineInfo> > SectionSourceLines;
@@ -1160,7 +1160,7 @@
   /// 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 @@
   };
 
   std::vector<FunctionDebugFrameInfo> 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 @@
     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<DIEntry *>(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 @@
       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 @@
       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 @@
       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 @@
       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 @@
       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 @@
       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 @@
       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 @@
       delete Block;
       Block = cast<DIEBlock>(Value);
     }
-  
+
     Die->AddValue(Attribute, Block->BestForm(), Value);
   }
 
@@ -1410,7 +1410,7 @@
                             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 @@
       }
       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 @@
     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 @@
     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 @@
     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 @@
     } 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<SubprogramDesc>(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 @@
         // 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 @@
       }
     }
   }
-  
+
   /// 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<BasicTypeDesc>(TyDesc)) {
       // Fundamental types like int, float, bool
       Buffer.setTag(DW_TAG_base_type);
@@ -1524,7 +1524,7 @@
       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 @@
     } else if (CompositeTypeDesc *CompTy = dyn_cast<CompositeTypeDesc>(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<DebugInfoDesc *> &Elements = CompTy->getElements();
-      
+
       switch (Tag) {
       case DW_TAG_vector_type:
         AddUInt(&Buffer, DW_AT_GNU_vector, DW_FORM_flag, 1);
@@ -1549,21 +1549,21 @@
         // 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<SubrangeDesc>(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 @@
             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 @@
         // Add elements to structure type.
         for(unsigned i = 0, N = Elements.size(); i < N; ++i) {
           DebugInfoDesc *Element = Elements[i];
-          
+
           if (DerivedTypeDesc *MemberDesc = dyn_cast<DerivedTypeDesc>(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 @@
                 FieldAlign = FromTy->getSize();
                 break;
               }
-              
+
               FromTy = cast<DerivedTypeDesc>(FromTy)->getFromType();
             }
-            
+
             // Unless we have a bit field.
             if (Tag == DW_TAG_member && FieldSize != Size) {
               // Construct the alignment mask.
@@ -1632,16 +1632,16 @@
               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 @@
             } else if (Tag == DW_TAG_inheritance) {
               AddUInt(Member, DW_AT_accessibility, 0, DW_ACCESS_public);
             }
-            
+
             Buffer.AddChild(Member);
           } else if (GlobalVariableDesc *StaticDesc =
                                         dyn_cast<GlobalVariableDesc>(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 @@
               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<SubprogramDesc>(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<CompositeTypeDesc>(MethodDesc->getType())) {
               // Get argument information.
               std::vector<DebugInfoDesc *> &Args = MethodTy->getElements();
-             
+
               // If not a ctor.
               if (!IsCTor) {
                 // Add return type.
                 AddType(Method, dyn_cast<TypeDesc>(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 @@
             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 @@
         AddUInt(&Buffer, DW_AT_prototyped, DW_FORM_flag, 1);
         // Add return type.
         AddType(&Buffer, dyn_cast<TypeDesc>(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<TypeDesc>(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 @@
     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 @@
     // 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 @@
     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 @@
     // 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 @@
     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 @@
 
     // 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 @@
       DIE *VariableDie = NewScopeVariable(Variables[i], Unit);
       if (VariableDie) ParentDie->AddChild(VariableDie);
     }
-    
+
     // Add nested scopes.
     std::vector<DebugScope *> &Scopes = ParentScope->getScopes();
     for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
@@ -1966,20 +1966,20 @@
       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 @@
           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 @@
   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<SubprogramDesc>(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 @@
     // 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 @@
     // 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 @@
                            TagString(Abbrev->getTag())));
     else
       Asm->EOL();
-    
+
     SmallVector<DIEValue*, 32> &Values = Die->getValues();
     const SmallVector<DIEAbbrevData, 8> &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 @@
         break;
       }
       }
-      
+
       Asm->EOL(AttributeString(Attr));
     }
-    
+
     // Emit the DIE children if any.
     if (Abbrev->getChildrenFlag() == DW_CHILDREN_yes) {
       const std::vector<DIE *> &Children = Die->getChildren();
-      
+
       for (unsigned j = 0, M = Children.size(); j < M; ++j) {
         EmitDIE(Children[j]);
       }
-      
+
       Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
     }
   }
@@ -2129,23 +2129,23 @@
   unsigned SizeAndOffsetDie(DIE *Die, unsigned Offset, bool Last) {
     // Get the children.
     const std::vector<DIE *> &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<DIEValue*, 32> &Values = Die->getValues();
     const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
 
@@ -2154,16 +2154,16 @@
       // 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 @@
   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 @@
                            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 @@
     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 @@
     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 @@
 
     // 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 @@
       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 @@
       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 @@
       // 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 @@
         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 @@
       // 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 @@
     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<MachineMove> Moves;
     RI->getInitialFrameState(Moves);
 
@@ -2470,7 +2470,7 @@
 
     Asm->EmitAlignment(2, 0, 0, false);
     EmitLabel("debug_frame_common_end", 0);
-    
+
     Asm->EOL();
   }
 
@@ -2479,14 +2479,14 @@
   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 @@
     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 @@
   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 @@
 
     EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),true);
     Asm->EOL("Compilation Unit Length");
-    
+
     std::map<std::string, DIE *> &Globals = Unit->getGlobals();
-    
+
     for (std::map<std::string, DIE *>::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 @@
     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 @@
         const std::string &String = StringPool[StringID];
         Asm->EmitString(String); Asm->EOL();
       }
-    
+
       Asm->EOL();
     }
   }
@@ -2575,7 +2575,7 @@
   void EmitDebugLoc() {
     // Start the dwarf loc section.
     Asm->SwitchToDataSection(TAI->getDwarfLocSection());
-    
+
     Asm->EOL();
   }
 
@@ -2584,16 +2584,16 @@
   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 @@
     Asm->EmitInt32(0); Asm->EOL("EOM (1)");
     Asm->EmitInt32(0); Asm->EOL("EOM (2)");
   #endif
-    
+
     Asm->EOL();
   }
 
@@ -2620,7 +2620,7 @@
   void EmitDebugRanges() {
     // Start the dwarf ranges section.
     Asm->SwitchToDataSection(TAI->getDwarfRangesSection());
-    
+
     Asm->EOL();
   }
 
@@ -2629,7 +2629,7 @@
   void EmitDebugMacInfo() {
     // Start the dwarf macinfo section.
     Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection());
-    
+
     Asm->EOL();
   }
 
@@ -2637,7 +2637,7 @@
   /// header file.
   void ConstructCompileUnitDIEs() {
     const UniqueVector<CompileUnitDesc *> 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 @@
   void ConstructGlobalDIEs() {
     std::vector<GlobalVariableDesc *> GlobalVariables;
     MMI->getAnchoredDescriptors<GlobalVariableDesc>(*M, GlobalVariables);
-    
+
     for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) {
       GlobalVariableDesc *GVD = GlobalVariables[i];
       NewGlobalVariable(GVD);
@@ -2662,7 +2662,7 @@
   void ConstructSubprogramDIEs() {
     std::vector<SubprogramDesc *> Subprograms;
     MMI->getAnchoredDescriptors<SubprogramDesc>(*M, Subprograms);
-    
+
     for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) {
       SubprogramDesc *SPD = Subprograms[i];
       NewSubprogram(SPD);
@@ -2702,16 +2702,16 @@
     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 @@
   ///
   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 @@
 
     // 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 @@
       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<SourceLineInfo> &LineInfos = MMI->getSourceLines();
 
@@ -2838,7 +2838,7 @@
       SectionLineInfos.insert(SectionLineInfos.end(),
                               LineInfos.begin(), LineInfos.end());
     }
-    
+
     // Construct scopes for subprogram.
     ConstructRootScope(MMI->getRootScope());
 
@@ -2848,7 +2848,7 @@
 };
 
 //===----------------------------------------------------------------------===//
-/// DwarfException - Emits Dwarf exception handling directives. 
+/// DwarfException - Emits Dwarf exception handling directives.
 ///
 class DwarfException : public Dwarf  {
 
@@ -2884,7 +2884,7 @@
   /// 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 @@
     // 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 @@
     }
 
     // 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 @@
       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 @@
       // 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 @@
     for(std::vector<unsigned>::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 @@
           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 @@
           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 @@
                                              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 @@
   , shouldEmitTableModule(false)
   , shouldEmitMovesModule(false)
   {}
-  
+
   virtual ~DwarfException() {}
 
   /// SetModuleInfo - Set machine module information when it's known that pass
@@ -3514,7 +3515,7 @@
     }
   }
 
-  /// 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 @@
   // 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 @@
     << " "
     << ChildrenString(ChildrenFlag)
     << "\n";
-  
+
   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
     O << "  "
       << AttributeString(Data[i].getAttribute())
@@ -3655,8 +3656,8 @@
   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 @@
   if (Form == DW_FORM_data4) return 4;
   return DD.getTargetData()->getPointerSize();
 }
-    
+
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit delta value.
@@ -3718,7 +3719,7 @@
   if (Form == DW_FORM_data4) return 4;
   return DD.getTargetData()->getPointerSize();
 }
-    
+
 //===----------------------------------------------------------------------===//
 
 /// EmitValue - Emit delta value.
@@ -3742,7 +3743,7 @@
 void DIEntry::EmitValue(DwarfDebug &DD, unsigned Form) {
   DD.getAsm()->EmitInt32(Entry->getOffset());
 }
-    
+
 //===----------------------------------------------------------------------===//
 
 /// ComputeSize - calculate the size of the block.
@@ -3750,7 +3751,7 @@
 unsigned DIEBlock::ComputeSize(DwarfDebug &DD) {
   if (!Size) {
     const SmallVector<DIEAbbrevData, 8> &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 @@
   case DW_FORM_block:  DD.getAsm()->EmitULEB128Bytes(Size); break;
   default: assert(0 && "Improper form for block");          break;
   }
-  
+
   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
 
   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
@@ -3784,7 +3785,7 @@
   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 @@
   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::Profile(FoldingSetNodeID &ID) {
   Abbrev.Profile(ID);
-  
+
   for (unsigned i = 0, N = Children.size(); i < N; ++i)
     ID.AddPointer(Children[i]);
 
@@ -3824,15 +3825,15 @@
   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 @@
   O << "\n";
 
   const SmallVector<DIEAbbrevData, 8> &Data = Abbrev.getData();
-  
+
   IndentCount += 2;
   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
     O << Indent;
@@ -3864,7 +3865,7 @@
   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 @@
   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::EndFunction() {
   DD->EndFunction();
   DE->EndFunction();
-  
+
   if (MachineModuleInfo *MMI = DD->getMMI() ? DD->getMMI() : DE->getMMI())
     // Clear function debug information.
     MMI->EndFunction();