AsmPrinter: Remove the vtable-entry from DIEValue

Remove all virtual functions from `DIEValue`, dropping the vtable
pointer from its layout.  Instead, create "impl" functions on the
subclasses, and use the `DIEValue::Type` to implement the dynamic
dispatch.

This is necessary -- obviously not sufficient -- for passing `DIEValue`s
around by value.  However, this change stands on its own: we make tons
of these.  I measured a drop in memory usage from 888 MB down to 860 MB,
or around 3.2%.

(I'm looking at `llc` memory usage on `verify-uselistorder.lto.opt.bc`;
see r236629 for details.)

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@238084 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/CodeGen/DIE.h b/include/llvm/CodeGen/DIE.h
index c2d9457ebe15962ffaa4ad66481f745366fc1cd8..0f1a5294200f4201ae19e668bb21170f84d8b8d2 100644 (file)
--- a/include/llvm/CodeGen/DIE.h
+++ b/include/llvm/CodeGen/DIE.h
@@ -200,8 +200,6 @@ public:
 /// to DWARF attribute classes.
 ///
 class DIEValue {
-  virtual void anchor();
-
 public:
   enum Type {
     isInteger,
@@ -222,7 +220,7 @@ protected:
   Type Ty;
 
   explicit DIEValue(Type T) : Ty(T) {}
-  virtual ~DIEValue() {}
+  ~DIEValue() {}
 
 public:
   // Accessors
@@ -230,14 +228,14 @@ public:
 
   /// EmitValue - Emit value via the Dwarf writer.
   ///
-  virtual void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const = 0;
+  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 
   /// SizeOf - Return the size of a value in bytes.
   ///
-  virtual unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const = 0;
+  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
 #ifndef NDEBUG
-  virtual void print(raw_ostream &O) const = 0;
+  void print(raw_ostream &O) const;
   void dump() const;
 #endif
 };
@@ -246,6 +244,8 @@ public:
 /// DIEInteger - An integer value DIE.
 ///
 class DIEInteger : public DIEValue {
+  friend DIEValue;
+
   uint64_t Integer;
 
 public:
@@ -273,22 +273,18 @@ public:
     return dwarf::DW_FORM_data8;
   }
 
-  /// EmitValue - Emit integer of appropriate size.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   uint64_t getValue() const { return Integer; }
   void setValue(uint64_t Val) { Integer = Val; }
 
-  /// SizeOf - Determine size of integer value in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *I) { return I->getType() == isInteger; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -296,28 +292,26 @@ public:
 /// DIEExpr - An expression DIE.
 //
 class DIEExpr : public DIEValue {
+  friend class DIEValue;
+
   const MCExpr *Expr;
 
 public:
   explicit DIEExpr(const MCExpr *E) : DIEValue(isExpr), Expr(E) {}
 
-  /// EmitValue - Emit expression value.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   /// getValue - Get MCExpr.
   ///
   const MCExpr *getValue() const { return Expr; }
 
-  /// SizeOf - Determine size of expression value in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *E) { return E->getType() == isExpr; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -325,28 +319,26 @@ public:
 /// DIELabel - A label DIE.
 //
 class DIELabel : public DIEValue {
+  friend class DIEValue;
+
   const MCSymbol *Label;
 
 public:
   explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {}
 
-  /// EmitValue - Emit label value.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   /// getValue - Get MCSymbol.
   ///
   const MCSymbol *getValue() const { return Label; }
 
-  /// SizeOf - Determine size of label value in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *L) { return L->getType() == isLabel; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -354,6 +346,8 @@ public:
 /// DIEDelta - A simple label difference DIE.
 ///
 class DIEDelta : public DIEValue {
+  friend class DIEValue;
+
   const MCSymbol *LabelHi;
   const MCSymbol *LabelLo;
 
@@ -361,19 +355,15 @@ public:
   DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo)
       : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
 
-  /// EmitValue - Emit delta value.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
-  /// SizeOf - Determine size of delta value in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *D) { return D->getType() == isDelta; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -381,6 +371,8 @@ public:
 /// DIEString - A container for string values.
 ///
 class DIEString : public DIEValue {
+  friend class DIEValue;
+
   const DIEValue *Access;
   StringRef Str;
 
@@ -391,19 +383,15 @@ public:
   /// getString - Grab the string out of the object.
   StringRef getString() const { return Str; }
 
-  /// EmitValue - Emit delta value.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
-  /// SizeOf - Determine size of delta value in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *D) { return D->getType() == isString; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -412,6 +400,8 @@ public:
 /// this class can also be used as a proxy for a debug information entry not
 /// yet defined (ie. types.)
 class DIEEntry : public DIEValue {
+  friend class DIEValue;
+
   DIE &Entry;
 
 public:
@@ -420,52 +410,49 @@ public:
 
   DIE &getEntry() const { return Entry; }
 
-  /// EmitValue - Emit debug information entry offset.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
-  /// SizeOf - Determine size of debug information entry in bytes.
-  ///
-   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override {
-    return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP)
-                                           : sizeof(int32_t);
-  }
-
   /// Returns size of a ref_addr entry.
   static unsigned getRefAddrSize(const AsmPrinter *AP);
 
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *E) { return E->getType() == isEntry; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
+    return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP)
+                                           : sizeof(int32_t);
+  }
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
 //===--------------------------------------------------------------------===//
 /// \brief A signature reference to a type unit.
 class DIETypeSignature : public DIEValue {
+  friend class DIEValue;
+
   const DwarfTypeUnit &Unit;
 
 public:
   explicit DIETypeSignature(const DwarfTypeUnit &Unit)
       : DIEValue(isTypeSignature), Unit(Unit) {}
 
-  /// \brief Emit type unit signature.
-  void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const override;
+  // \brief Implement isa/cast/dyncast.
+  static bool classof(const DIEValue *E) {
+    return E->getType() == isTypeSignature;
+  }
 
-  /// Returns size of a ref_sig8 entry.
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override {
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
     assert(Form == dwarf::DW_FORM_ref_sig8);
     return 8;
   }
 
-  // \brief Implement isa/cast/dyncast.
-  static bool classof(const DIEValue *E) {
-    return E->getType() == isTypeSignature;
-  }
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -473,6 +460,8 @@ public:
 /// DIELoc - Represents an expression location.
 //
 class DIELoc : public DIEValue, public DIE {
+  friend class DIEValue;
+
   mutable unsigned Size; // Size in bytes excluding size header.
 public:
   DIELoc() : DIEValue(isLoc), Size(0) {}
@@ -496,19 +485,15 @@ public:
     return dwarf::DW_FORM_block;
   }
 
-  /// EmitValue - Emit location data.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
-  /// SizeOf - Determine size of location data in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *E) { return E->getType() == isLoc; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -516,6 +501,8 @@ public:
 /// DIEBlock - Represents a block of values.
 //
 class DIEBlock : public DIEValue, public DIE {
+  friend class DIEValue;
+
   mutable unsigned Size; // Size in bytes excluding size header.
 public:
   DIEBlock() : DIEValue(isBlock), Size(0) {}
@@ -536,19 +523,15 @@ public:
     return dwarf::DW_FORM_block;
   }
 
-  /// EmitValue - Emit location data.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
-  /// SizeOf - Determine size of location data in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *E) { return E->getType() == isBlock; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 
@@ -557,6 +540,8 @@ public:
 /// section.
 //
 class DIELocList : public DIEValue {
+  friend class DIEValue;
+
   // Index into the .debug_loc vector.
   size_t Index;
 
@@ -566,19 +551,15 @@ public:
   /// getValue - Grab the current index out.
   size_t getValue() const { return Index; }
 
-  /// EmitValue - Emit location data.
-  ///
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
-
-  /// SizeOf - Determine size of location data in bytes.
-  ///
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
-
   // Implement isa/cast/dyncast.
   static bool classof(const DIEValue *E) { return E->getType() == isLocList; }
 
+private:
+  void EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const;
+
 #ifndef NDEBUG
-  void print(raw_ostream &O) const override;
+  void printImpl(raw_ostream &O) const;
 #endif
 };
 

diff --git a/lib/CodeGen/AsmPrinter/DIE.cpp b/lib/CodeGen/AsmPrinter/DIE.cpp
index a614080b5c2d552bbe017d8863443ca4cadab7e0..dca85c73f00157af4bb1c8404f0c9f4e81bd340e 100644 (file)
--- a/lib/CodeGen/AsmPrinter/DIE.cpp
+++ b/lib/CodeGen/AsmPrinter/DIE.cpp
@@ -191,9 +191,66 @@ void DIE::dump() {
 }
 #endif
 
-void DIEValue::anchor() { }
+void DIEValue::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+  switch (Ty) {
+#define EMIT_VALUE_IMPL(Kind)                                                  \
+  case is##Kind:                                                               \
+    cast<DIE##Kind>(this)->EmitValueImpl(AP, Form);                            \
+    break;
+    EMIT_VALUE_IMPL(Integer)
+    EMIT_VALUE_IMPL(String)
+    EMIT_VALUE_IMPL(Expr)
+    EMIT_VALUE_IMPL(Label)
+    EMIT_VALUE_IMPL(Delta)
+    EMIT_VALUE_IMPL(Entry)
+    EMIT_VALUE_IMPL(TypeSignature)
+    EMIT_VALUE_IMPL(Block)
+    EMIT_VALUE_IMPL(Loc)
+    EMIT_VALUE_IMPL(LocList)
+#undef EMIT_VALUE_IMPL
+  }
+}
+
+unsigned DIEValue::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+  switch (Ty) {
+#define SIZE_OF_IMPL(Kind)                                                     \
+  case is##Kind:                                                               \
+    return cast<DIE##Kind>(this)->SizeOfImpl(AP, Form);
+    SIZE_OF_IMPL(Integer)
+    SIZE_OF_IMPL(String)
+    SIZE_OF_IMPL(Expr)
+    SIZE_OF_IMPL(Label)
+    SIZE_OF_IMPL(Delta)
+    SIZE_OF_IMPL(Entry)
+    SIZE_OF_IMPL(TypeSignature)
+    SIZE_OF_IMPL(Block)
+    SIZE_OF_IMPL(Loc)
+    SIZE_OF_IMPL(LocList)
+#undef SIZE_OF_IMPL
+  }
+}
 
 #ifndef NDEBUG
+void DIEValue::print(raw_ostream &O) const {
+  switch (Ty) {
+#define PRINT_IMPL(Kind)                                                       \
+  case is##Kind:                                                               \
+    cast<DIE##Kind>(this)->printImpl(O);                                       \
+    break;
+    PRINT_IMPL(Integer)
+    PRINT_IMPL(String)
+    PRINT_IMPL(Expr)
+    PRINT_IMPL(Label)
+    PRINT_IMPL(Delta)
+    PRINT_IMPL(Entry)
+    PRINT_IMPL(TypeSignature)
+    PRINT_IMPL(Block)
+    PRINT_IMPL(Loc)
+    PRINT_IMPL(LocList)
+#undef PRINT_IMPL
+  }
+}
+
 void DIEValue::dump() const {
   print(dbgs());
 }
@@ -205,7 +262,7 @@ void DIEValue::dump() const {
 
 /// EmitValue - Emit integer of appropriate size.
 ///
-void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
+void DIEInteger::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
   unsigned Size = ~0U;
   switch (Form) {
   case dwarf::DW_FORM_flag_present:
@@ -241,7 +298,7 @@ void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
 
 /// SizeOf - Determine size of integer value in bytes.
 ///
-unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEInteger::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_flag_present: return 0;
   case dwarf::DW_FORM_flag:  // Fall thru
@@ -270,7 +327,7 @@ unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 }
 
 #ifndef NDEBUG
-void DIEInteger::print(raw_ostream &O) const {
+void DIEInteger::printImpl(raw_ostream &O) const {
   O << "Int: " << (int64_t)Integer << "  0x";
   O.write_hex(Integer);
 }
@@ -282,13 +339,13 @@ void DIEInteger::print(raw_ostream &O) const {
 
 /// EmitValue - Emit expression value.
 ///
-void DIEExpr::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEExpr::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   AP->OutStreamer->EmitValue(Expr, SizeOf(AP, Form));
 }
 
 /// SizeOf - Determine size of expression value in bytes.
 ///
-unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEExpr::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_data4) return 4;
   if (Form == dwarf::DW_FORM_sec_offset) return 4;
   if (Form == dwarf::DW_FORM_strp) return 4;
@@ -296,7 +353,7 @@ unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 }
 
 #ifndef NDEBUG
-void DIEExpr::print(raw_ostream &O) const {
+void DIEExpr::printImpl(raw_ostream &O) const {
   O << "Expr: ";
   Expr->print(O);
 }
@@ -308,7 +365,7 @@ void DIEExpr::print(raw_ostream &O) const {
 
 /// EmitValue - Emit label value.
 ///
-void DIELabel::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIELabel::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   AP->EmitLabelReference(Label, SizeOf(AP, Form),
                          Form == dwarf::DW_FORM_strp ||
                              Form == dwarf::DW_FORM_sec_offset ||
@@ -317,7 +374,7 @@ void DIELabel::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 
 /// SizeOf - Determine size of label value in bytes.
 ///
-unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELabel::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_data4) return 4;
   if (Form == dwarf::DW_FORM_sec_offset) return 4;
   if (Form == dwarf::DW_FORM_strp) return 4;
@@ -325,7 +382,7 @@ unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 }
 
 #ifndef NDEBUG
-void DIELabel::print(raw_ostream &O) const {
+void DIELabel::printImpl(raw_ostream &O) const {
   O << "Lbl: " << Label->getName();
 }
 #endif
@@ -336,13 +393,13 @@ void DIELabel::print(raw_ostream &O) const {
 
 /// EmitValue - Emit delta value.
 ///
-void DIEDelta::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEDelta::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   AP->EmitLabelDifference(LabelHi, LabelLo, SizeOf(AP, Form));
 }
 
 /// SizeOf - Determine size of delta value in bytes.
 ///
-unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEDelta::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_data4) return 4;
   if (Form == dwarf::DW_FORM_sec_offset) return 4;
   if (Form == dwarf::DW_FORM_strp) return 4;
@@ -350,7 +407,7 @@ unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 }
 
 #ifndef NDEBUG
-void DIEDelta::print(raw_ostream &O) const {
+void DIEDelta::printImpl(raw_ostream &O) const {
   O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();
 }
 #endif
@@ -361,18 +418,18 @@ void DIEDelta::print(raw_ostream &O) const {
 
 /// EmitValue - Emit string value.
 ///
-void DIEString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEString::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   Access->EmitValue(AP, Form);
 }
 
 /// SizeOf - Determine size of delta value in bytes.
 ///
-unsigned DIEString::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEString::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   return Access->SizeOf(AP, Form);
 }
 
 #ifndef NDEBUG
-void DIEString::print(raw_ostream &O) const {
+void DIEString::printImpl(raw_ostream &O) const {
   O << "String: " << Str << "\tSymbol: ";
   Access->print(O);
 }
@@ -384,7 +441,7 @@ void DIEString::print(raw_ostream &O) const {
 
 /// EmitValue - Emit debug information entry offset.
 ///
-void DIEEntry::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIEEntry::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
 
   if (Form == dwarf::DW_FORM_ref_addr) {
     const DwarfDebug *DD = AP->getDwarfDebug();
@@ -418,7 +475,7 @@ unsigned DIEEntry::getRefAddrSize(const AsmPrinter *AP) {
 }
 
 #ifndef NDEBUG
-void DIEEntry::print(raw_ostream &O) const {
+void DIEEntry::printImpl(raw_ostream &O) const {
   O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
 }
 #endif
@@ -426,13 +483,13 @@ void DIEEntry::print(raw_ostream &O) const {
 //===----------------------------------------------------------------------===//
 // DIETypeSignature Implementation
 //===----------------------------------------------------------------------===//
-void DIETypeSignature::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
+void DIETypeSignature::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
   assert(Form == dwarf::DW_FORM_ref_sig8);
   Asm->OutStreamer->EmitIntValue(Unit.getTypeSignature(), 8);
 }
 
 #ifndef NDEBUG
-void DIETypeSignature::print(raw_ostream &O) const {
+void DIETypeSignature::printImpl(raw_ostream &O) const {
   O << format("Type Unit: 0x%lx", Unit.getTypeSignature());
 }
 #endif
@@ -455,7 +512,7 @@ unsigned DIELoc::ComputeSize(const AsmPrinter *AP) const {
 
 /// EmitValue - Emit location data.
 ///
-void DIELoc::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
+void DIELoc::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
   switch (Form) {
   default: llvm_unreachable("Improper form for block");
   case dwarf::DW_FORM_block1: Asm->EmitInt8(Size);    break;
@@ -473,7 +530,7 @@ void DIELoc::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
 
 /// SizeOf - Determine size of location data in bytes.
 ///
-unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELoc::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
@@ -486,7 +543,7 @@ unsigned DIELoc::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 }
 
 #ifndef NDEBUG
-void DIELoc::print(raw_ostream &O) const {
+void DIELoc::printImpl(raw_ostream &O) const {
   O << "ExprLoc: ";
   DIE::print(O, 5);
 }
@@ -510,7 +567,7 @@ unsigned DIEBlock::ComputeSize(const AsmPrinter *AP) const {
 
 /// EmitValue - Emit block data.
 ///
-void DIEBlock::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
+void DIEBlock::EmitValueImpl(const AsmPrinter *Asm, dwarf::Form Form) const {
   switch (Form) {
   default: llvm_unreachable("Improper form for block");
   case dwarf::DW_FORM_block1: Asm->EmitInt8(Size);    break;
@@ -526,7 +583,7 @@ void DIEBlock::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
 
 /// SizeOf - Determine size of block data in bytes.
 ///
-unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIEBlock::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   switch (Form) {
   case dwarf::DW_FORM_block1: return Size + sizeof(int8_t);
   case dwarf::DW_FORM_block2: return Size + sizeof(int16_t);
@@ -537,7 +594,7 @@ unsigned DIEBlock::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 }
 
 #ifndef NDEBUG
-void DIEBlock::print(raw_ostream &O) const {
+void DIEBlock::printImpl(raw_ostream &O) const {
   O << "Blk: ";
   DIE::print(O, 5);
 }
@@ -547,7 +604,7 @@ void DIEBlock::print(raw_ostream &O) const {
 // DIELocList Implementation
 //===----------------------------------------------------------------------===//
 
-unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
+unsigned DIELocList::SizeOfImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_data4)
     return 4;
   if (Form == dwarf::DW_FORM_sec_offset)
@@ -557,7 +614,7 @@ unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 
 /// EmitValue - Emit label value.
 ///
-void DIELocList::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+void DIELocList::EmitValueImpl(const AsmPrinter *AP, dwarf::Form Form) const {
   DwarfDebug *DD = AP->getDwarfDebug();
   MCSymbol *Label = DD->getDebugLocs().getList(Index).Label;
 
@@ -568,7 +625,7 @@ void DIELocList::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 }
 
 #ifndef NDEBUG
-void DIELocList::print(raw_ostream &O) const {
+void DIELocList::printImpl(raw_ostream &O) const {
   O << "LocList: " << Index;
 
 }