Remove the DEBUG macro.

[Nicola]

Summary

Now that the LLVM_DEBUG() macro landed on the various sub-projects the DEBUG macro can be removed.

Only one new use of the old DEBUG macro happened in the meantime, so I'm also cleaning that one up.

[xbolva00]

lg

llvm/trunk/include/llvm/DebugInfo/PDB/DIA/DIASupport.h

 // Require at least Vista
 #define NTDDI_VERSION NTDDI_VISTA
 #define _WIN32_WINNT _WIN32_WINNT_VISTA
 #define WINVER _WIN32_WINNT_VISTA
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 
-// llvm/Support/Debug.h unconditionally #defines DEBUG as a macro.
-// DIA headers #define it if it is not already defined, so we have
-// an order of includes problem.  The real fix is to make LLVM use
-// something less generic than DEBUG, such as LLVM_DEBUG(), but it's
-// fairly prevalent.  So for now, we save the definition state and
-// restore it.
-#pragma push_macro("DEBUG")
-
 // atlbase.h has to come before windows.h
 #include <atlbase.h>
 #include <windows.h>
 
 // DIA headers must come after windows headers.
 #include <cvconst.h>
 #include <dia2.h>
 #include <diacreate.h>
 
-#pragma pop_macro("DEBUG")
-
 #endif // LLVM_DEBUGINFO_PDB_DIA_DIASUPPORT_H

llvm/trunk/include/llvm/Support/Debug.h

 // In the '-debug' option is specified on the commandline, and if this is a
 // debug build, then the code specified as the option to the macro will be
 // executed.  Otherwise it will not be.  Example:
 //
 // LLVM_DEBUG(dbgs() << "Bitset contains: " << Bitset << "\n");
 //
 #define LLVM_DEBUG(X) DEBUG_WITH_TYPE(DEBUG_TYPE, X)
 
-#define DEBUG(X) LLVM_DEBUG(X)
-
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_DEBUG_H

llvm/trunk/lib/Target/X86/X86DomainReassignment.cpp

for (unsigned Idx = 0; Idx < MRI->getNumVirtRegs(); ++Idx) {
     buildClosure(C, Reg);
 
     // Collect all closures that can potentially be converted.
     if (!C.empty() && C.isLegal(MaskDomain))
       Closures.push_back(std::move(C));
   }
 
   for (Closure &C : Closures) {
-    DEBUG(C.dump(MRI));
+    LLVM_DEBUG(C.dump(MRI));
     if (isReassignmentProfitable(C, MaskDomain)) {
       reassign(C, MaskDomain);
       ++NumClosuresConverted;
       Changed = true;
     }
   }
 
   DeleteContainerSeconds(Converters);

llvm/trunk/lib/Transforms/IPO/MergeFunctions.cpp

void MergeFunctions::filterInstsUnrelatedToPDI(
   LLVM_DEBUG(dbgs() << " }\n");
 }
 
 // Don't merge tiny functions using a thunk, since it can just end up
 // making the function larger.
 static bool isThunkProfitable(Function * F) {
   if (F->size() == 1) {
     if (F->front().size() <= 2) {
-      DEBUG(dbgs() << "isThunkProfitable: " << F->getName()
+      LLVM_DEBUG(dbgs() << "isThunkProfitable: " << F->getName()
                         << " is too small to bother creating a thunk for\n");
       return false;
     }
   }
   return true;
 }
 
 // Replace G with a simple tail call to bitcast(F). Also (unless
 // MergeFunctionsPDI holds) replace direct uses of G with bitcast(F),

llvm/trunk/lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp

 // existing one if it was already created.
 VPBasicBlock *PlainCFGBuilder::getOrCreateVPBB(BasicBlock *BB) {
   auto BlockIt = BB2VPBB.find(BB);
   if (BlockIt != BB2VPBB.end())
     // Retrieve existing VPBB.
     return BlockIt->second;
 
   // Create new VPBB.
-  DEBUG(dbgs() << "Creating VPBasicBlock for " << BB->getName() << "\n");
+  LLVM_DEBUG(dbgs() << "Creating VPBasicBlock for " << BB->getName() << "\n");
   VPBasicBlock *VPBB = new VPBasicBlock(BB->getName());
   BB2VPBB[BB] = VPBB;
   VPBB->setParent(TopRegion);
   return VPBB;
 }
 
 // Return true if \p Val is considered an external definition. An external
 // definition is either:

 }
 
 // Public interface to build a H-CFG.
 void VPlanHCFGBuilder::buildHierarchicalCFG(VPlan &Plan) {
   // Build Top Region enclosing the plain CFG and set it as VPlan entry.
   PlainCFGBuilder PCFGBuilder(TheLoop, LI, Plan);
   VPRegionBlock *TopRegion = PCFGBuilder.buildPlainCFG();
   Plan.setEntry(TopRegion);
-  DEBUG(Plan.setName("HCFGBuilder: Plain CFG\n"); dbgs() << Plan);
+  LLVM_DEBUG(Plan.setName("HCFGBuilder: Plain CFG\n"); dbgs() << Plan);
 
   Verifier.verifyHierarchicalCFG(TopRegion);
 }

llvm/trunk/lib/Transforms/Vectorize/VPlanVerifier.cpp

static void verifyRegionRec(const VPRegionBlock *Region) {
   }
 }
 
 void VPlanVerifier::verifyHierarchicalCFG(
     const VPRegionBlock *TopRegion) const {
   if (!EnableHCFGVerifier)
     return;
 
-  DEBUG(dbgs() << "Verifying VPlan H-CFG.\n");
+  LLVM_DEBUG(dbgs() << "Verifying VPlan H-CFG.\n");
   assert(!TopRegion->getParent() && "VPlan Top Region should have no parent.");
   verifyRegionRec(TopRegion);
 }

llvm/trunk/utils/TableGen/GlobalISelEmitter.cpp

for (Matcher *Rule : Rules) {
     // Try to add the pending matcher to a newly created empty group:
     if (!CurrentGroup->addMatcher(*Rule))
       // If we couldn't add the matcher to an empty group, that group type
       // doesn't support that kind of matchers at all, so just skip it:
       OptRules.push_back(Rule);
   }
   ProcessCurrentGroup();
 
-  DEBUG(dbgs() << "NumGroups: " << NumGroups << "\n");
+  LLVM_DEBUG(dbgs() << "NumGroups: " << NumGroups << "\n");
   assert(CurrentGroup->empty() && "The last group wasn't properly processed");
   return OptRules;
 }
 
 MatchTable
 GlobalISelEmitter::buildMatchTable(MutableArrayRef<RuleMatcher> Rules,
                                    bool Optimize, bool WithCoverage) {
   std::vector<Matcher *> InputRules;