Index: include/llvm/DebugInfo/DWARF/DWARFDie.h
===================================================================
--- include/llvm/DebugInfo/DWARF/DWARFDie.h
+++ include/llvm/DebugInfo/DWARF/DWARFDie.h
@@ -119,7 +119,7 @@
 
 
   /// Convenience zero-argument overload for debugging.
-  LLVM_DUMP_METHOD void dump() const;
+  void dump() const;
 
   /// Extract the specified attribute from this DIE.
   ///
Index: include/llvm/Object/Wasm.h
===================================================================
--- include/llvm/Object/Wasm.h
+++ include/llvm/Object/Wasm.h
@@ -105,7 +105,7 @@
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+  void dump() const { print(dbgs()); }
 #endif
 };
 
Index: include/llvm/Support/Compiler.h
===================================================================
--- include/llvm/Support/Compiler.h
+++ include/llvm/Support/Compiler.h
@@ -439,18 +439,6 @@
 #define LLVM_NO_SANITIZE(KIND)
 #endif
 
-/// \brief Mark debug helper function definitions like dump() that should not be
-/// stripped from debug builds.
-/// Note that you should also surround dump() functions with
-/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
-/// get stripped in release builds.
-// FIXME: Move this to a private config.h as it's not usable in public headers.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-#else
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
-#endif
-
 /// \macro LLVM_PRETTY_FUNCTION
 /// \brief Gets a user-friendly looking function signature for the current scope
 /// using the best available method on each platform.  The exact format of the
Index: include/llvm/Support/DebugCounter.h
===================================================================
--- include/llvm/Support/DebugCounter.h
+++ include/llvm/Support/DebugCounter.h
@@ -122,7 +122,7 @@
   }
 
   // Dump or print the current counter set into llvm::dbgs().
-  LLVM_DUMP_METHOD void dump() const;
+  void dump() const;
 
   void print(raw_ostream &OS) const;
 
Index: include/llvm/Transforms/Scalar/GVNExpression.h
===================================================================
--- include/llvm/Transforms/Scalar/GVNExpression.h
+++ include/llvm/Transforms/Scalar/GVNExpression.h
@@ -126,7 +126,7 @@
     OS << "}";
   }
 
-  LLVM_DUMP_METHOD void dump() const;
+  void dump() const;
 };
 
 inline raw_ostream &operator<<(raw_ostream &OS, const Expression &E) {
Index: lib/Analysis/AliasSetTracker.cpp
===================================================================
--- lib/Analysis/AliasSetTracker.cpp
+++ lib/Analysis/AliasSetTracker.cpp
@@ -649,8 +649,8 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void AliasSet::dump() const { print(dbgs()); }
-LLVM_DUMP_METHOD void AliasSetTracker::dump() const { print(dbgs()); }
+void AliasSet::dump() const { print(dbgs()); }
+void AliasSetTracker::dump() const { print(dbgs()); }
 #endif
 
 //===----------------------------------------------------------------------===//
Index: lib/Analysis/BlockFrequencyInfoImpl.cpp
===================================================================
--- lib/Analysis/BlockFrequencyInfoImpl.cpp
+++ lib/Analysis/BlockFrequencyInfoImpl.cpp
@@ -47,7 +47,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void BlockMass::dump() const { print(dbgs()); }
+void BlockMass::dump() const { print(dbgs()); }
 #endif
 
 static char getHexDigit(int N) {
Index: lib/Analysis/CallGraph.cpp
===================================================================
--- lib/Analysis/CallGraph.cpp
+++ lib/Analysis/CallGraph.cpp
@@ -110,7 +110,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void CallGraph::dump() const { print(dbgs()); }
+void CallGraph::dump() const { print(dbgs()); }
 #endif
 
 // removeFunctionFromModule - Unlink the function from this module, returning
@@ -179,7 +179,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void CallGraphNode::dump() const { print(dbgs()); }
+void CallGraphNode::dump() const { print(dbgs()); }
 #endif
 
 /// removeCallEdgeFor - This method removes the edge in the node for the
@@ -293,7 +293,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 void CallGraphWrapperPass::dump() const { print(dbgs(), nullptr); }
 #endif
 
Index: lib/Analysis/DependenceAnalysis.cpp
===================================================================
--- lib/Analysis/DependenceAnalysis.cpp
+++ lib/Analysis/DependenceAnalysis.cpp
@@ -387,7 +387,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // For debugging purposes. Dumps the constraint out to OS.
-LLVM_DUMP_METHOD void DependenceInfo::Constraint::dump(raw_ostream &OS) const {
+void DependenceInfo::Constraint::dump(raw_ostream &OS) const {
   if (isEmpty())
     OS << " Empty\n";
   else if (isAny())
Index: lib/Analysis/DominanceFrontier.cpp
===================================================================
--- lib/Analysis/DominanceFrontier.cpp
+++ lib/Analysis/DominanceFrontier.cpp
@@ -60,7 +60,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const {
+void DominanceFrontierWrapperPass::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/Analysis/IVUsers.cpp
===================================================================
--- lib/Analysis/IVUsers.cpp
+++ lib/Analysis/IVUsers.cpp
@@ -341,7 +341,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void IVUsers::dump() const { print(dbgs()); }
+void IVUsers::dump() const { print(dbgs()); }
 #endif
 
 void IVUsers::releaseMemory() {
Index: lib/Analysis/InlineCost.cpp
===================================================================
--- lib/Analysis/InlineCost.cpp
+++ lib/Analysis/InlineCost.cpp
@@ -1868,7 +1868,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// \brief Dump stats about this call's analysis.
-LLVM_DUMP_METHOD void CallAnalyzer::dump() {
+void CallAnalyzer::dump() {
 #define DEBUG_PRINT_STAT(x) dbgs() << "      " #x ": " << x << "\n"
   DEBUG_PRINT_STAT(NumConstantArgs);
   DEBUG_PRINT_STAT(NumConstantOffsetPtrArgs);
Index: lib/Analysis/LazyCallGraph.cpp
===================================================================
--- lib/Analysis/LazyCallGraph.cpp
+++ lib/Analysis/LazyCallGraph.cpp
@@ -138,7 +138,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LazyCallGraph::Node::dump() const {
+void LazyCallGraph::Node::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
@@ -208,7 +208,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LazyCallGraph::SCC::dump() const {
+void LazyCallGraph::SCC::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
@@ -282,7 +282,7 @@
 LazyCallGraph::RefSCC::RefSCC(LazyCallGraph &G) : G(&G) {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LazyCallGraph::RefSCC::dump() const {
+void LazyCallGraph::RefSCC::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
Index: lib/Analysis/LoopInfo.cpp
===================================================================
--- lib/Analysis/LoopInfo.cpp
+++ lib/Analysis/LoopInfo.cpp
@@ -441,9 +441,9 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void Loop::dump() const { print(dbgs()); }
+void Loop::dump() const { print(dbgs()); }
 
-LLVM_DUMP_METHOD void Loop::dumpVerbose() const {
+void Loop::dumpVerbose() const {
   print(dbgs(), /*Depth=*/0, /*Verbose=*/true);
 }
 #endif
Index: lib/Analysis/MemorySSA.cpp
===================================================================
--- lib/Analysis/MemorySSA.cpp
+++ lib/Analysis/MemorySSA.cpp
@@ -1603,7 +1603,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MemorySSA::dump() const { print(dbgs()); }
+void MemorySSA::dump() const { print(dbgs()); }
 #endif
 
 void MemorySSA::verifyMemorySSA() const {
Index: lib/Analysis/PHITransAddr.cpp
===================================================================
--- lib/Analysis/PHITransAddr.cpp
+++ lib/Analysis/PHITransAddr.cpp
@@ -42,7 +42,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void PHITransAddr::dump() const {
+void PHITransAddr::dump() const {
   if (!Addr) {
     dbgs() << "PHITransAddr: null\n";
     return;
Index: lib/Analysis/RegionInfo.cpp
===================================================================
--- lib/Analysis/RegionInfo.cpp
+++ lib/Analysis/RegionInfo.cpp
@@ -153,7 +153,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegionInfoPass::dump() const {
+void RegionInfoPass::dump() const {
   RI.dump();
 }
 #endif
Index: lib/Analysis/ScalarEvolution.cpp
===================================================================
--- lib/Analysis/ScalarEvolution.cpp
+++ lib/Analysis/ScalarEvolution.cpp
@@ -219,7 +219,7 @@
 //
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SCEV::dump() const {
+void SCEV::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
Index: lib/Analysis/Trace.cpp
===================================================================
--- lib/Analysis/Trace.cpp
+++ lib/Analysis/Trace.cpp
@@ -47,7 +47,7 @@
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// dump - Debugger convenience method; writes trace to standard error
 /// output stream.
-LLVM_DUMP_METHOD void Trace::dump() const {
+void Trace::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/Bitcode/Writer/ValueEnumerator.cpp
===================================================================
--- lib/Bitcode/Writer/ValueEnumerator.cpp
+++ lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -466,7 +466,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ValueEnumerator::dump() const {
+void ValueEnumerator::dump() const {
   print(dbgs(), ValueMap, "Default");
   dbgs() << '\n';
   print(dbgs(), MetadataMap, "MetaData");
Index: lib/CodeGen/AsmPrinter/DIE.cpp
===================================================================
--- lib/CodeGen/AsmPrinter/DIE.cpp
+++ lib/CodeGen/AsmPrinter/DIE.cpp
@@ -104,7 +104,6 @@
   AP->EmitULEB128(0, "EOM(2)");
 }
 
-LLVM_DUMP_METHOD
 void DIEAbbrev::print(raw_ostream &O) const {
   O << "Abbreviation @"
     << format("0x%lx", (long)(intptr_t)this)
@@ -128,7 +127,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DIEAbbrev::dump() const {
+void DIEAbbrev::dump() const {
   print(dbgs());
 }
 #endif
@@ -226,7 +225,6 @@
   return DIEValue();
 }
 
-LLVM_DUMP_METHOD
 static void printValues(raw_ostream &O, const DIEValueList &Values,
                         StringRef Type, unsigned Size, unsigned IndentCount) {
   O << Type << ": Size: " << Size << "\n";
@@ -242,7 +240,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void DIE::print(raw_ostream &O, unsigned IndentCount) const {
   const std::string Indent(IndentCount, ' ');
   O << Indent << "Die: " << format("0x%lx", (long)(intptr_t) this)
@@ -268,7 +265,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DIE::dump() const {
+void DIE::dump() const {
   print(dbgs());
 }
 #endif
@@ -346,7 +343,6 @@
   llvm_unreachable("Unknown DIE kind");
 }
 
-LLVM_DUMP_METHOD
 void DIEValue::print(raw_ostream &O) const {
   switch (Ty) {
   case isNone:
@@ -360,7 +356,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DIEValue::dump() const {
+void DIEValue::dump() const {
   print(dbgs());
 }
 #endif
@@ -479,7 +475,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void DIEInteger::print(raw_ostream &O) const {
   O << "Int: " << (int64_t)Integer << "  0x";
   O.write_hex(Integer);
@@ -504,7 +499,6 @@
   return AP->getPointerSize();
 }
 
-LLVM_DUMP_METHOD
 void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
 
 //===----------------------------------------------------------------------===//
@@ -530,7 +524,6 @@
   return AP->MAI->getCodePointerSize();
 }
 
-LLVM_DUMP_METHOD
 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
 
 //===----------------------------------------------------------------------===//
@@ -552,7 +545,6 @@
   return AP->MAI->getCodePointerSize();
 }
 
-LLVM_DUMP_METHOD
 void DIEDelta::print(raw_ostream &O) const {
   O << "Del: " << LabelHi->getName() << "-" << LabelLo->getName();
 }
@@ -604,7 +596,6 @@
   return DIEInteger(S.getOffset()).SizeOf(AP, Form);
 }
 
-LLVM_DUMP_METHOD
 void DIEString::print(raw_ostream &O) const {
   O << "String: " << S.getString();
 }
@@ -627,7 +618,6 @@
   return S.size() + 1;
 }
 
-LLVM_DUMP_METHOD
 void DIEInlineString::print(raw_ostream &O) const {
   O << "InlineString: " << S;
 }
@@ -697,7 +687,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void DIEEntry::print(raw_ostream &O) const {
   O << format("Die: 0x%lx", (long)(intptr_t)&Entry);
 }
@@ -748,7 +737,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void DIELoc::print(raw_ostream &O) const {
   printValues(O, *this, "ExprLoc", Size, 5);
 }
@@ -797,7 +785,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void DIEBlock::print(raw_ostream &O) const {
   printValues(O, *this, "Blk", Size, 5);
 }
@@ -822,5 +809,4 @@
   AP->emitDwarfSymbolReference(Label, /*ForceOffset*/ DD->useSplitDwarf());
 }
 
-LLVM_DUMP_METHOD
 void DIELocList::print(raw_ostream &O) const { O << "LocList: " << Index; }
Index: lib/CodeGen/AsmPrinter/DebugLocEntry.h
===================================================================
--- lib/CodeGen/AsmPrinter/DebugLocEntry.h
+++ lib/CodeGen/AsmPrinter/DebugLocEntry.h
@@ -77,7 +77,7 @@
     friend bool operator==(const Value &, const Value &);
     friend bool operator<(const Value &, const Value &);
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-    LLVM_DUMP_METHOD void dump() const {
+    void dump() const {
       if (isLocation()) {
         llvm::dbgs() << "Loc = { reg=" << Loc.getReg() << " ";
         if (Loc.isIndirect())
Index: lib/CodeGen/BranchRelaxation.cpp
===================================================================
--- lib/CodeGen/BranchRelaxation.cpp
+++ lib/CodeGen/BranchRelaxation.cpp
@@ -140,7 +140,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// print block size and offset information - debugging
-LLVM_DUMP_METHOD void BranchRelaxation::dumpBBs() {
+void BranchRelaxation::dumpBBs() {
   for (auto &MBB : *MF) {
     const BasicBlockInfo &BBI = BlockInfo[MBB.getNumber()];
     dbgs() << format("%bb.%u\toffset=%08x\t", MBB.getNumber(), BBI.Offset)
Index: lib/CodeGen/CodeGenPrepare.cpp
===================================================================
--- lib/CodeGen/CodeGenPrepare.cpp
+++ lib/CodeGen/CodeGenPrepare.cpp
@@ -2010,7 +2010,7 @@
   OS << ']';
 }
 
-LLVM_DUMP_METHOD void ExtAddrMode::dump() const {
+void ExtAddrMode::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
Index: lib/CodeGen/GlobalISel/RegBankSelect.cpp
===================================================================
--- lib/CodeGen/GlobalISel/RegBankSelect.cpp
+++ lib/CodeGen/GlobalISel/RegBankSelect.cpp
@@ -987,7 +987,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegBankSelect::MappingCost::dump() const {
+void RegBankSelect::MappingCost::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
Index: lib/CodeGen/GlobalISel/RegisterBank.cpp
===================================================================
--- lib/CodeGen/GlobalISel/RegisterBank.cpp
+++ lib/CodeGen/GlobalISel/RegisterBank.cpp
@@ -77,7 +77,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegisterBank::dump(const TargetRegisterInfo *TRI) const {
+void RegisterBank::dump(const TargetRegisterInfo *TRI) const {
   print(dbgs(), /* IsForDebug */ true, TRI);
 }
 #endif
Index: lib/CodeGen/GlobalISel/RegisterBankInfo.cpp
===================================================================
--- lib/CodeGen/GlobalISel/RegisterBankInfo.cpp
+++ lib/CodeGen/GlobalISel/RegisterBankInfo.cpp
@@ -482,7 +482,7 @@
 // Helper classes implementation.
 //------------------------------------------------------------------------------
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegisterBankInfo::PartialMapping::dump() const {
+void RegisterBankInfo::PartialMapping::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
@@ -535,7 +535,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegisterBankInfo::ValueMapping::dump() const {
+void RegisterBankInfo::ValueMapping::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
@@ -589,7 +589,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegisterBankInfo::InstructionMapping::dump() const {
+void RegisterBankInfo::InstructionMapping::dump() const {
   print(dbgs());
   dbgs() << '\n';
 }
@@ -712,7 +712,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegisterBankInfo::OperandsMapper::dump() const {
+void RegisterBankInfo::OperandsMapper::dump() const {
   print(dbgs(), true);
   dbgs() << '\n';
 }
Index: lib/CodeGen/InlineSpiller.cpp
===================================================================
--- lib/CodeGen/InlineSpiller.cpp
+++ lib/CodeGen/InlineSpiller.cpp
@@ -707,7 +707,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 // Dump the range of instructions from B to E with their slot indexes.
 static void dumpMachineInstrRangeWithSlotIndex(MachineBasicBlock::iterator B,
                                                MachineBasicBlock::iterator E,
Index: lib/CodeGen/LexicalScopes.cpp
===================================================================
--- lib/CodeGen/LexicalScopes.cpp
+++ lib/CodeGen/LexicalScopes.cpp
@@ -318,7 +318,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LexicalScope::dump(unsigned Indent) const {
+void LexicalScope::dump(unsigned Indent) const {
   raw_ostream &err = dbgs();
   err.indent(Indent);
   err << "DFSIn: " << DFSIn << " DFSOut: " << DFSOut << "\n";
Index: lib/CodeGen/LiveDebugValues.cpp
===================================================================
--- lib/CodeGen/LiveDebugValues.cpp
+++ lib/CodeGen/LiveDebugValues.cpp
@@ -160,7 +160,7 @@
     bool dominates(MachineBasicBlock &MBB) const { return UVS.dominates(&MBB); }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-    LLVM_DUMP_METHOD void dump() const { MI.dump(); }
+    void dump() const { MI.dump(); }
 #endif
 
     bool operator==(const VarLoc &Other) const {
Index: lib/CodeGen/LiveDebugVariables.cpp
===================================================================
--- lib/CodeGen/LiveDebugVariables.cpp
+++ lib/CodeGen/LiveDebugVariables.cpp
@@ -1222,7 +1222,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LiveDebugVariables::dump() const {
+void LiveDebugVariables::dump() const {
   if (pImpl)
     static_cast<LDVImpl*>(pImpl)->print(dbgs());
 }
Index: lib/CodeGen/LiveInterval.cpp
===================================================================
--- lib/CodeGen/LiveInterval.cpp
+++ lib/CodeGen/LiveInterval.cpp
@@ -945,7 +945,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LiveRange::Segment::dump() const {
+void LiveRange::Segment::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
@@ -994,15 +994,15 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LiveRange::dump() const {
+void LiveRange::dump() const {
   dbgs() << *this << '\n';
 }
 
-LLVM_DUMP_METHOD void LiveInterval::SubRange::dump() const {
+void LiveInterval::SubRange::dump() const {
   dbgs() << *this << '\n';
 }
 
-LLVM_DUMP_METHOD void LiveInterval::dump() const {
+void LiveInterval::dump() const {
   dbgs() << *this << '\n';
 }
 #endif
@@ -1101,7 +1101,7 @@
   OS << '\n';
 }
 
-LLVM_DUMP_METHOD void LiveRangeUpdater::dump() const {
+void LiveRangeUpdater::dump() const {
   print(errs());
 }
 #endif
Index: lib/CodeGen/LiveIntervals.cpp
===================================================================
--- lib/CodeGen/LiveIntervals.cpp
+++ lib/CodeGen/LiveIntervals.cpp
@@ -180,7 +180,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LiveIntervals::dumpInstrs() const {
+void LiveIntervals::dumpInstrs() const {
   printInstrs(dbgs());
 }
 #endif
Index: lib/CodeGen/LivePhysRegs.cpp
===================================================================
--- lib/CodeGen/LivePhysRegs.cpp
+++ lib/CodeGen/LivePhysRegs.cpp
@@ -131,7 +131,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LivePhysRegs::dump() const {
+void LivePhysRegs::dump() const {
   dbgs() << "  " << *this;
 }
 #endif
Index: lib/CodeGen/LiveVariables.cpp
===================================================================
--- lib/CodeGen/LiveVariables.cpp
+++ lib/CodeGen/LiveVariables.cpp
@@ -64,7 +64,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LiveVariables::VarInfo::dump() const {
+void LiveVariables::VarInfo::dump() const {
   dbgs() << "  Alive in blocks: ";
   for (SparseBitVector<>::iterator I = AliveBlocks.begin(),
            E = AliveBlocks.end(); I != E; ++I)
Index: lib/CodeGen/MachineBasicBlock.cpp
===================================================================
--- lib/CodeGen/MachineBasicBlock.cpp
+++ lib/CodeGen/MachineBasicBlock.cpp
@@ -229,7 +229,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineBasicBlock::dump() const {
+void MachineBasicBlock::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/CodeGen/MachineBlockPlacement.cpp
===================================================================
--- lib/CodeGen/MachineBlockPlacement.cpp
+++ lib/CodeGen/MachineBlockPlacement.cpp
@@ -294,7 +294,7 @@
 
 #ifndef NDEBUG
   /// \brief Dump the blocks in this chain.
-  LLVM_DUMP_METHOD void dump() {
+  void dump() {
     for (MachineBasicBlock *MBB : *this)
       MBB->dump();
   }
Index: lib/CodeGen/MachineFrameInfo.cpp
===================================================================
--- lib/CodeGen/MachineFrameInfo.cpp
+++ lib/CodeGen/MachineFrameInfo.cpp
@@ -245,7 +245,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineFrameInfo::dump(const MachineFunction &MF) const {
+void MachineFrameInfo::dump(const MachineFunction &MF) const {
   print(MF, dbgs());
 }
 #endif
Index: lib/CodeGen/MachineFunction.cpp
===================================================================
--- lib/CodeGen/MachineFunction.cpp
+++ lib/CodeGen/MachineFunction.cpp
@@ -479,7 +479,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineFunction::dump() const {
+void MachineFunction::dump() const {
   print(dbgs());
 }
 #endif
@@ -914,7 +914,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineJumpTableInfo::dump() const { print(dbgs()); }
+void MachineJumpTableInfo::dump() const { print(dbgs()); }
 #endif
 
 Printable llvm::printJumpTableEntryReference(unsigned Idx) {
@@ -1073,5 +1073,5 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineConstantPool::dump() const { print(dbgs()); }
+void MachineConstantPool::dump() const { print(dbgs()); }
 #endif
Index: lib/CodeGen/MachineInstr.cpp
===================================================================
--- lib/CodeGen/MachineInstr.cpp
+++ lib/CodeGen/MachineInstr.cpp
@@ -1200,7 +1200,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineInstr::dump() const {
+void MachineInstr::dump() const {
   dbgs() << "  ";
   print(dbgs());
 }
Index: lib/CodeGen/MachineLoopInfo.cpp
===================================================================
--- lib/CodeGen/MachineLoopInfo.cpp
+++ lib/CodeGen/MachineLoopInfo.cpp
@@ -139,7 +139,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineLoop::dump() const {
+void MachineLoop::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/CodeGen/MachineOperand.cpp
===================================================================
--- lib/CodeGen/MachineOperand.cpp
+++ lib/CodeGen/MachineOperand.cpp
@@ -848,7 +848,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineOperand::dump() const { dbgs() << *this << '\n'; }
+void MachineOperand::dump() const { dbgs() << *this << '\n'; }
 #endif
 
 //===----------------------------------------------------------------------===//
Index: lib/CodeGen/MachinePipeliner.cpp
===================================================================
--- lib/CodeGen/MachinePipeliner.cpp
+++ lib/CodeGen/MachinePipeliner.cpp
@@ -559,7 +559,7 @@
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+  void dump() const { print(dbgs()); }
 #endif
 };
 
@@ -4027,5 +4027,5 @@
 }
 
 /// Utility function used for debugging to print the schedule.
-LLVM_DUMP_METHOD void SMSchedule::dump() const { print(dbgs()); }
+void SMSchedule::dump() const { print(dbgs()); }
 #endif
Index: lib/CodeGen/MachineRegionInfo.cpp
===================================================================
--- lib/CodeGen/MachineRegionInfo.cpp
+++ lib/CodeGen/MachineRegionInfo.cpp
@@ -119,7 +119,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineRegionInfoPass::dump() const {
+void MachineRegionInfoPass::dump() const {
   RI.dump();
 }
 #endif
Index: lib/CodeGen/MachineRegisterInfo.cpp
===================================================================
--- lib/CodeGen/MachineRegisterInfo.cpp
+++ lib/CodeGen/MachineRegisterInfo.cpp
@@ -459,7 +459,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MachineRegisterInfo::dumpUses(unsigned Reg) const {
+void MachineRegisterInfo::dumpUses(unsigned Reg) const {
   for (MachineInstr &I : use_instructions(Reg))
     I.dump();
 }
Index: lib/CodeGen/MachineScheduler.cpp
===================================================================
--- lib/CodeGen/MachineScheduler.cpp
+++ lib/CodeGen/MachineScheduler.cpp
@@ -581,7 +581,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ReadyQueue::dump() const {
+void ReadyQueue::dump() const {
   dbgs() << "Queue " << Name << ": ";
   for (const SUnit *SU : Queue)
     dbgs() << SU->NodeNum << " ";
@@ -919,7 +919,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ScheduleDAGMI::dumpSchedule() const {
+void ScheduleDAGMI::dumpSchedule() const {
   for (MachineBasicBlock::iterator MI = begin(), ME = end(); MI != ME; ++MI) {
     if (SUnit *SU = getSUnit(&(*MI)))
       SU->dump(this);
@@ -2365,7 +2365,7 @@
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // This is useful information to dump after bumpNode.
 // Note that the Queue contents are more useful before pickNodeFromQueue.
-LLVM_DUMP_METHOD void SchedBoundary::dumpScheduledState() const {
+void SchedBoundary::dumpScheduledState() const {
   unsigned ResFactor;
   unsigned ResCount;
   if (ZoneCritResIdx) {
Index: lib/CodeGen/PostRASchedulerList.cpp
===================================================================
--- lib/CodeGen/PostRASchedulerList.cpp
+++ lib/CodeGen/PostRASchedulerList.cpp
@@ -252,7 +252,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// dumpSchedule - dump the scheduled Sequence.
-LLVM_DUMP_METHOD void SchedulePostRATDList::dumpSchedule() const {
+void SchedulePostRATDList::dumpSchedule() const {
   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
     if (SUnit *SU = Sequence[i])
       SU->dump(this);
Index: lib/CodeGen/RegAllocPBQP.cpp
===================================================================
--- lib/CodeGen/RegAllocPBQP.cpp
+++ lib/CodeGen/RegAllocPBQP.cpp
@@ -869,7 +869,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void PBQP::RegAlloc::PBQPRAGraph::dump(raw_ostream &OS) const {
+void PBQP::RegAlloc::PBQPRAGraph::dump(raw_ostream &OS) const {
   for (auto NId : nodeIds()) {
     const Vector &Costs = getNodeCosts(NId);
     assert(Costs.getLength() != 0 && "Empty vector in graph.");
@@ -890,7 +890,7 @@
   }
 }
 
-LLVM_DUMP_METHOD void PBQP::RegAlloc::PBQPRAGraph::dump() const {
+void PBQP::RegAlloc::PBQPRAGraph::dump() const {
   dump(dbgs());
 }
 #endif
Index: lib/CodeGen/RegisterPressure.cpp
===================================================================
--- lib/CodeGen/RegisterPressure.cpp
+++ lib/CodeGen/RegisterPressure.cpp
@@ -77,7 +77,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 void llvm::dumpRegSetPressure(ArrayRef<unsigned> SetPressure,
                               const TargetRegisterInfo *TRI) {
   bool Empty = true;
@@ -91,7 +90,6 @@
     dbgs() << "\n";
 }
 
-LLVM_DUMP_METHOD
 void RegisterPressure::dump(const TargetRegisterInfo *TRI) const {
   dbgs() << "Max Pressure: ";
   dumpRegSetPressure(MaxSetPressure, TRI);
@@ -113,7 +111,6 @@
   dbgs() << '\n';
 }
 
-LLVM_DUMP_METHOD
 void RegPressureTracker::dump() const {
   if (!isTopClosed() || !isBottomClosed()) {
     dbgs() << "Curr Pressure: ";
@@ -122,7 +119,6 @@
   P.dump(TRI);
 }
 
-LLVM_DUMP_METHOD
 void PressureDiff::dump(const TargetRegisterInfo &TRI) const {
   const char *sep = "";
   for (const PressureChange &Change : *this) {
Index: lib/CodeGen/SafeStackColoring.cpp
===================================================================
--- lib/CodeGen/SafeStackColoring.cpp
+++ lib/CodeGen/SafeStackColoring.cpp
@@ -251,13 +251,13 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void StackColoring::dumpAllocas() {
+void StackColoring::dumpAllocas() {
   dbgs() << "Allocas:\n";
   for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo)
     dbgs() << "  " << AllocaNo << ": " << *Allocas[AllocaNo] << "\n";
 }
 
-LLVM_DUMP_METHOD void StackColoring::dumpBlockLiveness() {
+void StackColoring::dumpBlockLiveness() {
   dbgs() << "Block liveness:\n";
   for (auto IT : BlockLiveness) {
     BasicBlock *BB = IT.getFirst();
@@ -270,7 +270,7 @@
   }
 }
 
-LLVM_DUMP_METHOD void StackColoring::dumpLiveRanges() {
+void StackColoring::dumpLiveRanges() {
   dbgs() << "Alloca liveness:\n";
   for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo) {
     LiveRange &Range = LiveRanges[AllocaNo];
Index: lib/CodeGen/SafeStackLayout.cpp
===================================================================
--- lib/CodeGen/SafeStackLayout.cpp
+++ lib/CodeGen/SafeStackLayout.cpp
@@ -27,7 +27,7 @@
                               cl::desc("enable safe stack layout"), cl::Hidden,
                               cl::init(true));
 
-LLVM_DUMP_METHOD void StackLayout::print(raw_ostream &OS) {
+void StackLayout::print(raw_ostream &OS) {
   OS << "Stack regions:\n";
   for (unsigned i = 0; i < Regions.size(); ++i) {
     OS << "  " << i << ": [" << Regions[i].Start << ", " << Regions[i].End
Index: lib/CodeGen/ScheduleDAG.cpp
===================================================================
--- lib/CodeGen/ScheduleDAG.cpp
+++ lib/CodeGen/ScheduleDAG.cpp
@@ -67,7 +67,6 @@
   return &TII->get(Node->getMachineOpcode());
 }
 
-LLVM_DUMP_METHOD
 raw_ostream &SDep::print(raw_ostream &OS, const TargetRegisterInfo *TRI) const {
   switch (getKind()) {
   case Data:   OS << "Data"; break;
@@ -336,7 +335,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 raw_ostream &SUnit::print(raw_ostream &OS,
                           const SUnit *Entry, const SUnit *Exit) const {
   if (this == Entry)
@@ -348,12 +346,10 @@
   return OS;
 }
 
-LLVM_DUMP_METHOD
 raw_ostream &SUnit::print(raw_ostream &OS, const ScheduleDAG *G) const {
   return print(OS, &G->EntrySU, &G->ExitSU);
 }
 
-LLVM_DUMP_METHOD
 void SUnit::dump(const ScheduleDAG *G) const {
   print(dbgs(), G);
   dbgs() << ": ";
@@ -360,7 +356,7 @@
   G->dumpNode(this);
 }
 
-LLVM_DUMP_METHOD void SUnit::dumpAll(const ScheduleDAG *G) const {
+void SUnit::dumpAll(const ScheduleDAG *G) const {
   dump(G);
 
   dbgs() << "  # preds left       : " << NumPredsLeft << "\n";
Index: lib/CodeGen/ScheduleDAGInstrs.cpp
===================================================================
--- lib/CodeGen/ScheduleDAGInstrs.cpp
+++ lib/CodeGen/ScheduleDAGInstrs.cpp
@@ -1410,7 +1410,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ILPValue::print(raw_ostream &OS) const {
+void ILPValue::print(raw_ostream &OS) const {
   OS << InstrCount << " / " << Length << " = ";
   if (!Length)
     OS << "BADILP";
@@ -1418,13 +1418,12 @@
     OS << format("%g", ((double)InstrCount / Length));
 }
 
-LLVM_DUMP_METHOD void ILPValue::dump() const {
+void ILPValue::dump() const {
   dbgs() << *this << '\n';
 }
 
 namespace llvm {
 
-LLVM_DUMP_METHOD
 raw_ostream &operator<<(raw_ostream &OS, const ILPValue &Val) {
   Val.print(OS);
   return OS;
Index: lib/CodeGen/ScoreboardHazardRecognizer.cpp
===================================================================
--- lib/CodeGen/ScoreboardHazardRecognizer.cpp
+++ lib/CodeGen/ScoreboardHazardRecognizer.cpp
@@ -84,7 +84,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ScoreboardHazardRecognizer::Scoreboard::dump() const {
+void ScoreboardHazardRecognizer::Scoreboard::dump() const {
   dbgs() << "Scoreboard:\n";
 
   unsigned last = Depth - 1;
Index: lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp
===================================================================
--- lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp
+++ lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp
@@ -1869,7 +1869,7 @@
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVM_DUMP_METHOD void dump(ScheduleDAG *DAG) const override {
+  void dump(ScheduleDAG *DAG) const override {
     // Emulate pop() without clobbering NodeQueueIds.
     std::vector<SUnit *> DumpQueue = Queue;
     SF DumpPicker = Picker;
@@ -2040,7 +2040,7 @@
 //===----------------------------------------------------------------------===//
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RegReductionPQBase::dumpRegPressure() const {
+void RegReductionPQBase::dumpRegPressure() const {
   for (const TargetRegisterClass *RC : TRI->regclasses()) {
     unsigned Id = RC->getID();
     unsigned RP = RegPressure[Id];
Index: lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
===================================================================
--- lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
+++ lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
@@ -402,9 +402,9 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SDNode::dump() const { dump(nullptr); }
+void SDNode::dump() const { dump(nullptr); }
 
-LLVM_DUMP_METHOD void SDNode::dump(const SelectionDAG *G) const {
+void SDNode::dump(const SelectionDAG *G) const {
   print(dbgs(), G);
   dbgs() << '\n';
 }
@@ -647,7 +647,7 @@
   N->dump(G);
 }
 
-LLVM_DUMP_METHOD void SelectionDAG::dump() const {
+void SelectionDAG::dump() const {
   dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:\n";
 
   for (allnodes_const_iterator I = allnodes_begin(), E = allnodes_end();
@@ -718,12 +718,12 @@
     DumpNodesr(OS, Op.getNode(), indent+2, G, once);
 }
 
-LLVM_DUMP_METHOD void SDNode::dumpr() const {
+void SDNode::dumpr() const {
   VisitedSDNodeSet once;
   DumpNodesr(dbgs(), this, 0, nullptr, once);
 }
 
-LLVM_DUMP_METHOD void SDNode::dumpr(const SelectionDAG *G) const {
+void SDNode::dumpr(const SelectionDAG *G) const {
   VisitedSDNodeSet once;
   DumpNodesr(dbgs(), this, 0, G, once);
 }
@@ -762,12 +762,11 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 void SDNode::dumprWithDepth(const SelectionDAG *G, unsigned depth) const {
   printrWithDepth(dbgs(), G, depth);
 }
 
-LLVM_DUMP_METHOD void SDNode::dumprFull(const SelectionDAG *G) const {
+void SDNode::dumprFull(const SelectionDAG *G) const {
   // Don't print impossibly deep things.
   dumprWithDepth(G, 10);
 }
Index: lib/CodeGen/SlotIndexes.cpp
===================================================================
--- lib/CodeGen/SlotIndexes.cpp
+++ lib/CodeGen/SlotIndexes.cpp
@@ -250,7 +250,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SlotIndexes::dump() const {
+void SlotIndexes::dump() const {
   for (IndexList::const_iterator itr = indexList.begin();
        itr != indexList.end(); ++itr) {
     dbgs() << itr->getIndex() << " ";
@@ -278,7 +278,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // Dump a SlotIndex to stderr.
-LLVM_DUMP_METHOD void SlotIndex::dump() const {
+void SlotIndex::dump() const {
   print(dbgs());
   dbgs() << "\n";
 }
Index: lib/CodeGen/SplitKit.cpp
===================================================================
--- lib/CodeGen/SplitKit.cpp
+++ lib/CodeGen/SplitKit.cpp
@@ -393,7 +393,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SplitEditor::dump() const {
+void SplitEditor::dump() const {
   if (RegAssign.empty()) {
     dbgs() << " empty\n";
     return;
Index: lib/CodeGen/StackColoring.cpp
===================================================================
--- lib/CodeGen/StackColoring.cpp
+++ lib/CodeGen/StackColoring.cpp
@@ -534,7 +534,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void StackColoring::dumpBV(const char *tag,
+void StackColoring::dumpBV(const char *tag,
                                             const BitVector &BV) const {
   dbgs() << tag << " : { ";
   for (unsigned I = 0, E = BV.size(); I != E; ++I)
@@ -542,7 +542,7 @@
   dbgs() << "}\n";
 }
 
-LLVM_DUMP_METHOD void StackColoring::dumpBB(MachineBasicBlock *MBB) const {
+void StackColoring::dumpBB(MachineBasicBlock *MBB) const {
   LivenessMap::const_iterator BI = BlockLiveness.find(MBB);
   assert(BI != BlockLiveness.end() && "Block not found");
   const BlockLifetimeInfo &BlockInfo = BI->second;
@@ -553,7 +553,7 @@
   dumpBV("LIVE_OUT", BlockInfo.LiveOut);
 }
 
-LLVM_DUMP_METHOD void StackColoring::dump() const {
+void StackColoring::dump() const {
   for (MachineBasicBlock *MBB : depth_first(MF)) {
     dbgs() << "Inspecting block #" << MBB->getNumber() << " ["
            << MBB->getName() << "]\n";
@@ -561,7 +561,7 @@
   }
 }
 
-LLVM_DUMP_METHOD void StackColoring::dumpIntervals() const {
+void StackColoring::dumpIntervals() const {
   for (unsigned I = 0, E = Intervals.size(); I != E; ++I) {
     dbgs() << "Interval[" << I << "]:\n";
     Intervals[I]->dump();
Index: lib/CodeGen/TargetRegisterInfo.cpp
===================================================================
--- lib/CodeGen/TargetRegisterInfo.cpp
+++ lib/CodeGen/TargetRegisterInfo.cpp
@@ -451,7 +451,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 void TargetRegisterInfo::dumpReg(unsigned Reg, unsigned SubRegIndex,
                                  const TargetRegisterInfo *TRI) {
   dbgs() << printReg(Reg, TRI, SubRegIndex) << "\n";
Index: lib/CodeGen/VirtRegMap.cpp
===================================================================
--- lib/CodeGen/VirtRegMap.cpp
+++ lib/CodeGen/VirtRegMap.cpp
@@ -157,7 +157,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void VirtRegMap::dump() const {
+void VirtRegMap::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
===================================================================
--- lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
+++ lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
@@ -114,7 +114,7 @@
   return {DieOffset, DieTag};
 }
 
-LLVM_DUMP_METHOD void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
+void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
   if (!IsValid)
     return;
 
Index: lib/DebugInfo/DWARF/DWARFDie.cpp
===================================================================
--- lib/DebugInfo/DWARF/DWARFDie.cpp
+++ lib/DebugInfo/DWARF/DWARFDie.cpp
@@ -508,7 +508,7 @@
   }
 }
 
-LLVM_DUMP_METHOD void DWARFDie::dump() const { dump(llvm::errs(), 0); }
+void DWARFDie::dump() const { dump(llvm::errs(), 0); }
 
 DWARFDie DWARFDie::getParent() const {
   if (isValid())
Index: lib/IR/AsmWriter.cpp
===================================================================
--- lib/IR/AsmWriter.cpp
+++ lib/IR/AsmWriter.cpp
@@ -3637,15 +3637,12 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // Value::dump - allow easy printing of Values from the debugger.
-LLVM_DUMP_METHOD
 void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
 
 // Type::dump - allow easy printing of Types from the debugger.
-LLVM_DUMP_METHOD
 void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
 
 // Module::dump() - Allow printing of Modules from the debugger.
-LLVM_DUMP_METHOD
 void Module::dump() const {
   print(dbgs(), nullptr,
         /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
@@ -3652,17 +3649,13 @@
 }
 
 // \brief Allow printing of Comdats from the debugger.
-LLVM_DUMP_METHOD
 void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
 
 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
-LLVM_DUMP_METHOD
 void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
 
-LLVM_DUMP_METHOD
 void Metadata::dump() const { dump(nullptr); }
 
-LLVM_DUMP_METHOD
 void Metadata::dump(const Module *M) const {
   print(dbgs(), M, /*IsForDebug=*/true);
   dbgs() << '\n';
Index: lib/IR/Attributes.cpp
===================================================================
--- lib/IR/Attributes.cpp
+++ lib/IR/Attributes.cpp
@@ -622,7 +622,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void AttributeSet::dump() const {
+void AttributeSet::dump() const {
   dbgs() << "AS =\n";
     dbgs() << "  { ";
     dbgs() << getAsString(true) << " }\n";
@@ -831,7 +831,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void AttributeListImpl::dump() const {
+void AttributeListImpl::dump() const {
   AttributeList(const_cast<AttributeListImpl *>(this)).dump();
 }
 #endif
@@ -1291,7 +1291,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void AttributeList::dump() const {
+void AttributeList::dump() const {
   dbgs() << "PAL[\n";
 
   for (unsigned i = index_begin(), e = index_end(); i != e; ++i) {
Index: lib/IR/ConstantRange.cpp
===================================================================
--- lib/IR/ConstantRange.cpp
+++ lib/IR/ConstantRange.cpp
@@ -1020,7 +1020,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ConstantRange::dump() const {
+void ConstantRange::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/IR/Core.cpp
===================================================================
--- lib/IR/Core.cpp
+++ lib/IR/Core.cpp
@@ -359,11 +359,9 @@
   return wrap(&unwrap(Ty)->getContext());
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LLVMDumpType(LLVMTypeRef Ty) {
-  return unwrap(Ty)->dump();
+void LLVMDumpType(LLVMTypeRef Ty) {
+  return unwrap(Ty)->print(errs(), /*IsForDebug=*/true);
 }
-#endif
 
 char *LLVMPrintTypeToString(LLVMTypeRef Ty) {
   std::string buf;
@@ -658,7 +656,7 @@
   unwrap(Val)->setName(Name);
 }
 
-LLVM_DUMP_METHOD void LLVMDumpValue(LLVMValueRef Val) {
+void LLVMDumpValue(LLVMValueRef Val) {
   unwrap(Val)->print(errs(), /*IsForDebug=*/true);
 }
 
Index: lib/IR/DebugLoc.cpp
===================================================================
--- lib/IR/DebugLoc.cpp
+++ lib/IR/DebugLoc.cpp
@@ -99,7 +99,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DebugLoc::dump() const {
+void DebugLoc::dump() const {
   if (!Loc)
     return;
 
Index: lib/IR/LegacyPassManager.cpp
===================================================================
--- lib/IR/LegacyPassManager.cpp
+++ lib/IR/LegacyPassManager.cpp
@@ -1804,7 +1804,7 @@
 }
 
 // Dump content of the pass manager stack.
-LLVM_DUMP_METHOD void PMStack::dump() const {
+void PMStack::dump() const {
   for (PMDataManager *Manager : S)
     dbgs() << Manager->getAsPass()->getPassName() << ' ';
 
Index: lib/IR/Pass.cpp
===================================================================
--- lib/IR/Pass.cpp
+++ lib/IR/Pass.cpp
@@ -126,7 +126,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // dump - call print(cerr);
-LLVM_DUMP_METHOD void Pass::dump() const {
+void Pass::dump() const {
   print(dbgs(), nullptr);
 }
 #endif
Index: lib/IR/ValueSymbolTable.cpp
===================================================================
--- lib/IR/ValueSymbolTable.cpp
+++ lib/IR/ValueSymbolTable.cpp
@@ -114,7 +114,7 @@
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // dump - print out the symbol table
 //
-LLVM_DUMP_METHOD void ValueSymbolTable::dump() const {
+void ValueSymbolTable::dump() const {
   //dbgs() << "ValueSymbolTable:\n";
   for (const auto &I : *this) {
     //dbgs() << "  '" << I->getKeyData() << "' = ";
Index: lib/MC/MCExpr.cpp
===================================================================
--- lib/MC/MCExpr.cpp
+++ lib/MC/MCExpr.cpp
@@ -137,7 +137,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCExpr::dump() const {
+void MCExpr::dump() const {
   dbgs() << *this;
   dbgs() << '\n';
 }
Index: lib/MC/MCFragment.cpp
===================================================================
--- lib/MC/MCFragment.cpp
+++ lib/MC/MCFragment.cpp
@@ -310,7 +310,7 @@
 } // end namespace llvm
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCFragment::dump() const {
+void MCFragment::dump() const {
   raw_ostream &OS = errs();
 
   OS << "<";
@@ -464,7 +464,7 @@
   OS << ">";
 }
 
-LLVM_DUMP_METHOD void MCAssembler::dump() const{
+void MCAssembler::dump() const{
   raw_ostream &OS = errs();
 
   OS << "<MCAssembler\n";
Index: lib/MC/MCInst.cpp
===================================================================
--- lib/MC/MCInst.cpp
+++ lib/MC/MCInst.cpp
@@ -36,7 +36,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCOperand::dump() const {
+void MCOperand::dump() const {
   print(dbgs());
   dbgs() << "\n";
 }
@@ -67,7 +67,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCInst::dump() const {
+void MCInst::dump() const {
   print(dbgs());
   dbgs() << "\n";
 }
Index: lib/MC/MCLabel.cpp
===================================================================
--- lib/MC/MCLabel.cpp
+++ lib/MC/MCLabel.cpp
@@ -19,7 +19,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCLabel::dump() const {
+void MCLabel::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/MC/MCSection.cpp
===================================================================
--- lib/MC/MCSection.cpp
+++ lib/MC/MCSection.cpp
@@ -86,7 +86,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCSection::dump() const {
+void MCSection::dump() const {
   raw_ostream &OS = errs();
 
   OS << "<MCSection";
Index: lib/MC/MCSymbol.cpp
===================================================================
--- lib/MC/MCSymbol.cpp
+++ lib/MC/MCSymbol.cpp
@@ -82,7 +82,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCSymbol::dump() const {
+void MCSymbol::dump() const {
   dbgs() << *this;
 }
 #endif
Index: lib/MC/MCValue.cpp
===================================================================
--- lib/MC/MCValue.cpp
+++ lib/MC/MCValue.cpp
@@ -38,7 +38,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MCValue::dump() const {
+void MCValue::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/MC/SubtargetFeature.cpp
===================================================================
--- lib/MC/SubtargetFeature.cpp
+++ lib/MC/SubtargetFeature.cpp
@@ -257,7 +257,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SubtargetFeatures::dump() const {
+void SubtargetFeatures::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/MC/WasmObjectWriter.cpp
===================================================================
--- lib/MC/WasmObjectWriter.cpp
+++ lib/MC/WasmObjectWriter.cpp
@@ -170,7 +170,7 @@
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+  void dump() const { print(dbgs()); }
 #endif
 };
 
Index: lib/Option/Arg.cpp
===================================================================
--- lib/Option/Arg.cpp
+++ lib/Option/Arg.cpp
@@ -62,7 +62,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void Arg::dump() const { print(dbgs()); }
+void Arg::dump() const { print(dbgs()); }
 #endif
 
 std::string Arg::getAsString(const ArgList &Args) const {
Index: lib/Option/ArgList.cpp
===================================================================
--- lib/Option/ArgList.cpp
+++ lib/Option/ArgList.cpp
@@ -205,7 +205,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ArgList::dump() const { print(dbgs()); }
+void ArgList::dump() const { print(dbgs()); }
 #endif
 
 void InputArgList::releaseMemory() {
Index: lib/Option/Option.cpp
===================================================================
--- lib/Option/Option.cpp
+++ lib/Option/Option.cpp
@@ -87,7 +87,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void Option::dump() const { print(dbgs()); }
+void Option::dump() const { print(dbgs()); }
 #endif
 
 bool Option::matches(OptSpecifier Opt) const {
Index: lib/ProfileData/GCOV.cpp
===================================================================
--- lib/ProfileData/GCOV.cpp
+++ lib/ProfileData/GCOV.cpp
@@ -110,7 +110,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// dump - Dump GCOVFile content to dbgs() for debugging purposes.
-LLVM_DUMP_METHOD void GCOVFile::dump() const {
+void GCOVFile::dump() const {
   print(dbgs());
 }
 #endif
@@ -358,7 +358,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// dump - Dump GCOVFunction content to dbgs() for debugging purposes.
-LLVM_DUMP_METHOD void GCOVFunction::dump() const {
+void GCOVFunction::dump() const {
   print(dbgs());
 }
 #endif
@@ -436,7 +436,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// dump - Dump GCOVBlock content to dbgs() for debugging purposes.
-LLVM_DUMP_METHOD void GCOVBlock::dump() const {
+void GCOVBlock::dump() const {
   print(dbgs());
 }
 #endif
Index: lib/ProfileData/SampleProf.cpp
===================================================================
--- lib/ProfileData/SampleProf.cpp
+++ lib/ProfileData/SampleProf.cpp
@@ -83,7 +83,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void LineLocation::dump() const { print(dbgs()); }
+void LineLocation::dump() const { print(dbgs()); }
 #endif
 
 /// \brief Print the sample record to the stream \p OS indented by \p Indent.
@@ -98,7 +98,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SampleRecord::dump() const { print(dbgs(), 0); }
+void SampleRecord::dump() const { print(dbgs(), 0); }
 #endif
 
 raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
@@ -151,5 +151,5 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void FunctionSamples::dump() const { print(dbgs(), 0); }
+void FunctionSamples::dump() const { print(dbgs(), 0); }
 #endif
Index: lib/Support/APFloat.cpp
===================================================================
--- lib/Support/APFloat.cpp
+++ lib/Support/APFloat.cpp
@@ -4490,7 +4490,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void APFloat::dump() const { print(dbgs()); }
+void APFloat::dump() const { print(dbgs()); }
 #endif
 
 void APFloat::Profile(FoldingSetNodeID &NID) const {
Index: lib/Support/APInt.cpp
===================================================================
--- lib/Support/APInt.cpp
+++ lib/Support/APInt.cpp
@@ -2131,7 +2131,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void APInt::dump() const {
+void APInt::dump() const {
   SmallString<40> S, U;
   this->toStringUnsigned(U);
   this->toStringSigned(S);
Index: lib/Support/BranchProbability.cpp
===================================================================
--- lib/Support/BranchProbability.cpp
+++ lib/Support/BranchProbability.cpp
@@ -33,7 +33,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void BranchProbability::dump() const { print(dbgs()) << '\n'; }
+void BranchProbability::dump() const { print(dbgs()) << '\n'; }
 #endif
 
 BranchProbability::BranchProbability(uint32_t Numerator, uint32_t Denominator) {
Index: lib/Support/DebugCounter.cpp
===================================================================
--- lib/Support/DebugCounter.cpp
+++ lib/Support/DebugCounter.cpp
@@ -109,6 +109,6 @@
        << KV.second.first << "," << KV.second.second << "}\n";
 }
 
-LLVM_DUMP_METHOD void DebugCounter::dump() const {
+void DebugCounter::dump() const {
   print(dbgs());
 }
Index: lib/Support/Twine.cpp
===================================================================
--- lib/Support/Twine.cpp
+++ lib/Support/Twine.cpp
@@ -174,11 +174,11 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void Twine::dump() const {
+void Twine::dump() const {
   print(dbgs());
 }
 
-LLVM_DUMP_METHOD void Twine::dumpRepr() const {
+void Twine::dumpRepr() const {
   printRepr(dbgs());
 }
 #endif
Index: lib/TableGen/Record.cpp
===================================================================
--- lib/TableGen/Record.cpp
+++ lib/TableGen/Record.cpp
@@ -49,7 +49,7 @@
 DagRecTy DagRecTy::Shared;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RecTy::dump() const { print(errs()); }
+void RecTy::dump() const { print(errs()); }
 #endif
 
 ListRecTy *RecTy::getListTy() {
@@ -173,7 +173,7 @@
 void Init::anchor() {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
+void Init::dump() const { return print(errs()); }
 #endif
 
 UnsetInit *UnsetInit::get() {
@@ -1582,7 +1582,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void RecordVal::dump() const { errs() << *this; }
+void RecordVal::dump() const { errs() << *this; }
 #endif
 
 void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
@@ -1661,7 +1661,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void Record::dump() const { errs() << *this; }
+void Record::dump() const { errs() << *this; }
 #endif
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
@@ -1855,7 +1855,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MultiClass::dump() const {
+void MultiClass::dump() const {
   errs() << "Record:\n";
   Rec.dump();
 
@@ -1864,7 +1864,7 @@
     Proto->dump();
 }
 
-LLVM_DUMP_METHOD void RecordKeeper::dump() const { errs() << *this; }
+void RecordKeeper::dump() const { errs() << *this; }
 #endif
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
Index: lib/TableGen/TGParser.cpp
===================================================================
--- lib/TableGen/TGParser.cpp
+++ lib/TableGen/TGParser.cpp
@@ -55,7 +55,7 @@
 };
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SubMultiClassReference::dump() const {
+void SubMultiClassReference::dump() const {
   errs() << "Multiclass:\n";
 
   MC->dump();
Index: lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp
===================================================================
--- lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp
+++ lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp
@@ -262,7 +262,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void PHILinearize::dump(MachineRegisterInfo *MRI) {
+void PHILinearize::dump(MachineRegisterInfo *MRI) {
   const TargetRegisterInfo *TRI = MRI->getTargetRegisterInfo();
   dbgs() << "=PHIInfo Start=\n";
   for (auto PII : this->PHIInfo) {
Index: lib/Target/AMDGPU/GCNIterativeScheduler.cpp
===================================================================
--- lib/Target/AMDGPU/GCNIterativeScheduler.cpp
+++ lib/Target/AMDGPU/GCNIterativeScheduler.cpp
@@ -55,7 +55,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 static void printRegion(raw_ostream &OS,
                         MachineBasicBlock::iterator Begin,
                         MachineBasicBlock::iterator End,
@@ -86,7 +85,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 static void printLivenessInfo(raw_ostream &OS,
                               MachineBasicBlock::iterator Begin,
                               MachineBasicBlock::iterator End,
@@ -104,7 +102,6 @@
   getRegPressure(MRI, LiveOuts).print(OS);
 }
 
-LLVM_DUMP_METHOD
 void GCNIterativeScheduler::printRegions(raw_ostream &OS) const {
   const auto &ST = MF.getSubtarget<SISubtarget>();
   for (const auto R : Regions) {
@@ -116,7 +113,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void GCNIterativeScheduler::printSchedResult(raw_ostream &OS,
                                              const Region *R,
                                              const GCNRegPressure &RP) const {
@@ -126,7 +122,6 @@
   OS << '\n';
 }
 
-LLVM_DUMP_METHOD
 void GCNIterativeScheduler::printSchedRP(raw_ostream &OS,
                                          const GCNRegPressure &Before,
                                          const GCNRegPressure &After) const {
Index: lib/Target/AMDGPU/GCNRegPressure.cpp
===================================================================
--- lib/Target/AMDGPU/GCNRegPressure.cpp
+++ lib/Target/AMDGPU/GCNRegPressure.cpp
@@ -32,7 +32,6 @@
 #define DEBUG_TYPE "machine-scheduler"
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 void llvm::printLivesAt(SlotIndex SI,
                         const LiveIntervals &LIS,
                         const MachineRegisterInfo &MRI) {
@@ -176,7 +175,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 void GCNRegPressure::print(raw_ostream &OS, const SISubtarget *ST) const {
   OS << "VGPRs: " << getVGPRNum();
   if (ST) OS << "(O" << ST->getOccupancyWithNumVGPRs(getVGPRNum()) << ')';
@@ -434,7 +432,6 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD
 static void reportMismatch(const GCNRPTracker::LiveRegSet &LISLR,
                            const GCNRPTracker::LiveRegSet &TrackedLR,
                            const TargetRegisterInfo *TRI) {
Index: lib/Target/AMDGPU/SIPeepholeSDWA.cpp
===================================================================
--- lib/Target/AMDGPU/SIPeepholeSDWA.cpp
+++ lib/Target/AMDGPU/SIPeepholeSDWA.cpp
@@ -245,7 +245,6 @@
   return OS;
 }
 
-LLVM_DUMP_METHOD
 void SDWASrcOperand::print(raw_ostream& OS) const {
   OS << "SDWA src: " << *getTargetOperand()
     << " src_sel:" << getSrcSel()
@@ -253,7 +252,6 @@
     << " sext:" << getSext() << '\n';
 }
 
-LLVM_DUMP_METHOD
 void SDWADstOperand::print(raw_ostream& OS) const {
   OS << "SDWA dst: " << *getTargetOperand()
     << " dst_sel:" << getDstSel()
@@ -260,7 +258,6 @@
     << " dst_unused:" << getDstUnused() << '\n';
 }
 
-LLVM_DUMP_METHOD
 void SDWADstPreserveOperand::print(raw_ostream& OS) const {
   OS << "SDWA preserve dst: " << *getTargetOperand()
     << " dst_sel:" << getDstSel()
Index: lib/Target/AMDGPU/SIWholeQuadMode.cpp
===================================================================
--- lib/Target/AMDGPU/SIWholeQuadMode.cpp
+++ lib/Target/AMDGPU/SIWholeQuadMode.cpp
@@ -222,7 +222,7 @@
 }
 
 #ifndef NDEBUG
-LLVM_DUMP_METHOD void SIWholeQuadMode::printInfo() {
+void SIWholeQuadMode::printInfo() {
   for (const auto &BII : Blocks) {
     dbgs() << "\n"
            << printMBBReference(*BII.first) << ":\n"
Index: lib/Target/ARM/ARMConstantIslandPass.cpp
===================================================================
--- lib/Target/ARM/ARMConstantIslandPass.cpp
+++ lib/Target/ARM/ARMConstantIslandPass.cpp
@@ -322,7 +322,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// print block size and offset information - debugging
-LLVM_DUMP_METHOD void ARMConstantIslands::dumpBBs() {
+void ARMConstantIslands::dumpBBs() {
   DEBUG({
     for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
       const BasicBlockInfo &BBI = BBInfo[J];
Index: lib/Target/ARM/ARMConstantPoolValue.cpp
===================================================================
--- lib/Target/ARM/ARMConstantPoolValue.cpp
+++ lib/Target/ARM/ARMConstantPoolValue.cpp
@@ -98,7 +98,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void ARMConstantPoolValue::dump() const {
+void ARMConstantPoolValue::dump() const {
   errs() << "  " << *this;
 }
 #endif
Index: lib/Target/Hexagon/HexagonConstExtenders.cpp
===================================================================
--- lib/Target/Hexagon/HexagonConstExtenders.cpp
+++ lib/Target/Hexagon/HexagonConstExtenders.cpp
@@ -549,13 +549,13 @@
 char HCE::ID = 0;
 
 #ifndef NDEBUG
-LLVM_DUMP_METHOD void RangeTree::dump() const {
+void RangeTree::dump() const {
   dbgs() << "Root: " << Root << '\n';
   if (Root)
     dump(Root);
 }
 
-LLVM_DUMP_METHOD void RangeTree::dump(const Node *N) const {
+void RangeTree::dump(const Node *N) const {
   dbgs() << "Node: " << N << '\n';
   dbgs() << "  Height: " << N->Height << '\n';
   dbgs() << "  Count: " << N->Count << '\n';
Index: lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp
===================================================================
--- lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp
+++ lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp
@@ -271,7 +271,6 @@
   return true;
 }
 
-LLVM_DUMP_METHOD
 void Coloring::dump() const {
   dbgs() << "{ Order:   {";
   for (unsigned I = 0; I != Order.size(); ++I) {
Index: lib/Target/Hexagon/HexagonSplitDouble.cpp
===================================================================
--- lib/Target/Hexagon/HexagonSplitDouble.cpp
+++ lib/Target/Hexagon/HexagonSplitDouble.cpp
@@ -132,7 +132,7 @@
   "Hexagon Split Double Registers", false, false)
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void HexagonSplitDoubleRegs::dump_partition(raw_ostream &os,
+void HexagonSplitDoubleRegs::dump_partition(raw_ostream &os,
       const USet &Part, const TargetRegisterInfo &TRI) {
   dbgs() << '{';
   for (auto I : Part)
Index: lib/Target/MSP430/MSP430ISelDAGToDAG.cpp
===================================================================
--- lib/Target/MSP430/MSP430ISelDAGToDAG.cpp
+++ lib/Target/MSP430/MSP430ISelDAGToDAG.cpp
@@ -62,7 +62,7 @@
     }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-    LLVM_DUMP_METHOD void dump() {
+    void dump() {
       errs() << "MSP430ISelAddressMode " << this << '\n';
       if (BaseType == RegBase && Base.Reg.getNode() != nullptr) {
         errs() << "Base.Reg ";
Index: lib/Target/Mips/MipsConstantIslandPass.cpp
===================================================================
--- lib/Target/Mips/MipsConstantIslandPass.cpp
+++ lib/Target/Mips/MipsConstantIslandPass.cpp
@@ -427,7 +427,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// print block size and offset information - debugging
-LLVM_DUMP_METHOD void MipsConstantIslands::dumpBBs() {
+void MipsConstantIslands::dumpBBs() {
   for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
     const BasicBlockInfo &BBI = BBInfo[J];
     dbgs() << format("%08x %bb.%u\t", BBI.Offset, J)
Index: lib/Target/PowerPC/PPCReduceCRLogicals.cpp
===================================================================
--- lib/Target/PowerPC/PPCReduceCRLogicals.cpp
+++ lib/Target/PowerPC/PPCReduceCRLogicals.cpp
@@ -232,7 +232,7 @@
 };
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void PPCReduceCRLogicals::CRLogicalOpInfo::dump() {
+void PPCReduceCRLogicals::CRLogicalOpInfo::dump() {
   dbgs() << "CRLogicalOpMI: ";
   MI->dump();
   dbgs() << "IsBinary: " << IsBinary << ", FeedsISEL: " << FeedsISEL;
Index: lib/Target/PowerPC/PPCVSXSwapRemoval.cpp
===================================================================
--- lib/Target/PowerPC/PPCVSXSwapRemoval.cpp
+++ lib/Target/PowerPC/PPCVSXSwapRemoval.cpp
@@ -957,7 +957,7 @@
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 // For debug purposes, dump the contents of the swap vector.
-LLVM_DUMP_METHOD void PPCVSXSwapRemoval::dumpSwapVector() {
+void PPCVSXSwapRemoval::dumpSwapVector() {
 
   for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {
 
Index: lib/Transforms/Coroutines/CoroFrame.cpp
===================================================================
--- lib/Transforms/Coroutines/CoroFrame.cpp
+++ lib/Transforms/Coroutines/CoroFrame.cpp
@@ -134,7 +134,7 @@
 } // end anonymous namespace
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SuspendCrossingInfo::dump(StringRef Label,
+void SuspendCrossingInfo::dump(StringRef Label,
                                                 BitVector const &BV) const {
   dbgs() << Label << ":";
   for (size_t I = 0, N = BV.size(); I < N; ++I)
@@ -143,7 +143,7 @@
   dbgs() << "\n";
 }
 
-LLVM_DUMP_METHOD void SuspendCrossingInfo::dump() const {
+void SuspendCrossingInfo::dump() const {
   for (size_t I = 0, N = Block.size(); I < N; ++I) {
     BasicBlock *const B = Mapping.indexToBlock(I);
     dbgs() << B->getName() << ":\n";
Index: lib/Transforms/Scalar/GVN.cpp
===================================================================
--- lib/Transforms/Scalar/GVN.cpp
+++ lib/Transforms/Scalar/GVN.cpp
@@ -647,7 +647,7 @@
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void GVN::dump(DenseMap<uint32_t, Value*>& d) const {
+void GVN::dump(DenseMap<uint32_t, Value*>& d) const {
   errs() << "{\n";
   for (DenseMap<uint32_t, Value*>::iterator I = d.begin(),
        E = d.end(); I != E; ++I) {
Index: lib/Transforms/Scalar/GVNSink.cpp
===================================================================
--- lib/Transforms/Scalar/GVNSink.cpp
+++ lib/Transforms/Scalar/GVNSink.cpp
@@ -88,7 +88,7 @@
 namespace llvm {
 namespace GVNExpression {
 
-LLVM_DUMP_METHOD void Expression::dump() const {
+void Expression::dump() const {
   print(dbgs());
   dbgs() << "\n";
 }
Index: lib/Transforms/Scalar/GuardWidening.cpp
===================================================================
--- lib/Transforms/Scalar/GuardWidening.cpp
+++ lib/Transforms/Scalar/GuardWidening.cpp
@@ -165,7 +165,7 @@
       Length->printAsOperand(OS, PrintTypes);
     }
 
-    LLVM_DUMP_METHOD void dump() {
+    void dump() {
       print(dbgs());
       dbgs() << "\n";
     }
Index: lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
===================================================================
--- lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
+++ lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
@@ -188,7 +188,6 @@
     OS << " Operand: " << getCheckUse()->getOperandNo() << "\n";
   }
 
-  LLVM_DUMP_METHOD
   void dump() {
     print(dbgs());
   }
Index: lib/Transforms/Scalar/LoopStrengthReduce.cpp
===================================================================
--- lib/Transforms/Scalar/LoopStrengthReduce.cpp
+++ lib/Transforms/Scalar/LoopStrengthReduce.cpp
@@ -205,7 +205,7 @@
   OS << "[NumUses=" << UsedByIndices.count() << ']';
 }
 
-LLVM_DUMP_METHOD void RegSortData::dump() const {
+void RegSortData::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
@@ -603,7 +603,7 @@
   }
 }
 
-LLVM_DUMP_METHOD void Formula::dump() const {
+void Formula::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
@@ -1402,7 +1402,7 @@
     OS << ", plus " << C.SetupCost << " setup cost";
 }
 
-LLVM_DUMP_METHOD void Cost::dump() const {
+void Cost::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
@@ -1445,7 +1445,7 @@
     OS << ", Offset=" << Offset;
 }
 
-LLVM_DUMP_METHOD void LSRFixup::dump() const {
+void LSRFixup::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
@@ -1561,7 +1561,7 @@
     OS << ", widest fixup type: " << *WidestFixupType;
 }
 
-LLVM_DUMP_METHOD void LSRUse::dump() const {
+void LSRUse::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
@@ -3902,7 +3902,7 @@
      << " , add offset " << Imm;
 }
 
-LLVM_DUMP_METHOD void WorkItem::dump() const {
+void WorkItem::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
@@ -5408,7 +5408,7 @@
   print_uses(OS);
 }
 
-LLVM_DUMP_METHOD void LSRInstance::dump() const {
+void LSRInstance::dump() const {
   print(errs()); errs() << '\n';
 }
 #endif
Index: lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
===================================================================
--- lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
+++ lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
@@ -681,7 +681,6 @@
 
   bool operator!=(const BDVState &other) const { return !(*this == other); }
 
-  LLVM_DUMP_METHOD
   void dump() const {
     print(dbgs());
     dbgs() << '\n';
Index: lib/Transforms/Scalar/SROA.cpp
===================================================================
--- lib/Transforms/Scalar/SROA.cpp
+++ lib/Transforms/Scalar/SROA.cpp
@@ -1099,10 +1099,10 @@
     print(OS, I);
 }
 
-LLVM_DUMP_METHOD void AllocaSlices::dump(const_iterator I) const {
+void AllocaSlices::dump(const_iterator I) const {
   print(dbgs(), I);
 }
-LLVM_DUMP_METHOD void AllocaSlices::dump() const { print(dbgs()); }
+void AllocaSlices::dump() const { print(dbgs()); }
 
 #endif // !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 
Index: utils/TableGen/AsmMatcherEmitter.cpp
===================================================================
--- utils/TableGen/AsmMatcherEmitter.cpp
+++ utils/TableGen/AsmMatcherEmitter.cpp
@@ -767,7 +767,7 @@
 } // end anonymous namespace
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void MatchableInfo::dump() const {
+void MatchableInfo::dump() const {
   errs() << TheDef->getName() << " -- " << "flattened:\"" << AsmString <<"\"\n";
 
   for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
Index: utils/TableGen/CodeGenDAGPatterns.cpp
===================================================================
--- utils/TableGen/CodeGenDAGPatterns.cpp
+++ utils/TableGen/CodeGenDAGPatterns.cpp
@@ -245,7 +245,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void TypeSetByHwMode::dump() const {
   dbgs() << *this << '\n';
 }
Index: utils/TableGen/CodeGenHwModes.cpp
===================================================================
--- utils/TableGen/CodeGenHwModes.cpp
+++ utils/TableGen/CodeGenHwModes.cpp
@@ -24,7 +24,6 @@
   Features = R->getValueAsString("Features");
 }
 
-LLVM_DUMP_METHOD
 void HwMode::dump() const {
   dbgs() << Name << ": " << Features << '\n';
 }
@@ -44,7 +43,6 @@
   }
 }
 
-LLVM_DUMP_METHOD
 void HwModeSelect::dump() const {
   dbgs() << '{';
   for (const PairType &P : Items)
@@ -91,7 +89,6 @@
   return F->second;
 }
 
-LLVM_DUMP_METHOD
 void CodeGenHwModes::dump() const {
   dbgs() << "Modes: {\n";
   for (const HwMode &M : Modes) {
Index: utils/TableGen/InfoByHwMode.cpp
===================================================================
--- utils/TableGen/InfoByHwMode.cpp
+++ utils/TableGen/InfoByHwMode.cpp
@@ -97,7 +97,6 @@
   OS << '}';
 }
 
-LLVM_DUMP_METHOD
 void ValueTypeByHwMode::dump() const {
   dbgs() << *this << '\n';
 }
Index: utils/TableGen/SubtargetFeatureInfo.cpp
===================================================================
--- utils/TableGen/SubtargetFeatureInfo.cpp
+++ utils/TableGen/SubtargetFeatureInfo.cpp
@@ -17,7 +17,7 @@
 using namespace llvm;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void SubtargetFeatureInfo::dump() const {
+void SubtargetFeatureInfo::dump() const {
   errs() << getEnumName() << " " << Index << "\n" << *TheDef;
 }
 #endif