Change DEBUG() macro to LLVM_DEBUG() in Polly

[Nicola]

Summary

The DEBUG() macro is too generic so it might clash with other projects.
This is going to be deprecated and replaced by LLVM_DEBUG() as soon as https://reviews.llvm.org/D43624 is submitted.

This is the command I used to do the replacement and formatting:
git grep -l 'DEBUG' | xargs sed -i 's/\bDEBUG\s\?(/LLVM_DEBUG(/g'
git diff -U0 master | ../clang/tools/clang-format/clang-format-diff.py -i -p1 -style LLVM

[sbc100]

Looks like the title is wrong but otherwise lgtm

[Nicola]

I uploaded the wrong patch, sorry about that. I mixed up the patch file selection. This is the correct one for Polly.

[Meinersbur]

Did you use the latest version of clang-format? Our unittests include a checking correct formatting and clang-format suggests the following changes:

--- C:/Users/Meinersbur/src/llvm/tools/polly/lib/CodeGen/PPCGCodeGeneration.cpp Fri Mar 30 11:50:07 2018
+++ -   Wed Dec 31 18:00:00 1969
@@ -3409,8 +3409,8 @@
         // Look for (<func-type>*) among operands of Inst
         if (auto PtrTy = dyn_cast<PointerType>(Op->getType())) {
           if (isa<FunctionType>(PtrTy->getElementType())) {
-            LLVM_DEBUG(dbgs() << Inst
-                              << " has illegal use of function in kernel.\n");
+            LLVM_DEBUG(dbgs()
+                       << Inst << " has illegal use of function in kernel.\n");
             return true;
           }
         }
@@ -3489,8 +3489,8 @@
       SplitBBTerm->setOperand(0, FalseI1);

       LLVM_DEBUG(dbgs() << "preloading invariant loads failed in function: " +
-                               S->getFunction().getName() + " | Scop Region: " +
-                               S->getNameStr());
+                               S->getFunction().getName() +
+                               " | Scop Region: " + S->getNameStr());
       // adjust the dominator tree accordingly.
       auto *ExitingBlock = StartBlock->getUniqueSuccessor();
       assert(ExitingBlock);

You can run ninja polly-update-format to apply automatically fix the formatting.

LLVM patch has not yet landed, so I did not test whether it compiles.

Otherwise, LGTM.

[Nicola]

Updated diff with the latest clang-format. Thanks!

[Meinersbur]

The patch doesn't apply cleanly anymore, but generally LGTM after r332240

lib/Analysis/DependenceInfo.cpp

 
   AI = isl_union_access_info_from_sink(isl_union_map_copy(Snk));
   if (MaySrc)
     AI = isl_union_access_info_set_may_source(AI, isl_union_map_copy(MaySrc));
   if (Src)
     AI = isl_union_access_info_set_must_source(AI, isl_union_map_copy(Src));
   AI = isl_union_access_info_set_schedule(AI, isl_schedule_copy(Schedule));
   auto Flow = isl_union_access_info_compute_flow(AI);
-  DEBUG(if (!Flow) dbgs() << "last error: "
-                          << isl_ctx_last_error(isl_schedule_get_ctx(Schedule))
-                          << '\n';);
+  LLVM_DEBUG(if (!Flow) dbgs()
+                 << "last error: "
+                 << isl_ctx_last_error(isl_schedule_get_ctx(Schedule))
+                 << '\n';);
   return Flow;
 }
 
 /// Compute exact WAR dependences
 /// We need exact WAR dependences. That is, if there are
 /// dependences of the form:
 /// must-W2 (sink) <- must-W1 (sink) <- R (source)
 /// We wish to generate *ONLY*:

   return WAR;
 }
 
 void Dependences::calculateDependences(Scop &S) {
   isl_union_map *Read, *MustWrite, *MayWrite, *ReductionTagMap;
   isl_schedule *Schedule;
   isl_union_set *TaggedStmtDomain;
 
-  DEBUG(dbgs() << "Scop: \n" << S << "\n");
+  LLVM_DEBUG(dbgs() << "Scop: \n" << S << "\n");
 
   collectInfo(S, Read, MustWrite, MayWrite, ReductionTagMap, TaggedStmtDomain,
               Level);
 
   bool HasReductions = !isl_union_map_is_empty(ReductionTagMap);
 
-  DEBUG(dbgs() << "Read: " << Read << '\n';
+  LLVM_DEBUG(dbgs() << "Read: " << Read << '\n';
              dbgs() << "MustWrite: " << MustWrite << '\n';
              dbgs() << "MayWrite: " << MayWrite << '\n';
              dbgs() << "ReductionTagMap: " << ReductionTagMap << '\n';
              dbgs() << "TaggedStmtDomain: " << TaggedStmtDomain << '\n';);
 
   Schedule = S.getScheduleTree().release();
 
   if (!HasReductions) {
     isl_union_map_free(ReductionTagMap);
     // Tag the schedule tree if we want fine-grain dependence info
     if (Level > AL_Statement) {
       auto TaggedMap =

     Tags = isl_union_pw_multi_aff_union_add(ReductionTags, IdentityTags);
 
     // By pulling back Tags from Schedule, we have a schedule tree that can
     // be used to compute normal dependences, as well as 'tagged' reduction
     // dependences.
     Schedule = isl_schedule_pullback_union_pw_multi_aff(Schedule, Tags);
   }
 
-  DEBUG(dbgs() << "Read: " << Read << "\n";
+  LLVM_DEBUG(dbgs() << "Read: " << Read << "\n";
              dbgs() << "MustWrite: " << MustWrite << "\n";
              dbgs() << "MayWrite: " << MayWrite << "\n";
              dbgs() << "Schedule: " << Schedule << "\n");
 
   isl_union_map *StrictWAW = nullptr;
   {
     IslMaxOperationsGuard MaxOpGuard(IslCtx.get(), OptComputeOut);
 
     RAW = WAW = WAR = RED = nullptr;
     isl_union_map *Write = isl_union_map_union(isl_union_map_copy(MustWrite),
                                                isl_union_map_copy(MayWrite));

 
   isl_union_map *STMT_RAW, *STMT_WAW, *STMT_WAR;
   STMT_RAW = isl_union_map_intersect_domain(
       isl_union_map_copy(RAW), isl_union_set_copy(TaggedStmtDomain));
   STMT_WAW = isl_union_map_intersect_domain(
       isl_union_map_copy(WAW), isl_union_set_copy(TaggedStmtDomain));
   STMT_WAR =
       isl_union_map_intersect_domain(isl_union_map_copy(WAR), TaggedStmtDomain);
-  DEBUG({
+  LLVM_DEBUG({
     dbgs() << "Wrapped Dependences:\n";
     dump();
     dbgs() << "\n";
   });
 
   // To handle reduction dependences we proceed as follows:
   // 1) Aggregate all possible reduction dependences, namely all self
   //    dependences on reduction like statements.

     RAW = isl_union_map_subtract(RAW, isl_union_map_copy(RED));
     WAW = isl_union_map_subtract(WAW, isl_union_map_copy(RED));
     WAR = isl_union_map_subtract(WAR, isl_union_map_copy(RED));
 
     // Step 4)
     addPrivatizationDependences();
   }
 
-  DEBUG({
+  LLVM_DEBUG({
     dbgs() << "Final Wrapped Dependences:\n";
     dump();
     dbgs() << "\n";
   });
 
   // RED_SIN is used to collect all reduction dependences again after we
   // split them according to the causing memory accesses. The current assumption
   // is that our method of splitting will not have any leftovers. In the end

   isl_union_map_free(RED_SIN);
 
   RAW = isl_union_map_zip(RAW);
   WAW = isl_union_map_zip(WAW);
   WAR = isl_union_map_zip(WAR);
   RED = isl_union_map_zip(RED);
   TC_RED = isl_union_map_zip(TC_RED);
 
-  DEBUG({
+  LLVM_DEBUG({
     dbgs() << "Zipped Dependences:\n";
     dump();
     dbgs() << "\n";
   });
 
   RAW = isl_union_set_unwrap(isl_union_map_domain(RAW));
   WAW = isl_union_set_unwrap(isl_union_map_domain(WAW));
   WAR = isl_union_set_unwrap(isl_union_map_domain(WAR));
   RED = isl_union_set_unwrap(isl_union_map_domain(RED));
   TC_RED = isl_union_set_unwrap(isl_union_map_domain(TC_RED));
 
-  DEBUG({
+  LLVM_DEBUG({
     dbgs() << "Unwrapped Dependences:\n";
     dump();
     dbgs() << "\n";
   });
 
   RAW = isl_union_map_union(RAW, STMT_RAW);
   WAW = isl_union_map_union(WAW, STMT_WAW);
   WAR = isl_union_map_union(WAR, STMT_WAR);
 
   RAW = isl_union_map_coalesce(RAW);
   WAW = isl_union_map_coalesce(WAW);
   WAR = isl_union_map_coalesce(WAR);
   RED = isl_union_map_coalesce(RED);
   TC_RED = isl_union_map_coalesce(TC_RED);
 
-  DEBUG(dump());
+  LLVM_DEBUG(dump());
 }
 
 bool Dependences::isValidSchedule(Scop &S,
                                   StatementToIslMapTy *NewSchedule) const {
   if (LegalityCheckDisabled)
     return true;
 
   isl_union_map *Dependences = getDependences(TYPE_RAW | TYPE_WAW | TYPE_WAR);

lib/Analysis/PolyhedralInfo.cpp

   bool IsParallel;
   const Scop *S = getScopContainingLoop(L);
   if (!S)
     return false;
   const Dependences &D =
       DI->getDependences(const_cast<Scop *>(S), Dependences::AL_Access);
   if (!D.hasValidDependences())
     return false;
-  DEBUG(dbgs() << "Loop :\t" << L->getHeader()->getName() << ":\n");
+  LLVM_DEBUG(dbgs() << "Loop :\t" << L->getHeader()->getName() << ":\n");
 
   isl_union_map *Deps =
       D.getDependences(Dependences::TYPE_RAW | Dependences::TYPE_WAW |
                        Dependences::TYPE_WAR | Dependences::TYPE_RED);
-  DEBUG(dbgs() << "Dependences :\t" << stringFromIslObj(Deps) << "\n");
+  LLVM_DEBUG(dbgs() << "Dependences :\t" << stringFromIslObj(Deps) << "\n");
 
   isl_union_map *Schedule = getScheduleForLoop(S, L);
-  DEBUG(dbgs() << "Schedule: \t" << stringFromIslObj(Schedule) << "\n");
+  LLVM_DEBUG(dbgs() << "Schedule: \t" << stringFromIslObj(Schedule) << "\n");
 
   IsParallel = D.isParallel(Schedule, Deps, MinDepDistPtr);
   isl_union_map_free(Schedule);
   return IsParallel;
 }
 
 bool PolyhedralInfo::isParallel(Loop *L) const { return checkParallel(L); }
 

 //  The schedule for the outer loop will be
 //    Stmt[i0, i1] -> [i0]
 //  The schedule for the inner loop will be
 //    Stmt[i0, i1] -> [i0, i1]
 __isl_give isl_union_map *PolyhedralInfo::getScheduleForLoop(const Scop *S,
                                                              Loop *L) const {
   isl_union_map *Schedule = isl_union_map_empty(S->getParamSpace().release());
   int CurrDim = S->getRelativeLoopDepth(L);
-  DEBUG(dbgs() << "Relative loop depth:\t" << CurrDim << "\n");
+  LLVM_DEBUG(dbgs() << "Relative loop depth:\t" << CurrDim << "\n");
   assert(CurrDim >= 0 && "Loop in region should have at least depth one");
 
   for (auto &SS : *S) {
     if (L->contains(SS.getSurroundingLoop())) {
 
       unsigned int MaxDim = SS.getNumIterators();
-      DEBUG(dbgs() << "Maximum depth of Stmt:\t" << MaxDim << "\n");
+      LLVM_DEBUG(dbgs() << "Maximum depth of Stmt:\t" << MaxDim << "\n");
       isl_map *ScheduleMap = SS.getSchedule().release();
       assert(
           ScheduleMap &&
           "Schedules that contain extension nodes require special handling.");
 
       ScheduleMap = isl_map_project_out(ScheduleMap, isl_dim_out, CurrDim + 1,
                                         MaxDim - CurrDim - 1);
       ScheduleMap = isl_map_set_tuple_id(ScheduleMap, isl_dim_in,

lib/Analysis/PruneUnprofitable.cpp

 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<ScopInfoRegionPass>();
     AU.setPreservesAll();
   }
 
   bool runOnScop(Scop &S) override {
     if (PollyProcessUnprofitable) {
-      DEBUG(dbgs() << "NOTE: -polly-process-unprofitable active, won't prune "
-                      "anything\n");
+      LLVM_DEBUG(
+          dbgs() << "NOTE: -polly-process-unprofitable active, won't prune "
+                    "anything\n");
       return false;
     }
 
     ScopsProcessed++;
 
     if (!S.isProfitable(true)) {
-      DEBUG(dbgs() << "SCoP pruned because it probably cannot be optimized in "
-                      "a significant way\n");
+      LLVM_DEBUG(
+          dbgs() << "SCoP pruned because it probably cannot be optimized in "
+                    "a significant way\n");
       S.invalidate(PROFITABLE, DebugLoc());
       updateStatistics(S, true);
     } else {
       updateStatistics(S, false);
     }
 
     return false;
   }

lib/Analysis/ScopBuilder.cpp

   }
 
   scop->buildInvariantEquivalenceClasses();
 
   /// A map from basic blocks to their invalid domains.
   DenseMap<BasicBlock *, isl::set> InvalidDomainMap;
 
   if (!scop->buildDomains(&R, DT, LI, InvalidDomainMap)) {
-    DEBUG(dbgs() << "Bailing-out because buildDomains encountered problems\n");
+    LLVM_DEBUG(
+        dbgs() << "Bailing-out because buildDomains encountered problems\n");
     return;
   }
 
   scop->addUserAssumptions(AC, DT, LI, InvalidDomainMap);
 
   // Initialize the invalid domain.
   for (ScopStmt &Stmt : scop->Stmts)
     if (Stmt.isBlockStmt())
       Stmt.setInvalidDomain(InvalidDomainMap[Stmt.getEntryBlock()]);
     else
       Stmt.setInvalidDomain(InvalidDomainMap[getRegionNodeBasicBlock(
           Stmt.getRegion()->getNode())]);
 
   // Remove empty statements.
   // Exit early in case there are no executable statements left in this scop.
   scop->removeStmtNotInDomainMap();
   scop->simplifySCoP(false);
   if (scop->isEmpty()) {
-    DEBUG(dbgs() << "Bailing-out because SCoP is empty\n");
+    LLVM_DEBUG(dbgs() << "Bailing-out because SCoP is empty\n");
     return;
   }
 
   // The ScopStmts now have enough information to initialize themselves.
   for (ScopStmt &Stmt : *scop) {
     buildDomain(Stmt);
     collectSurroundingLoops(Stmt);
     buildAccessRelations(Stmt);
 
     if (DetectReductions)
       checkForReductions(Stmt);
   }
 
   // Check early for a feasible runtime context.
   if (!scop->hasFeasibleRuntimeContext()) {
-    DEBUG(dbgs() << "Bailing-out because of unfeasible context (early)\n");
+    LLVM_DEBUG(dbgs() << "Bailing-out because of unfeasible context (early)\n");
     return;
   }
 
   // Check early for profitability. Afterwards it cannot change anymore,
   // only the runtime context could become infeasible.
   if (!scop->isProfitable(UnprofitableScalarAccs)) {
     scop->invalidate(PROFITABLE, DebugLoc());
-    DEBUG(dbgs() << "Bailing-out because SCoP is not considered profitable\n");
+    LLVM_DEBUG(
+        dbgs() << "Bailing-out because SCoP is not considered profitable\n");
     return;
   }
 
   scop->buildSchedule(LI);
 
   scop->finalizeAccesses();
 
   scop->realignParams();
   scop->addUserContext();
 
   // After the context was fully constructed, thus all our knowledge about
   // the parameters is in there, we add all recorded assumptions to the
   // assumed/invalid context.
   scop->addRecordedAssumptions();
 
   scop->simplifyContexts();
   if (!scop->buildAliasChecks(AA)) {
-    DEBUG(dbgs() << "Bailing-out because could not build alias checks\n");
+    LLVM_DEBUG(dbgs() << "Bailing-out because could not build alias checks\n");
     return;
   }
 
   scop->hoistInvariantLoads();
   scop->canonicalizeDynamicBasePtrs();
   scop->verifyInvariantLoads();
   scop->simplifySCoP(true);
 
   // Check late for a feasible runtime context because profitability did not
   // change.
   if (!scop->hasFeasibleRuntimeContext()) {
-    DEBUG(dbgs() << "Bailing-out because of unfeasible context (late)\n");
+    LLVM_DEBUG(dbgs() << "Bailing-out because of unfeasible context (late)\n");
     return;
   }
 
 #ifndef NDEBUG
   verifyUses(scop.get(), LI, DT);
 #endif
 }
 
 ScopBuilder::ScopBuilder(Region *R, AssumptionCache &AC, AliasAnalysis &AA,
                          const DataLayout &DL, DominatorTree &DT, LoopInfo &LI,
                          ScopDetection &SD, ScalarEvolution &SE,
                          OptimizationRemarkEmitter &ORE)
     : AA(AA), DL(DL), DT(DT), LI(LI), SD(SD), SE(SE) {
   DebugLoc Beg, End;
   auto P = getBBPairForRegion(R);
   getDebugLocations(P, Beg, End);
 
   std::string Msg = "SCoP begins here.";
   ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "ScopEntry", Beg, P.first)
            << Msg);
 
   buildScop(*R, AC, ORE);
 
-  DEBUG(dbgs() << *scop);
+  LLVM_DEBUG(dbgs() << *scop);
 
   if (!scop->hasFeasibleRuntimeContext()) {
     InfeasibleScops++;
     Msg = "SCoP ends here but was dismissed.";
-    DEBUG(dbgs() << "SCoP detected but dismissed\n");
+    LLVM_DEBUG(dbgs() << "SCoP detected but dismissed\n");
     scop.reset();
   } else {
     Msg = "SCoP ends here.";
     ++ScopFound;
     if (scop->getMaxLoopDepth() > 0)
       ++RichScopFound;
   }
 
   if (R->isTopLevelRegion())
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "ScopEnd", End, P.first)
              << Msg);
   else
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "ScopEnd", End, P.second)
              << Msg);
 }

lib/Analysis/ScopDetection.cpp

                                    Args &&... Arguments) const {
   if (!Context.Verifying) {
     RejectLog &Log = Context.Log;
     std::shared_ptr<RR> RejectReason = std::make_shared<RR>(Arguments...);
 
     if (PollyTrackFailures)
       Log.report(RejectReason);
 
-    DEBUG(dbgs() << RejectReason->getMessage());
-    DEBUG(dbgs() << "\n");
+    LLVM_DEBUG(dbgs() << RejectReason->getMessage());
+    LLVM_DEBUG(dbgs() << "\n");
   } else {
     assert(!Assert && "Verification of detected scop failed");
   }
 
   return false;
 }
 
 bool ScopDetection::isMaxRegionInScop(const Region &R, bool Verify) const {

   return {LoopNum, MaxLoopDepth};
 }
 
 Region *ScopDetection::expandRegion(Region &R) {
   // Initial no valid region was found (greater than R)
   std::unique_ptr<Region> LastValidRegion;
   auto ExpandedRegion = std::unique_ptr<Region>(R.getExpandedRegion());
 
-  DEBUG(dbgs() << "\tExpanding " << R.getNameStr() << "\n");
+  LLVM_DEBUG(dbgs() << "\tExpanding " << R.getNameStr() << "\n");
 
   while (ExpandedRegion) {
     const auto &It = DetectionContextMap.insert(std::make_pair(
         getBBPairForRegion(ExpandedRegion.get()),
         DetectionContext(*ExpandedRegion, AA, false /*verifying*/)));
     DetectionContext &Context = It.first->second;
-    DEBUG(dbgs() << "\t\tTrying " << ExpandedRegion->getNameStr() << "\n");
+    LLVM_DEBUG(dbgs() << "\t\tTrying " << ExpandedRegion->getNameStr() << "\n");
     // Only expand when we did not collect errors.
 
     if (!Context.Log.hasErrors()) {
       // If the exit is valid check all blocks
       //  - if true, a valid region was found => store it + keep expanding
       //  - if false, .tbd. => stop  (should this really end the loop?)
       if (!allBlocksValid(Context) || Context.Log.hasErrors()) {
         removeCachedResults(*ExpandedRegion);

       // Create and test the next greater region (if any)
       removeCachedResults(*ExpandedRegion);
       DetectionContextMap.erase(It.first);
       ExpandedRegion =
           std::unique_ptr<Region>(ExpandedRegion->getExpandedRegion());
     }
   }
 
-  DEBUG({
+  LLVM_DEBUG({
     if (LastValidRegion)
       dbgs() << "\tto " << LastValidRegion->getNameStr() << "\n";
     else
       dbgs() << "\tExpanding " << R.getNameStr() << " failed\n";
   });
 
   return LastValidRegion.release();
 }

     return true;
 
   return invalid<ReportUnprofitable>(Context, /*Assert=*/true, &CurRegion);
 }
 
 bool ScopDetection::isValidRegion(DetectionContext &Context) const {
   Region &CurRegion = Context.CurRegion;
 
-  DEBUG(dbgs() << "Checking region: " << CurRegion.getNameStr() << "\n\t");
+  LLVM_DEBUG(dbgs() << "Checking region: " << CurRegion.getNameStr() << "\n\t");
 
   if (!PollyAllowFullFunction && CurRegion.isTopLevelRegion()) {
-    DEBUG(dbgs() << "Top level region is invalid\n");
+    LLVM_DEBUG(dbgs() << "Top level region is invalid\n");
     return false;
   }
 
   DebugLoc DbgLoc;
   if (CurRegion.getExit() &&
       isa<UnreachableInst>(CurRegion.getExit()->getTerminator())) {
-    DEBUG(dbgs() << "Unreachable in exit\n");
+    LLVM_DEBUG(dbgs() << "Unreachable in exit\n");
     return invalid<ReportUnreachableInExit>(Context, /*Assert=*/true,
                                             CurRegion.getExit(), DbgLoc);
   }
 
   if (!CurRegion.getEntry()->getName().count(OnlyRegion)) {
-    DEBUG({
+    LLVM_DEBUG({
       dbgs() << "Region entry does not match -polly-region-only";
       dbgs() << "\n";
     });
     return false;
   }
 
   // SCoP cannot contain the entry block of the function, because we need
   // to insert alloca instruction there when translate scalar to array.
   if (!PollyAllowFullFunction &&
       CurRegion.getEntry() ==
           &(CurRegion.getEntry()->getParent()->getEntryBlock()))
     return invalid<ReportEntry>(Context, /*Assert=*/true, CurRegion.getEntry());
 
   if (!allBlocksValid(Context))
     return false;
 
   if (!isReducibleRegion(CurRegion, DbgLoc))
     return invalid<ReportIrreducibleRegion>(Context, /*Assert=*/true,
                                             &CurRegion, DbgLoc);
 
-  DEBUG(dbgs() << "OK\n");
+  LLVM_DEBUG(dbgs() << "OK\n");
   return true;
 }
 
 void ScopDetection::markFunctionAsInvalid(Function *F) {
   F->addFnAttr(PollySkipFnAttr);
 }
 
 bool ScopDetection::isValidFunction(Function &F) {

lib/Analysis/ScopInfo.cpp

     return true;
   }
 
   // If a problem occurs while building the alias groups we need to delete
   // this SCoP and pretend it wasn't valid in the first place. To this end
   // we make the assumed context infeasible.
   invalidate(ALIASING, DebugLoc());
 
-  DEBUG(dbgs() << "\n\nNOTE: Run time checks for " << getNameStr()
-               << " could not be created as the number of parameters involved "
-                  "is too high. The SCoP will be "
-                  "dismissed.\nUse:\n\t--polly-rtc-max-parameters=X\nto adjust "
-                  "the maximal number of parameters but be advised that the "
-                  "compile time might increase exponentially.\n\n");
+  LLVM_DEBUG(
+      dbgs() << "\n\nNOTE: Run time checks for " << getNameStr()
+             << " could not be created as the number of parameters involved "
+                "is too high. The SCoP will be "
+                "dismissed.\nUse:\n\t--polly-rtc-max-parameters=X\nto adjust "
+                "the maximal number of parameters but be advised that the "
+                "compile time might increase exponentially.\n\n");
   return false;
 }
 
 std::tuple<Scop::AliasGroupVectorTy, DenseSet<const ScopArrayInfo *>>
 Scop::buildAliasGroupsForAccesses(AliasAnalysis &AA) {
   AliasSetTracker AST(AA);
 
   DenseMap<Value *, MemoryAccess *> PtrToAcc;

     else /* (AS.Sign == AS_ASSUMPTION) */
       S = isl_set_params(isl_set_subtract(Dom, S));
 
     addAssumption(AS.Kind, isl::manage(S), AS.Loc, AS_RESTRICTION, AS.BB);
   }
 }
 
 void Scop::invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB) {
-  DEBUG(dbgs() << "Invalidate SCoP because of reason " << Kind << "\n");
+  LLVM_DEBUG(dbgs() << "Invalidate SCoP because of reason " << Kind << "\n");
   addAssumption(Kind, isl::set::empty(getParamSpace()), Loc, AS_ASSUMPTION, BB);
 }
 
 isl::set Scop::getInvalidContext() const { return InvalidContext; }
 
 void Scop::printContext(raw_ostream &OS) const {
   OS << "Context:\n";
   OS.indent(4) << Context << "\n";

lib/CodeGen/CodeGeneration.cpp

   OrigTerminator->eraseFromParent();
 }
 } // namespace polly
 
 static void verifyGeneratedFunction(Scop &S, Function &F, IslAstInfo &AI) {
   if (!Verify || !verifyFunction(F, &errs()))
     return;
 
-  DEBUG({
+  LLVM_DEBUG({
     errs() << "== ISL Codegen created an invalid function ==\n\n== The "
               "SCoP ==\n";
     errs() << S;
     errs() << "\n== The isl AST ==\n";
     AI.print(errs());
     errs() << "\n== The invalid function ==\n";
     F.print(errs());
   });

   // Instead, we compare the address of the isl_ctx object. Both, DependenceInfo
   // and IslAstInfo must hold a reference to the isl_ctx object to ensure it is
   // not freed before the destruction of those analyses which might happen after
   // the destruction of the Scop/ScopInfo they refer to.  Hence, the isl_ctx
   // will not be freed and its space not reused as long there is a
   // DependenceInfo or IslAstInfo around.
   IslAst &Ast = AI.getIslAst();
   if (Ast.getSharedIslCtx() != S.getSharedIslCtx()) {
-    DEBUG(dbgs() << "Got an IstAst for a different Scop/isl_ctx\n");
+    LLVM_DEBUG(dbgs() << "Got an IstAst for a different Scop/isl_ctx\n");
     return false;
   }
 
   // Check if we created an isl_ast root node, otherwise exit.
   isl_ast_node *AstRoot = Ast.getAst();
   if (!AstRoot)
     return false;
 

lib/CodeGen/CodegenCleanup.cpp

     delete FPM;
     FPM = nullptr;
 
     return Result;
   }
 
   virtual bool runOnFunction(llvm::Function &F) override {
     if (!F.hasFnAttribute("polly-optimized")) {
-      DEBUG(dbgs() << F.getName()
-                   << ": Skipping cleanup because Polly did not optimize it.");
+      LLVM_DEBUG(
+          dbgs() << F.getName()
+                 << ": Skipping cleanup because Polly did not optimize it.");
       return false;
     }
 
-    DEBUG(dbgs() << F.getName() << ": Running codegen cleanup...");
+    LLVM_DEBUG(dbgs() << F.getName() << ": Running codegen cleanup...");
     return FPM->run(F);
   }
   //@}
 };
 
 char CodegenCleanup::ID;
 } // namespace
 
 FunctionPass *polly::createCodegenCleanupPass() { return new CodegenCleanup(); }
 
 INITIALIZE_PASS_BEGIN(CodegenCleanup, "polly-cleanup",
                       "Polly - Cleanup after code generation", false, false)
 INITIALIZE_PASS_END(CodegenCleanup, "polly-cleanup",
                     "Polly - Cleanup after code generation", false, false)

lib/CodeGen/IslAst.cpp

   RtCStr = isl_printer_get_str(P);
   P = isl_printer_flush(P);
   P = isl_printer_indent(P, 4);
   P = isl_ast_node_print(RootNode, P, Options);
   AstStr = isl_printer_get_str(P);
 
   auto *Schedule = S.getScheduleTree().release();
 
-  DEBUG({
+  LLVM_DEBUG({
     dbgs() << S.getContextStr() << "\n";
     dbgs() << stringFromIslObj(Schedule);
   });
   OS << "\nif (" << RtCStr << ")\n\n";
   OS << AstStr << "\n";
   OS << "else\n";
   OS << "    {  /* original code */ }\n\n";
 

     return false;
 
   ScopsProcessed++;
 
   const Dependences &D =
       getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
 
   if (D.getSharedIslCtx() != Scop.getSharedIslCtx()) {
-    DEBUG(dbgs() << "Got dependence analysis for different SCoP/isl_ctx\n");
+    LLVM_DEBUG(
+        dbgs() << "Got dependence analysis for different SCoP/isl_ctx\n");
     Ast.reset();
     return false;
   }
 
   Ast.reset(new IslAstInfo(Scop, D));
 
-  DEBUG(printScop(dbgs(), Scop));
+  LLVM_DEBUG(printScop(dbgs(), Scop));
   return false;
 }
 
 void IslAstInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   // Get the Common analysis usage of ScopPasses.
   ScopPass::getAnalysisUsage(AU);
   AU.addRequiredTransitive<ScopInfoRegionPass>();
   AU.addRequired<DependenceInfo>();

lib/CodeGen/ManagedMemoryRewrite.cpp

 // already expanded.
 static void expandConstantExpr(ConstantExpr *Cur, PollyIRBuilder &Builder,
                                Instruction *Parent, int index,
                                SmallPtrSet<Instruction *, 4> &Expands) {
   assert(Cur && "invalid constant expression passed");
   Instruction *I = Cur->getAsInstruction();
   assert(I && "unable to convert ConstantExpr to Instruction");
 
-  DEBUG(dbgs() << "Expanding ConstantExpression: (" << *Cur
+  LLVM_DEBUG(dbgs() << "Expanding ConstantExpression: (" << *Cur
                     << ") in Instruction: (" << *I << ")\n";);
 
   // Invalidate `Cur` so that no one after this point uses `Cur`. Rather,
   // they should mutate `I`.
   Cur = nullptr;
 
   Expands.insert(I);
   Parent->setOperand(index, I);
 

 
   // We only wish to replace arrays that are visible in the module they
   // inhabit. Otherwise, our type edit from [T] to T* would be illegal across
   // modules.
   const bool OnlyVisibleInsideModule = Array.hasPrivateLinkage() ||
                                        Array.hasInternalLinkage() ||
                                        IgnoreLinkageForGlobals;
   if (!OnlyVisibleInsideModule) {
-    DEBUG(dbgs() << "Not rewriting (" << Array
-                 << ") to managed memory "
-                    "because it could be visible externally. To force rewrite, "
-                    "use -polly-acc-rewrite-ignore-linkage-for-globals.\n");
+    LLVM_DEBUG(
+        dbgs() << "Not rewriting (" << Array
+               << ") to managed memory "
+                  "because it could be visible externally. To force rewrite, "
+                  "use -polly-acc-rewrite-ignore-linkage-for-globals.\n");
     return;
   }
 
   if (!Array.hasInitializer() ||
       !isa<ConstantAggregateZero>(Array.getInitializer())) {
-    DEBUG(dbgs() << "Not rewriting (" << Array
+    LLVM_DEBUG(dbgs() << "Not rewriting (" << Array
                       << ") to managed memory "
                          "because it has an initializer which is "
                          "not a zeroinitializer.\n");
     return;
   }
 
   // At this point, we have committed to replacing this array.
   ReplacedGlobals.insert(&Array);
 
   std::string NewName = Array.getName();
   NewName += ".toptr";

 // cudaMallocManaged.
 static void getAllocasToBeManaged(Function &F,
                                   SmallSet<AllocaInst *, 4> &Allocas) {
   for (BasicBlock &BB : F) {
     for (Instruction &I : BB) {
       auto *Alloca = dyn_cast<AllocaInst>(&I);
       if (!Alloca)
         continue;
-      DEBUG(dbgs() << "Checking if (" << *Alloca << ") may be captured: ");
+      LLVM_DEBUG(dbgs() << "Checking if (" << *Alloca << ") may be captured: ");
 
       if (PointerMayBeCaptured(Alloca, /* ReturnCaptures */ false,
                                /* StoreCaptures */ true)) {
         Allocas.insert(Alloca);
-        DEBUG(dbgs() << "YES (captured).\n");
+        LLVM_DEBUG(dbgs() << "YES (captured).\n");
       } else {
-        DEBUG(dbgs() << "NO (not captured).\n");
+        LLVM_DEBUG(dbgs() << "NO (not captured).\n");
       }
     }
   }
 }
 
 static void rewriteAllocaAsManagedMemory(AllocaInst *Alloca,
                                          const DataLayout &DL) {
-  DEBUG(dbgs() << "rewriting: (" << *Alloca << ") to managed mem.\n");
+  LLVM_DEBUG(dbgs() << "rewriting: (" << *Alloca << ") to managed mem.\n");
   Module *M = Alloca->getModule();
   assert(M && "Alloca does not have a module");
 
   PollyIRBuilder Builder(M->getContext());
   Builder.SetInsertPoint(Alloca);
 
   Value *MallocManagedFn = getOrCreatePollyMallocManaged(*Alloca->getModule());
   const uint64_t Size =

lib/CodeGen/PPCGCodeGeneration.cpp

 
   if (StoredScalar) {
     /// In case more than one thread contains scalar stores, the generated
     /// code might be incorrect, if we only store at the end of the kernel.
     /// To support this case we need to store these scalars back at each
     /// memory store or at least before each kernel barrier.
     if (Kernel->n_block != 0 || Kernel->n_grid != 0) {
       BuildSuccessful = 0;
-      DEBUG(
+      LLVM_DEBUG(
           dbgs() << getUniqueScopName(&S)
                  << " has a store to a scalar value that"
                     " would be undefined to run in parallel. Bailing out.\n";);
     }
   }
 }
 
 void GPUNodeBuilder::createKernelVariables(ppcg_kernel *Kernel, Function *FN) {

     LibDeviceModule->setTargetTriple(Triple::normalize("nvptx64-nvidia-cuda"));
     L.linkInModule(std::move(LibDeviceModule), Linker::LinkOnlyNeeded);
   }
 }
 
 std::string GPUNodeBuilder::finalizeKernelFunction() {
 
   if (verifyModule(*GPUModule)) {
-    DEBUG(dbgs() << "verifyModule failed on module:\n";
+    LLVM_DEBUG(dbgs() << "verifyModule failed on module:\n";
                GPUModule->print(dbgs(), nullptr); dbgs() << "\n";);
-    DEBUG(dbgs() << "verifyModule Error:\n";
+    LLVM_DEBUG(dbgs() << "verifyModule Error:\n";
                verifyModule(*GPUModule, &dbgs()););
 
     if (FailOnVerifyModuleFailure)
       llvm_unreachable("VerifyModule failed.");
 
     BuildSuccessful = false;
     return "";
   }
 

 
     int has_permutable = has_any_permutable_node(Schedule);
 
     Schedule =
         isl_schedule_align_params(Schedule, S->getFullParamSpace().release());
 
     if (!has_permutable || has_permutable < 0) {
       Schedule = isl_schedule_free(Schedule);
-      DEBUG(dbgs() << getUniqueScopName(S)
+      LLVM_DEBUG(dbgs() << getUniqueScopName(S)
                         << " does not have permutable bands. Bailing out\n";);
     } else {
       const bool CreateTransferToFromDevice = !PollyManagedMemory;
       Schedule = map_to_device(PPCGGen, Schedule, CreateTransferToFromDevice);
       PPCGGen->tree = generate_code(PPCGGen, isl_schedule_copy(Schedule));
     }
 
     if (DumpSchedule) {
       isl_printer *P = isl_printer_to_str(S->getIslCtx().get());

       if (Call && isValidFunctionInKernel(Call->getCalledFunction(),
                                           AllowCUDALibDevice))
         continue;
 
       for (Value *Op : Inst.operands())
         // Look for (<func-type>*) among operands of Inst
         if (auto PtrTy = dyn_cast<PointerType>(Op->getType())) {
           if (isa<FunctionType>(PtrTy->getElementType())) {
-            DEBUG(dbgs() << Inst
+            LLVM_DEBUG(dbgs() << Inst
                               << " has illegal use of function in kernel.\n");
             return true;
           }
         }
     }
     return false;
   }
 
   /// Return whether the Scop S uses functions in a way that we do not support.

     // because the RTC may depend on values that are invariant load hoisted.
     if (!NodeBuilder.preloadInvariantLoads()) {
       // Patch the introduced branch condition to ensure that we always execute
       // the original SCoP.
       auto *FalseI1 = Builder.getFalse();
       auto *SplitBBTerm = Builder.GetInsertBlock()->getTerminator();
       SplitBBTerm->setOperand(0, FalseI1);
 
-      DEBUG(dbgs() << "preloading invariant loads failed in function: " +
-                          S->getFunction().getName() +
-                          " | Scop Region: " + S->getNameStr());
+      LLVM_DEBUG(dbgs() << "preloading invariant loads failed in function: " +
+                               S->getFunction().getName() + " | Scop Region: " +
+                               S->getNameStr());
       // adjust the dominator tree accordingly.
       auto *ExitingBlock = StartBlock->getUniqueSuccessor();
       assert(ExitingBlock);
       auto *MergeBlock = ExitingBlock->getUniqueSuccessor();
       assert(MergeBlock);
       polly::markBlockUnreachable(*StartBlock, Builder);
       polly::markBlockUnreachable(*ExitingBlock, Builder);
       auto *ExitingBB = S->getExitingBlock();

   bool runOnScop(Scop &CurrentScop) override {
     S = &CurrentScop;
     LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
     DL = &S->getRegion().getEntry()->getModule()->getDataLayout();
     RI = &getAnalysis<RegionInfoPass>().getRegionInfo();
 
-    DEBUG(dbgs() << "PPCGCodeGen running on : " << getUniqueScopName(S)
+    LLVM_DEBUG(dbgs() << "PPCGCodeGen running on : " << getUniqueScopName(S)
                       << " | loop depth: " << S->getMaxLoopDepth() << "\n");
 
     // We currently do not support functions other than intrinsics inside
     // kernels, as code generation will need to offload function calls to the
     // kernel. This may lead to a kernel trying to call a function on the host.
     // This also allows us to prevent codegen from trying to take the
     // address of an intrinsic function to send to the kernel.
     if (containsInvalidKernelFunction(CurrentScop,
                                       Architecture == GPUArch::NVPTX64)) {
-      DEBUG(
+      LLVM_DEBUG(
           dbgs() << getUniqueScopName(S)
                  << " contains function which cannot be materialised in a GPU "
                     "kernel. Bailing out.\n";);
       return false;
     }
 
     auto PPCGScop = createPPCGScop();
     auto PPCGProg = createPPCGProg(PPCGScop);
     auto PPCGGen = generateGPU(PPCGScop, PPCGProg);
 
     if (PPCGGen->tree) {
       generateCode(isl_ast_node_copy(PPCGGen->tree), PPCGProg);
       CurrentScop.markAsToBeSkipped();
     } else {
-      DEBUG(dbgs() << getUniqueScopName(S)
+      LLVM_DEBUG(dbgs() << getUniqueScopName(S)
                         << " has empty PPCGGen->tree. Bailing out.\n");
     }
 
     freeOptions(PPCGScop);
     freePPCGGen(PPCGGen);
     gpu_prog_free(PPCGProg);
     ppcg_scop_free(PPCGScop);
 
     return true;

lib/Support/DumpModulePass.cpp

     std::string Dumpfile;
     if (IsSuffix) {
       auto ModuleName = M.getName();
       auto Stem = sys::path::stem(ModuleName);
       Dumpfile = (Twine(Stem) + Filename + ".ll").str();
     } else {
       Dumpfile = Filename;
     }
-    DEBUG(dbgs() << "Dumping module to " << Dumpfile << '\n');
+    LLVM_DEBUG(dbgs() << "Dumping module to " << Dumpfile << '\n');
 
     std::unique_ptr<ToolOutputFile> Out;
     std::error_code EC;
     Out.reset(new ToolOutputFile(Dumpfile, EC, sys::fs::F_None));
     if (EC) {
       errs() << EC.message() << '\n';
       return false;
     }

lib/Support/SCEVValidator.cpp

         continue;
 
       if (Op.isPARAM() && Return.isPARAM()) {
         HasMultipleParams = true;
         continue;
       }
 
       if ((Op.isIV() || Op.isPARAM()) && !Return.isINT()) {
-        DEBUG(dbgs() << "INVALID: More than one non-int operand in MulExpr\n"
-                     << "\tExpr: " << *Expr << "\n"
-                     << "\tPrevious expression type: " << Return << "\n"
-                     << "\tNext operand (" << Op
-                     << "): " << *Expr->getOperand(i) << "\n");
+        LLVM_DEBUG(
+            dbgs() << "INVALID: More than one non-int operand in MulExpr\n"
+                   << "\tExpr: " << *Expr << "\n"
+                   << "\tPrevious expression type: " << Return << "\n"
+                   << "\tNext operand (" << Op << "): " << *Expr->getOperand(i)
+                   << "\n");
 
         return ValidatorResult(SCEVType::INVALID);
       }
 
       Return.merge(Op);
     }
 
     if (HasMultipleParams && Return.isValid())
       return ValidatorResult(SCEVType::PARAM, Expr);
 
     return Return;
   }
 
   class ValidatorResult visitAddRecExpr(const SCEVAddRecExpr *Expr) {
     if (!Expr->isAffine()) {
-      DEBUG(dbgs() << "INVALID: AddRec is not affine");
+      LLVM_DEBUG(dbgs() << "INVALID: AddRec is not affine");
       return ValidatorResult(SCEVType::INVALID);
     }
 
     ValidatorResult Start = visit(Expr->getStart());
     ValidatorResult Recurrence = visit(Expr->getStepRecurrence(SE));
 
     if (!Start.isValid())
       return Start;
 
     if (!Recurrence.isValid())
       return Recurrence;
 
     auto *L = Expr->getLoop();
     if (R->contains(L) && (!Scope || !L->contains(Scope))) {
-      DEBUG(dbgs() << "INVALID: Loop of AddRec expression boxed in an a "
-                      "non-affine subregion or has a non-synthesizable exit "
-                      "value.");
+      LLVM_DEBUG(
+          dbgs() << "INVALID: Loop of AddRec expression boxed in an a "
+                    "non-affine subregion or has a non-synthesizable exit "
+                    "value.");
       return ValidatorResult(SCEVType::INVALID);
     }
 
     if (R->contains(L)) {
       if (Recurrence.isINT()) {
         ValidatorResult Result(SCEVType::IV);
         Result.addParamsFrom(Start);
         return Result;
       }
 
-      DEBUG(dbgs() << "INVALID: AddRec within scop has non-int"
+      LLVM_DEBUG(dbgs() << "INVALID: AddRec within scop has non-int"
                            "recurrence part");
       return ValidatorResult(SCEVType::INVALID);
     }
 
     assert(Recurrence.isConstant() && "Expected 'Recurrence' to be constant");
 
     // Directly generate ValidatorResult for Expr if 'start' is zero.
     if (Expr->getStart()->isZero())
       return ValidatorResult(SCEVType::PARAM, Expr);

 
   class ValidatorResult visitUMaxExpr(const SCEVUMaxExpr *Expr) {
     // We do not support unsigned max operations. If 'Expr' is constant during
     // Scop execution we treat this as a parameter, otherwise we bail out.
     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
       ValidatorResult Op = visit(Expr->getOperand(i));
 
       if (!Op.isConstant()) {
-        DEBUG(dbgs() << "INVALID: UMaxExpr has a non-constant operand");
+        LLVM_DEBUG(dbgs() << "INVALID: UMaxExpr has a non-constant operand");
         return ValidatorResult(SCEVType::INVALID);
       }
     }
 
     return ValidatorResult(SCEVType::PARAM, Expr);
   }
 
   ValidatorResult visitGenericInst(Instruction *I, const SCEV *S) {
     if (R->contains(I)) {
-      DEBUG(dbgs() << "INVALID: UnknownExpr references an instruction "
+      LLVM_DEBUG(dbgs() << "INVALID: UnknownExpr references an instruction "
                            "within the region\n");
       return ValidatorResult(SCEVType::INVALID);
     }
 
     return ValidatorResult(SCEVType::PARAM, S);
   }
 
   ValidatorResult visitCallInstruction(Instruction *I, const SCEV *S) {
     assert(I->getOpcode() == Instruction::Call && "Call instruction expected");

     if (SDiv)
       return visitGenericInst(SDiv, DivExpr);
 
     ValidatorResult LHS = visit(Dividend);
     ValidatorResult RHS = visit(Divisor);
     if (LHS.isConstant() && RHS.isConstant())
       return ValidatorResult(SCEVType::PARAM, DivExpr);
 
-    DEBUG(dbgs() << "INVALID: unsigned division of non-constant expressions");
+    LLVM_DEBUG(
+        dbgs() << "INVALID: unsigned division of non-constant expressions");
     return ValidatorResult(SCEVType::INVALID);
   }
 
   ValidatorResult visitUDivExpr(const SCEVUDivExpr *Expr) {
     if (!PollyAllowUnsignedOperations)
       return ValidatorResult(SCEVType::INVALID);
 
     auto *Dividend = Expr->getLHS();

     auto *DividendSCEV = SE.getSCEV(Dividend);
     return visit(DividendSCEV);
   }
 
   ValidatorResult visitUnknown(const SCEVUnknown *Expr) {
     Value *V = Expr->getValue();
 
     if (!Expr->getType()->isIntegerTy() && !Expr->getType()->isPointerTy()) {
-      DEBUG(dbgs() << "INVALID: UnknownExpr is not an integer or pointer");
+      LLVM_DEBUG(dbgs() << "INVALID: UnknownExpr is not an integer or pointer");
       return ValidatorResult(SCEVType::INVALID);
     }
 
     if (isa<UndefValue>(V)) {
-      DEBUG(dbgs() << "INVALID: UnknownExpr references an undef value");
+      LLVM_DEBUG(dbgs() << "INVALID: UnknownExpr references an undef value");
       return ValidatorResult(SCEVType::INVALID);
     }
 
     if (Instruction *I = dyn_cast<Instruction>(Expr->getValue())) {
       switch (I->getOpcode()) {
       case Instruction::IntToPtr:
         return visit(SE.getSCEVAtScope(I->getOperand(0), Scope));
       case Instruction::PtrToInt:

 }
 
 bool isAffineExpr(const Region *R, llvm::Loop *Scope, const SCEV *Expr,
                   ScalarEvolution &SE, InvariantLoadsSetTy *ILS) {
   if (isa<SCEVCouldNotCompute>(Expr))
     return false;
 
   SCEVValidator Validator(R, Scope, SE, ILS);
-  DEBUG({
+  LLVM_DEBUG({
     dbgs() << "\n";
     dbgs() << "Expr: " << *Expr << "\n";
     dbgs() << "Region: " << R->getNameStr() << "\n";
     dbgs() << " -> ";
   });
 
   ValidatorResult Result = Validator.visit(Expr);
 
-  DEBUG({
+  LLVM_DEBUG({
     if (Result.isValid())
       dbgs() << "VALID\n";
     dbgs() << "\n";
   });
 
   return Result.isValid();
 }
 

lib/Transform/DeLICM.cpp

   /// The number of PHIs mapped to some array element.
   int NumberOfMappedPHIScalars = 0;
 
   /// Determine whether two knowledges are conflicting with each other.
   ///
   /// @see Knowledge::isConflicting
   bool isConflicting(const Knowledge &Proposed) {
     raw_ostream *OS = nullptr;
-    DEBUG(OS = &llvm::dbgs());
+    LLVM_DEBUG(OS = &llvm::dbgs());
     return Knowledge::isConflicting(Zone, Proposed, OS, 4);
   }
 
   /// Determine whether @p SAI is a scalar that can be mapped to an array
   /// element.
   bool isMappable(const ScopArrayInfo *SAI) {
     assert(SAI);
 
     if (SAI->isValueKind()) {
       auto *MA = S->getValueDef(SAI);
       if (!MA) {
-        DEBUG(dbgs()
-              << "    Reject because value is read-only within the scop\n");
+        LLVM_DEBUG(
+            dbgs()
+            << "    Reject because value is read-only within the scop\n");
         return false;
       }
 
       // Mapping if value is used after scop is not supported. The code
       // generator would need to reload the scalar after the scop, but it
       // does not have the information to where it is mapped to. Only the
       // MemoryAccesses have that information, not the ScopArrayInfo.
       auto Inst = MA->getAccessInstruction();
       for (auto User : Inst->users()) {
         if (!isa<Instruction>(User))
           return false;
         auto UserInst = cast<Instruction>(User);
 
         if (!S->contains(UserInst)) {
-          DEBUG(dbgs() << "    Reject because value is escaping\n");
+          LLVM_DEBUG(dbgs() << "    Reject because value is escaping\n");
           return false;
         }
       }
 
       return true;
     }
 
     if (SAI->isPHIKind()) {
       auto *MA = S->getPHIRead(SAI);
       assert(MA);
 
       // Mapping of an incoming block from before the SCoP is not supported by
       // the code generator.
       auto PHI = cast<PHINode>(MA->getAccessInstruction());
       for (auto Incoming : PHI->blocks()) {
         if (!S->contains(Incoming)) {
-          DEBUG(dbgs() << "    Reject because at least one incoming block is "
-                          "not in the scop region\n");
+          LLVM_DEBUG(dbgs()
+                     << "    Reject because at least one incoming block is "
+                        "not in the scop region\n");
           return false;
         }
       }
 
       return true;
     }
 
-    DEBUG(dbgs() << "    Reject ExitPHI or other non-value\n");
+    LLVM_DEBUG(dbgs() << "    Reject ExitPHI or other non-value\n");
     return false;
   }
 
   /// Compute the uses of a MemoryKind::Value and its lifetime (from its
   /// definition to the last use).
   ///
   /// @param SAI The ScopArrayInfo representing the value's storage.
   ///

     // { DomainDef[] -> Scatter[] }
     auto DefSched = getScatterFor(DefMA);
 
     // Where each write is mapped to, according to the suggestion.
     // { DomainDef[] -> Element[] }
     auto DefTarget = give(isl_map_apply_domain(
         TargetElt.copy(), isl_map_reverse(DefSched.copy())));
     simplify(DefTarget);
-    DEBUG(dbgs() << "    Def Mapping: " << DefTarget << '\n');
+    LLVM_DEBUG(dbgs() << "    Def Mapping: " << DefTarget << '\n');
 
     auto OrigDomain = getDomainFor(DefMA);
     auto MappedDomain = give(isl_map_domain(DefTarget.copy()));
     if (!isl_set_is_subset(OrigDomain.keep(), MappedDomain.keep())) {
-      DEBUG(dbgs()
-            << "    Reject because mapping does not encompass all instances\n");
+      LLVM_DEBUG(
+          dbgs()
+          << "    Reject because mapping does not encompass all instances\n");
       return false;
     }
 
     // { DomainDef[] -> Zone[] }
     isl::map Lifetime;
 
     // { DomainDef[] -> DomainUse[] }
     isl::union_map DefUses;
 
     std::tie(DefUses, Lifetime) = computeValueUses(SAI);
-    DEBUG(dbgs() << "    Lifetime: " << Lifetime << '\n');
+    LLVM_DEBUG(dbgs() << "    Lifetime: " << Lifetime << '\n');
 
     /// { [Element[] -> Zone[]] }
     auto EltZone = give(
         isl_map_wrap(isl_map_apply_domain(Lifetime.copy(), DefTarget.copy())));
     simplify(EltZone);
 
     // When known knowledge is disabled, just return the unknown value. It will
     // either get filtered out or conflict with itself.

 
     // { DomainRead[] -> Scatter[] }
     auto PHISched = getScatterFor(PHIRead);
 
     // { DomainRead[] -> Element[] }
     auto PHITarget =
         give(isl_map_apply_range(PHISched.copy(), TargetElt.copy()));
     simplify(PHITarget);
-    DEBUG(dbgs() << "    Mapping: " << PHITarget << '\n');
+    LLVM_DEBUG(dbgs() << "    Mapping: " << PHITarget << '\n');
 
     auto OrigDomain = getDomainFor(PHIRead);
     auto MappedDomain = give(isl_map_domain(PHITarget.copy()));
     if (!isl_set_is_subset(OrigDomain.keep(), MappedDomain.keep())) {
-      DEBUG(dbgs()
-            << "    Reject because mapping does not encompass all instances\n");
+      LLVM_DEBUG(
+          dbgs()
+          << "    Reject because mapping does not encompass all instances\n");
       return false;
     }
 
     // { DomainRead[] -> DomainWrite[] }
     auto PerPHIWrites = computePerPHI(SAI);
 
     // { DomainWrite[] -> Element[] }
     auto WritesTarget = give(isl_union_map_reverse(isl_union_map_apply_domain(

     auto RelevantWritesTarget = WritesTarget;
     if (DelicmOverapproximateWrites)
       WritesTarget = expandMapping(WritesTarget, UniverseWritesDom);
 
     auto ExpandedWritesDom = give(isl_union_map_domain(WritesTarget.copy()));
     if (!DelicmPartialWrites &&
         !isl_union_set_is_subset(UniverseWritesDom.keep(),
                                  ExpandedWritesDom.keep())) {
-      DEBUG(dbgs() << "    Reject because did not find PHI write mapping for "
-                      "all instances\n");
+      LLVM_DEBUG(
+          dbgs() << "    Reject because did not find PHI write mapping for "
+                    "all instances\n");
       if (DelicmOverapproximateWrites)
-        DEBUG(dbgs() << "      Relevant Mapping:    " << RelevantWritesTarget
-                     << '\n');
-      DEBUG(dbgs() << "      Deduced Mapping:     " << WritesTarget << '\n');
-      DEBUG(dbgs() << "      Missing instances:    "
-                   << give(isl_union_set_subtract(UniverseWritesDom.copy(),
-                                                  ExpandedWritesDom.copy()))
-                   << '\n');
+        LLVM_DEBUG(dbgs() << "      Relevant Mapping:    "
+                          << RelevantWritesTarget << '\n');
+      LLVM_DEBUG(dbgs() << "      Deduced Mapping:     " << WritesTarget
+                        << '\n');
+      LLVM_DEBUG(
+          dbgs() << "      Missing instances:    "
+                 << give(isl_union_set_subtract(UniverseWritesDom.copy(),
+                                                ExpandedWritesDom.copy()))
+                 << '\n');
       return false;
     }
 
     //  { DomainRead[] -> Scatter[] }
     auto PerPHIWriteScatter = give(isl_map_from_union_map(
         isl_union_map_apply_range(PerPHIWrites.copy(), Schedule.copy())));
 
     // { DomainRead[] -> Zone[] }
     auto Lifetime = betweenScatter(PerPHIWriteScatter, PHISched, false, true);
     simplify(Lifetime);
-    DEBUG(dbgs() << "    Lifetime: " << Lifetime << "\n");
+    LLVM_DEBUG(dbgs() << "    Lifetime: " << Lifetime << "\n");
 
     // { DomainWrite[] -> Zone[] }
     auto WriteLifetime = give(isl_union_map_apply_domain(
         isl_union_map_from_map(Lifetime.copy()), PerPHIWrites.copy()));
 
     // { DomainWrite[] -> ValInst[] }
     auto WrittenValue = determinePHIWrittenValues(SAI);
 

     auto Target =
         computeScalarReachingOverwrite(Schedule, TargetDom, false, true);
 
     // { Zone[] -> Element[] }
     // Use the target store's write location as a suggestion to map scalars to.
     auto EltTarget =
         give(isl_map_apply_range(Target.take(), TargetAccRel.take()));
     simplify(EltTarget);
-    DEBUG(dbgs() << "    Target mapping is " << EltTarget << '\n');
+    LLVM_DEBUG(dbgs() << "    Target mapping is " << EltTarget << '\n');
 
     // Stack of elements not yet processed.
     SmallVector<MemoryAccess *, 16> Worklist;
 
     // Set of scalars already tested.
     SmallPtrSet<const ScopArrayInfo *, 16> Closed;
 
     // Lambda to add all scalar reads to the work list.

 
     while (!Worklist.empty()) {
       auto *MA = Worklist.pop_back_val();
 
       auto *SAI = MA->getScopArrayInfo();
       if (Closed.count(SAI))
         continue;
       Closed.insert(SAI);
-      DEBUG(dbgs() << "\n    Trying to map " << MA << " (SAI: " << SAI
+      LLVM_DEBUG(dbgs() << "\n    Trying to map " << MA << " (SAI: " << SAI
                         << ")\n");
 
       // Skip non-mappable scalars.
       if (!isMappable(SAI))
         continue;
 
       auto MASize = DL.getTypeAllocSize(MA->getAccessValue()->getType());
       if (MASize > StoreSize) {
-        DEBUG(dbgs() << "    Reject because storage size is insufficient\n");
+        LLVM_DEBUG(
+            dbgs() << "    Reject because storage size is insufficient\n");
         continue;
       }
 
       // Try to map MemoryKind::Value scalars.
       if (SAI->isValueKind()) {
         if (!tryMapValue(SAI, EltTarget))
           continue;
 

     }
     DeLICMAnalyzed++;
 
     if (!EltUnused || !EltKnown || !EltWritten) {
       assert(isl_ctx_last_error(IslCtx.get()) == isl_error_quota &&
              "The only reason that these things have not been computed should "
              "be if the max-operations limit hit");
       DeLICMOutOfQuota++;
-      DEBUG(dbgs() << "DeLICM analysis exceeded max_operations\n");
+      LLVM_DEBUG(dbgs() << "DeLICM analysis exceeded max_operations\n");
       DebugLoc Begin, End;
       getDebugLocations(getBBPairForRegion(&S->getRegion()), Begin, End);
       OptimizationRemarkAnalysis R(DEBUG_TYPE, "OutOfQuota", Begin,
                                    S->getEntry());
       R << "maximal number of operations exceeded during zone analysis";
       S->getFunction().getContext().diagnose(R);
       return false;
     }
 
     Zone = OriginalZone = Knowledge(nullptr, EltUnused, EltKnown, EltWritten);
-    DEBUG(dbgs() << "Computed Zone:\n"; OriginalZone.print(dbgs(), 4));
+    LLVM_DEBUG(dbgs() << "Computed Zone:\n"; OriginalZone.print(dbgs(), 4));
 
     assert(Zone.isUsable() && OriginalZone.isUsable());
     return true;
   }
 
   /// Try to map as many scalars to unused array elements as possible.
   ///
   /// Multiple scalars might be mappable to intersecting unused array element
   /// zones, but we can only chose one. This is a greedy algorithm, therefore
   /// the first processed element claims it.
   void greedyCollapse() {
     bool Modified = false;
 
     for (auto &Stmt : *S) {
       for (auto *MA : Stmt) {
         if (!MA->isLatestArrayKind())
           continue;
         if (!MA->isWrite())
           continue;
 
         if (MA->isMayWrite()) {
-          DEBUG(dbgs() << "Access " << MA
+          LLVM_DEBUG(dbgs() << "Access " << MA
                             << " pruned because it is a MAY_WRITE\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "TargetMayWrite",
                                      MA->getAccessInstruction());
           R << "Skipped possible mapping target because it is not an "
                "unconditional overwrite";
           S->getFunction().getContext().diagnose(R);
           continue;
         }
 
         if (Stmt.getNumIterators() == 0) {
-          DEBUG(dbgs() << "Access " << MA
+          LLVM_DEBUG(dbgs() << "Access " << MA
                             << " pruned because it is not in a loop\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "WriteNotInLoop",
                                      MA->getAccessInstruction());
           R << "skipped possible mapping target because it is not in a loop";
           S->getFunction().getContext().diagnose(R);
           continue;
         }
 
         if (isScalarAccess(MA)) {
-          DEBUG(dbgs() << "Access " << MA
-                       << " pruned because it writes only a single element\n");
+          LLVM_DEBUG(dbgs()
+                     << "Access " << MA
+                     << " pruned because it writes only a single element\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "ScalarWrite",
                                      MA->getAccessInstruction());
           R << "skipped possible mapping target because the memory location "
                "written to does not depend on its outer loop";
           S->getFunction().getContext().diagnose(R);
           continue;
         }
 
         if (!isa<StoreInst>(MA->getAccessInstruction())) {
-          DEBUG(dbgs() << "Access " << MA
+          LLVM_DEBUG(dbgs() << "Access " << MA
                             << " pruned because it is not a StoreInst\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "NotAStore",
                                      MA->getAccessInstruction());
           R << "skipped possible mapping target because non-store instructions "
                "are not supported";
           S->getFunction().getContext().diagnose(R);
           continue;
         }
 
         // Check for more than one element acces per statement instance.
         // Currently we expect write accesses to be functional, eg. disallow
         //
         //   { Stmt[0] -> [i] : 0 <= i < 2 }
         //
         // This may occur when some accesses to the element write/read only
         // parts of the element, eg. a single byte. Polly then divides each
         // element into subelements of the smallest access length, normal access
         // then touch multiple of such subelements. It is very common when the
         // array is accesses with memset, memcpy or memmove which take i8*
         // arguments.
         isl::union_map AccRel = MA->getLatestAccessRelation();
         if (!AccRel.is_single_valued().is_true()) {
-          DEBUG(dbgs() << "Access " << MA
+          LLVM_DEBUG(dbgs() << "Access " << MA
                             << " is incompatible because it writes multiple "
                                "elements per instance\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "NonFunctionalAccRel",
                                      MA->getAccessInstruction());
           R << "skipped possible mapping target because it writes more than "
                "one element";
           S->getFunction().getContext().diagnose(R);
           continue;
         }
 
         isl::union_set TouchedElts = AccRel.range();
         if (!TouchedElts.is_subset(CompatibleElts)) {
-          DEBUG(
+          LLVM_DEBUG(
               dbgs()
               << "Access " << MA
               << " is incompatible because it touches incompatible elements\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "IncompatibleElts",
                                      MA->getAccessInstruction());
           R << "skipped possible mapping target because a target location "
                "cannot be reliably analyzed";
           S->getFunction().getContext().diagnose(R);
           continue;
         }
 
         assert(isCompatibleAccess(MA));
         NumberOfCompatibleTargets++;
-        DEBUG(dbgs() << "Analyzing target access " << MA << "\n");
+        LLVM_DEBUG(dbgs() << "Analyzing target access " << MA << "\n");
         if (collapseScalarsToStore(MA))
           Modified = true;
       }
     }
 
     if (Modified)
       DeLICMScopsModified++;
   }

   /// The pass implementation, also holding per-scop data.
   std::unique_ptr<DeLICMImpl> Impl;
 
   void collapseToUnused(Scop &S) {
     auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     Impl = make_unique<DeLICMImpl>(&S, &LI);
 
     if (!Impl->computeZone()) {
-      DEBUG(dbgs() << "Abort because cannot reliably compute lifetimes\n");
+      LLVM_DEBUG(dbgs() << "Abort because cannot reliably compute lifetimes\n");
       return;
     }
 
-    DEBUG(dbgs() << "Collapsing scalars to unused array elements...\n");
+    LLVM_DEBUG(dbgs() << "Collapsing scalars to unused array elements...\n");
     Impl->greedyCollapse();
 
-    DEBUG(dbgs() << "\nFinal Scop:\n");
-    DEBUG(dbgs() << S);
+    LLVM_DEBUG(dbgs() << "\nFinal Scop:\n");
+    LLVM_DEBUG(dbgs() << S);
   }
 
 public:
   static char ID;
   explicit DeLICM() : ScopPass(ID) {}
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredTransitive<ScopInfoRegionPass>();

lib/Transform/FlattenAlgo.cpp

   auto ScatterSet = isl::set(Schedule.range());
 
   auto ParamSpace = Schedule.get_space().params();
   auto Dims = ScatterSet.dim(isl::dim::set);
   assert(Dims >= 2);
 
   // Would cause an infinite loop.
   if (!isDimBoundedByConstant(ScatterSet, 0)) {
-    DEBUG(dbgs() << "Abort; dimension is not of fixed size\n");
+    LLVM_DEBUG(dbgs() << "Abort; dimension is not of fixed size\n");
     return nullptr;
   }
 
   auto AllDomains = Schedule.domain();
   auto AllDomainsToNull = isl::union_pw_multi_aff(AllDomains);
 
   auto NewSchedule = isl::union_map::empty(ParamSpace);
   auto Counter = isl::pw_aff(isl::local_space(ParamSpace.set_from_params()));
 
   while (!ScatterSet.is_empty()) {
-    DEBUG(dbgs() << "Next counter:\n  " << Counter << "\n");
-    DEBUG(dbgs() << "Remaining scatter set:\n  " << ScatterSet << "\n");
+    LLVM_DEBUG(dbgs() << "Next counter:\n  " << Counter << "\n");
+    LLVM_DEBUG(dbgs() << "Remaining scatter set:\n  " << ScatterSet << "\n");
     auto ThisSet = ScatterSet.project_out(isl::dim::set, 1, Dims - 1);
     auto ThisFirst = ThisSet.lexmin();
     auto ScatterFirst = ThisFirst.add_dims(isl::dim::set, Dims - 1);
 
     auto SubSchedule = Schedule.intersect_range(ScatterFirst);
     SubSchedule = scheduleProjectOut(SubSchedule, 0, 1);
     SubSchedule = flattenSchedule(SubSchedule);
 
     auto SubDims = scheduleScatterDims(SubSchedule);
     auto FirstSubSchedule = scheduleProjectOut(SubSchedule, 1, SubDims - 1);
     auto FirstScheduleAff = scheduleExtractDimAff(FirstSubSchedule, 0);
     auto RemainingSubSchedule = scheduleProjectOut(SubSchedule, 0, 1);
 
     auto FirstSubScatter = isl::set(FirstSubSchedule.range());
-    DEBUG(dbgs() << "Next step in sequence is:\n  " << FirstSubScatter << "\n");
+    LLVM_DEBUG(dbgs() << "Next step in sequence is:\n  " << FirstSubScatter
+                      << "\n");
 
     if (!isDimBoundedByParameter(FirstSubScatter, 0)) {
-      DEBUG(dbgs() << "Abort; sequence step is not bounded\n");
+      LLVM_DEBUG(dbgs() << "Abort; sequence step is not bounded\n");
       return nullptr;
     }
 
     auto FirstSubScatterMap = isl::map::from_range(FirstSubScatter);
 
     // isl_set_dim_max returns a strange isl_pw_aff with domain tuple_id of
     // 'none'. It doesn't match with any space including a 0-dimensional
     // anonymous tuple.

     auto ScheduleWithOffset = isl::union_map(FirstScheduleAffWithOffset)
                                   .flat_range_product(RemainingSubSchedule);
     NewSchedule = NewSchedule.unite(ScheduleWithOffset);
 
     ScatterSet = ScatterSet.subtract(ScatterFirst);
     Counter = Counter.add(PartLen);
   }
 
-  DEBUG(dbgs() << "Sequence-flatten result is:\n  " << NewSchedule << "\n");
+  LLVM_DEBUG(dbgs() << "Sequence-flatten result is:\n  " << NewSchedule
+                    << "\n");
   return NewSchedule;
 }
 
 /// Flatten a loop-like first dimension.
 ///
 /// A loop-like dimension is one that depends on a variable (usually a loop's
 /// induction variable). Let the input schedule look like this:
 ///   { Stmt[i] -> [i, X, ...] }

   auto SubDims = scheduleScatterDims(SubSchedule);
 
   auto SubExtent = isl::set(SubSchedule.range());
   auto SubExtentDims = SubExtent.dim(isl::dim::param);
   SubExtent = SubExtent.project_out(isl::dim::param, 0, SubExtentDims);
   SubExtent = SubExtent.project_out(isl::dim::set, 1, SubDims - 1);
 
   if (!isDimBoundedByConstant(SubExtent, 0)) {
-    DEBUG(dbgs() << "Abort; dimension not bounded by constant\n");
+    LLVM_DEBUG(dbgs() << "Abort; dimension not bounded by constant\n");
     return nullptr;
   }
 
   auto Min = SubExtent.dim_min(0);
-  DEBUG(dbgs() << "Min bound:\n  " << Min << "\n");
+  LLVM_DEBUG(dbgs() << "Min bound:\n  " << Min << "\n");
   auto MinVal = getConstant(Min, false, true);
   auto Max = SubExtent.dim_max(0);
-  DEBUG(dbgs() << "Max bound:\n  " << Max << "\n");
+  LLVM_DEBUG(dbgs() << "Max bound:\n  " << Max << "\n");
   auto MaxVal = getConstant(Max, true, false);
 
   if (!MinVal || !MaxVal || MinVal.is_nan() || MaxVal.is_nan()) {
-    DEBUG(dbgs() << "Abort; dimension bounds could not be determined\n");
+    LLVM_DEBUG(dbgs() << "Abort; dimension bounds could not be determined\n");
     return nullptr;
   }
 
   auto FirstSubScheduleAff = scheduleExtractDimAff(SubSchedule, 0);
   auto RemainingSubSchedule = scheduleProjectOut(std::move(SubSchedule), 0, 1);
 
   auto LenVal = MaxVal.sub(MinVal).add_ui(1);
   auto FirstSubScheduleNormalized = subtract(FirstSubScheduleAff, MinVal);
 
   // TODO: Normalize FirstAff to zero (convert to isl_map, determine minimum,
   // subtract it)
   auto FirstAff = scheduleExtractDimAff(Schedule, 0);
   auto Offset = multiply(FirstAff, LenVal);
   auto Index = FirstSubScheduleNormalized.add(Offset);
   auto IndexMap = isl::union_map(Index);
 
   auto Result = IndexMap.flat_range_product(RemainingSubSchedule);
-  DEBUG(dbgs() << "Loop-flatten result is:\n  " << Result << "\n");
+  LLVM_DEBUG(dbgs() << "Loop-flatten result is:\n  " << Result << "\n");
   return Result;
 }
 } // anonymous namespace
 
 isl::union_map polly::flattenSchedule(isl::union_map Schedule) {
   auto Dims = scheduleScatterDims(Schedule);
-  DEBUG(dbgs() << "Recursive schedule to process:\n  " << Schedule << "\n");
+  LLVM_DEBUG(dbgs() << "Recursive schedule to process:\n  " << Schedule
+                    << "\n");
 
   // Base case; no dimensions left
   if (Dims == 0) {
     // TODO: Add one dimension?
     return Schedule;
   }
 
   // Base case; already one-dimensional
   if (Dims == 1)
     return Schedule;
 
   // Fixed dimension; no need to preserve variabledness.
   if (!isVariableDim(Schedule)) {
-    DEBUG(dbgs() << "Fixed dimension; try sequence flattening\n");
+    LLVM_DEBUG(dbgs() << "Fixed dimension; try sequence flattening\n");
     auto NewScheduleSequence = tryFlattenSequence(Schedule);
     if (NewScheduleSequence)
       return NewScheduleSequence;
   }
 
   // Constant stride
-  DEBUG(dbgs() << "Try loop flattening\n");
+  LLVM_DEBUG(dbgs() << "Try loop flattening\n");
   auto NewScheduleLoop = tryFlattenLoop(Schedule);
   if (NewScheduleLoop)
     return NewScheduleLoop;
 
   // Try again without loop condition (may blow up the number of pieces!!)
-  DEBUG(dbgs() << "Try sequence flattening again\n");
+  LLVM_DEBUG(dbgs() << "Try sequence flattening again\n");
   auto NewScheduleSequence = tryFlattenSequence(Schedule);
   if (NewScheduleSequence)
     return NewScheduleSequence;
 
   // Cannot flatten
   return Schedule;
 }

lib/Transform/FlattenSchedule.cpp

     AU.setPreservesAll();
   }
 
   virtual bool runOnScop(Scop &S) override {
     // Keep a reference to isl_ctx to ensure that it is not freed before we free
     // OldSchedule.
     IslCtx = S.getSharedIslCtx();
 
-    DEBUG(dbgs() << "Going to flatten old schedule:\n");
+    LLVM_DEBUG(dbgs() << "Going to flatten old schedule:\n");
     OldSchedule = S.getSchedule();
-    DEBUG(printSchedule(dbgs(), OldSchedule, 2));
+    LLVM_DEBUG(printSchedule(dbgs(), OldSchedule, 2));
 
     auto Domains = S.getDomains();
     auto RestrictedOldSchedule = OldSchedule.intersect_domain(Domains);
-    DEBUG(dbgs() << "Old schedule with domains:\n");
-    DEBUG(printSchedule(dbgs(), RestrictedOldSchedule, 2));
+    LLVM_DEBUG(dbgs() << "Old schedule with domains:\n");
+    LLVM_DEBUG(printSchedule(dbgs(), RestrictedOldSchedule, 2));
 
     auto NewSchedule = flattenSchedule(RestrictedOldSchedule);
 
-    DEBUG(dbgs() << "Flattened new schedule:\n");
-    DEBUG(printSchedule(dbgs(), NewSchedule, 2));
+    LLVM_DEBUG(dbgs() << "Flattened new schedule:\n");
+    LLVM_DEBUG(printSchedule(dbgs(), NewSchedule, 2));
 
     NewSchedule = NewSchedule.gist_domain(Domains);
-    DEBUG(dbgs() << "Gisted, flattened new schedule:\n");
-    DEBUG(printSchedule(dbgs(), NewSchedule, 2));
+    LLVM_DEBUG(dbgs() << "Gisted, flattened new schedule:\n");
+    LLVM_DEBUG(printSchedule(dbgs(), NewSchedule, 2));
 
     S.setSchedule(NewSchedule);
     return false;
   }
 
   virtual void printScop(raw_ostream &OS, Scop &S) const override {
     OS << "Schedule before flattening {\n";
     printSchedule(OS, OldSchedule, 4);

lib/Transform/ForwardOpTree.cpp

       Translator = makeIdentityMap(Known.range(), false);
     }
 
     if (!Known || !Translator || !NormalizeMap) {
       assert(isl_ctx_last_error(IslCtx.get()) == isl_error_quota);
       Known = nullptr;
       Translator = nullptr;
       NormalizeMap = nullptr;
-      DEBUG(dbgs() << "Known analysis exceeded max_operations\n");
+      LLVM_DEBUG(dbgs() << "Known analysis exceeded max_operations\n");
       return false;
     }
 
     KnownAnalyzed++;
-    DEBUG(dbgs() << "All known: " << Known << "\n");
+    LLVM_DEBUG(dbgs() << "All known: " << Known << "\n");
 
     return true;
   }
 
   void printStatistics(raw_ostream &OS, int Indent = 0) {
     OS.indent(Indent) << "Statistics {\n";
     OS.indent(Indent + 4) << "Instructions copied: " << NumInstructionsCopied
                           << '\n';

 
     if (DoIt)
       TargetStmt->prependInstruction(LI);
 
     if (!DoIt)
       return FD_CanForwardProfitably;
 
     if (Access) {
-      DEBUG(dbgs() << "    forwarded known load with preexisting MemoryAccess"
-                   << Access << "\n");
+      LLVM_DEBUG(
+          dbgs() << "    forwarded known load with preexisting MemoryAccess"
+                 << Access << "\n");
     } else {
       Access = makeReadArrayAccess(TargetStmt, LI, SameVal);
-      DEBUG(dbgs() << "    forwarded known load with new MemoryAccess" << Access
-                   << "\n");
+      LLVM_DEBUG(dbgs() << "    forwarded known load with new MemoryAccess"
+                        << Access << "\n");
 
       // { ValInst[] }
       isl::space ValInstSpace = ExpectedVal.get_space().range();
 
       // After adding a new load to the SCoP, also update the Known content
       // about it. The new load will have a known ValInst of
       // { [DomainTarget[] -> Value[]] }
       // but which -- because it is a copy of it -- has same value as the

         // { Value[] -> Value[] }
         isl::map ValToVal =
             isl::map::identity(ValSpace.map_from_domain_and_range(ValSpace));
 
         // { [TargetDomain[] -> Value[]] -> [DefDomain[] -> Value] }
         isl::map LocalTranslator = DefToTarget.reverse().product(ValToVal);
 
         Translator = Translator.add_map(LocalTranslator);
-        DEBUG(dbgs() << "      local translator is " << LocalTranslator
+        LLVM_DEBUG(dbgs() << "      local translator is " << LocalTranslator
                           << "\n");
       }
     }
-    DEBUG(dbgs() << "      expected values where " << TargetExpectedVal
+    LLVM_DEBUG(dbgs() << "      expected values where " << TargetExpectedVal
                       << "\n");
-    DEBUG(dbgs() << "      candidate elements where " << Candidates << "\n");
+    LLVM_DEBUG(dbgs() << "      candidate elements where " << Candidates
+                      << "\n");
     assert(Access);
 
     NumKnownLoadsForwarded++;
     TotalKnownLoadsForwarded++;
     return FD_DidForwardTree;
   }
 
   /// Forward a scalar by redirecting the access to an array element that stores

       // do not allow forwarding PHI nodes, thus this should never occur (the
       // only exception where no phi is necessary being an unreachable loop
       // without edge from the outside).
       VirtualUse TargetUse = VirtualUse::create(
           S, TargetStmt, TargetStmt->getSurroundingLoop(), UseVal, true);
       if (TargetUse.getKind() == VirtualUse::Synthesizable)
         return FD_CanForwardLeaf;
 
-      DEBUG(dbgs() << "    Synthesizable would not be synthesizable anymore: "
-                   << *UseVal << "\n");
+      LLVM_DEBUG(
+          dbgs() << "    Synthesizable would not be synthesizable anymore: "
+                 << *UseVal << "\n");
       return FD_CannotForward;
     }
 
     case VirtualUse::ReadOnly:
       // Note that we cannot return FD_CanForwardTree here. With a operand tree
       // depth of 0, UseVal is the use in TargetStmt that we try to replace.
       // With -polly-analyze-read-only-scalars=true we would ensure the
       // existence of a MemoryAccess (which already exists for a leaf) and be

       ForwardingDecision ReloadResult =
           reloadKnownContent(TargetStmt, Inst, UseStmt, UseLoop, UseToTarget,
                              DefStmt, DefLoop, DefToTarget, DoIt);
       if (ReloadResult != FD_NotApplicable)
         return ReloadResult;
 
       // When no method is found to forward the operand tree, we effectively
       // cannot handle it.
-      DEBUG(dbgs() << "    Cannot forward instruction: " << *Inst << "\n");
+      LLVM_DEBUG(dbgs() << "    Cannot forward instruction: " << *Inst << "\n");
       return FD_CannotForward;
     }
 
     llvm_unreachable("Case unhandled");
   }
 
   /// Try to forward an operand tree rooted in @p RA.
   bool tryForwardTree(MemoryAccess *RA) {
     assert(RA->isLatestScalarKind());
-    DEBUG(dbgs() << "Trying to forward operand tree " << RA << "...\n");
+    LLVM_DEBUG(dbgs() << "Trying to forward operand tree " << RA << "...\n");
 
     ScopStmt *Stmt = RA->getStatement();
     Loop *InLoop = Stmt->getSurroundingLoop();
 
     isl::map TargetToUse;
     if (!Known.is_null()) {
       isl::space DomSpace = Stmt->getDomainSpace();
       TargetToUse =

 
     LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
 
     {
       IslMaxOperationsGuard MaxOpGuard(S.getIslCtx().get(), MaxOps, false);
       Impl = llvm::make_unique<ForwardOpTreeImpl>(&S, &LI, MaxOpGuard);
 
       if (AnalyzeKnown) {
-        DEBUG(dbgs() << "Prepare forwarders...\n");
+        LLVM_DEBUG(dbgs() << "Prepare forwarders...\n");
         Impl->computeKnownValues();
       }
 
-      DEBUG(dbgs() << "Forwarding operand trees...\n");
+      LLVM_DEBUG(dbgs() << "Forwarding operand trees...\n");
       Impl->forwardOperandTrees();
 
       if (MaxOpGuard.hasQuotaExceeded()) {
-        DEBUG(dbgs() << "Not all operations completed because of "
+        LLVM_DEBUG(dbgs() << "Not all operations completed because of "
                              "max_operations exceeded\n");
         KnownOutOfQuota++;
       }
     }
 
-    DEBUG(dbgs() << "\nFinal Scop:\n");
-    DEBUG(dbgs() << S);
+    LLVM_DEBUG(dbgs() << "\nFinal Scop:\n");
+    LLVM_DEBUG(dbgs() << S);
 
     // Update statistics
     auto ScopStats = S.getStatistics();
     NumValueWrites += ScopStats.NumValueWrites;
     NumValueWritesInLoops += ScopStats.NumValueWritesInLoops;
     NumPHIWrites += ScopStats.NumPHIWrites;
     NumPHIWritesInLoops += ScopStats.NumPHIWritesInLoops;
     NumSingletonWrites += ScopStats.NumSingletonWrites;

lib/Transform/ScheduleOptimizer.cpp

     return Node;
 
   const OptimizerAdditionalInfoTy *OAI =
       static_cast<const OptimizerAdditionalInfoTy *>(User);
 
   MatMulInfoTy MMI;
   if (PMBasedOpts && User &&
       isMatrMultPattern(isl::manage_copy(Node), OAI->D, MMI)) {
-    DEBUG(dbgs() << "The matrix multiplication pattern was detected\n");
+    LLVM_DEBUG(dbgs() << "The matrix multiplication pattern was detected\n");
     MatMulOpts++;
     return optimizeMatMulPattern(isl::manage(Node), OAI->TTI, MMI).release();
   }
 
   return standardBandOpts(isl::manage(Node), User).release();
 }
 
 isl::schedule

     S.markAsOptimized();
     return false;
   }
 
   const Dependences &D =
       getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
 
   if (D.getSharedIslCtx() != S.getSharedIslCtx()) {
-    DEBUG(dbgs() << "DependenceInfo for another SCoP/isl_ctx\n");
+    LLVM_DEBUG(dbgs() << "DependenceInfo for another SCoP/isl_ctx\n");
     return false;
   }
 
   if (!D.hasValidDependences())
     return false;
 
   isl_schedule_free(LastSchedule);
   LastSchedule = nullptr;

     Validity = Validity.gist_range(Domain);
     Proximity = Proximity.gist_domain(Domain);
     Proximity = Proximity.gist_range(Domain);
   } else if (SimplifyDeps != "no") {
     errs() << "warning: Option -polly-opt-simplify-deps should either be 'yes' "
               "or 'no'. Falling back to default: 'yes'\n";
   }
 
-  DEBUG(dbgs() << "\n\nCompute schedule from: ");
-  DEBUG(dbgs() << "Domain := " << Domain << ";\n");
-  DEBUG(dbgs() << "Proximity := " << Proximity << ";\n");
-  DEBUG(dbgs() << "Validity := " << Validity << ";\n");
+  LLVM_DEBUG(dbgs() << "\n\nCompute schedule from: ");
+  LLVM_DEBUG(dbgs() << "Domain := " << Domain << ";\n");
+  LLVM_DEBUG(dbgs() << "Proximity := " << Proximity << ";\n");
+  LLVM_DEBUG(dbgs() << "Validity := " << Validity << ";\n");
 
   unsigned IslSerializeSCCs;
 
   if (FusionStrategy == "max") {
     IslSerializeSCCs = 0;
   } else if (FusionStrategy == "min") {
     IslSerializeSCCs = 1;
   } else {

 
   // In cases the scheduler is not able to optimize the code, we just do not
   // touch the schedule.
   if (!Schedule)
     return false;
 
   ScopsRescheduled++;
 
-  DEBUG({
+  LLVM_DEBUG({
     auto *P = isl_printer_to_str(Ctx);
     P = isl_printer_set_yaml_style(P, ISL_YAML_STYLE_BLOCK);
     P = isl_printer_print_schedule(P, Schedule.get());
     auto *str = isl_printer_get_str(P);
     dbgs() << "NewScheduleTree: \n" << str << "\n";
     free(str);
     isl_printer_free(P);
   });

lib/Transform/ScopInliner.cpp

       return false;
     assert(SCC.size() == 1 && "found empty SCC");
     Function *F = (*SCC.begin())->getFunction();
 
     // If the function is a nullptr, or the function is a declaration.
     if (!F)
       return false;
     if (F->isDeclaration()) {
-      DEBUG(dbgs() << "Skipping " << F->getName()
+      LLVM_DEBUG(dbgs() << "Skipping " << F->getName()
                         << "because it is a declaration.\n");
       return false;
     }
 
     PassBuilder PB;
     FunctionAnalysisManager FAM;
     FAM.registerPass([] { return ScopAnalysis(); });
     PB.registerFunctionAnalyses(FAM);
 
     RegionInfo &RI = FAM.getResult<RegionInfoAnalysis>(*F);
     ScopDetection &SD = FAM.getResult<ScopAnalysis>(*F);
 
     const bool HasScopAsTopLevelRegion =
         SD.ValidRegions.count(RI.getTopLevelRegion()) > 0;
 
     if (HasScopAsTopLevelRegion) {
-      DEBUG(dbgs() << "Skipping " << F->getName()
+      LLVM_DEBUG(dbgs() << "Skipping " << F->getName()
                         << " has scop as top level region");
       F->addFnAttr(llvm::Attribute::AlwaysInline);
 
       ModuleAnalysisManager MAM;
       PB.registerModuleAnalyses(MAM);
       ModulePassManager MPM;
       MPM.addPass(AlwaysInlinerPass());
       Module *M = F->getParent();
       assert(M && "Function has illegal module");
       MPM.run(*M, MAM);
     } else {
-      DEBUG(dbgs() << F->getName()
+      LLVM_DEBUG(dbgs() << F->getName()
                         << " does NOT have scop as top level region\n");
     }
 
     return false;
   };
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     CallGraphSCCPass::getAnalysisUsage(AU);
   }

lib/Transform/Simplify.cpp

           isl::map AccRelUniv = isl::map::universe(AccRel.get_space());
           WillBeOverwritten = WillBeOverwritten.subtract(AccRelUniv);
           continue;
         }
 
         // If all of a write's elements are overwritten, remove it.
         isl::union_map AccRelUnion = AccRel;
         if (AccRelUnion.is_subset(WillBeOverwritten)) {
-          DEBUG(dbgs() << "Removing " << MA
+          LLVM_DEBUG(dbgs() << "Removing " << MA
                             << " which will be overwritten anyway\n");
 
           Stmt.removeSingleMemoryAccess(MA);
           OverwritesRemoved++;
           TotalOverwritesRemoved[CallNo]++;
         }
 
         // Unconditional writes overwrite other values.
         if (MA->isMustWrite()) {

           if (!StoredVal)
             StoredVal = MA->getAccessValue();
 
           if (StoredVal) {
             // Lookup in the set of known values.
             isl::map AccRelStoredVal = isl::map::from_domain_and_range(
                 AccRelWrapped, makeValueSet(StoredVal));
             if (isl::union_map(AccRelStoredVal).is_subset(Known)) {
-              DEBUG(dbgs() << "Cleanup of " << MA << ":\n");
-              DEBUG(dbgs() << "      Scalar: " << *StoredVal << "\n");
-              DEBUG(dbgs() << "      AccRel: " << AccRel << "\n");
+              LLVM_DEBUG(dbgs() << "Cleanup of " << MA << ":\n");
+              LLVM_DEBUG(dbgs() << "      Scalar: " << *StoredVal << "\n");
+              LLVM_DEBUG(dbgs() << "      AccRel: " << AccRel << "\n");
 
               Stmt.removeSingleMemoryAccess(MA);
 
               RedundantWritesRemoved++;
               TotalRedundantWritesRemoved[CallNo]++;
             }
           }
         }

   }
 
   /// Remove statements without side effects.
   void removeUnnecessaryStmts() {
     auto NumStmtsBefore = S->getSize();
     S->simplifySCoP(true);
     assert(NumStmtsBefore >= S->getSize());
     StmtsRemoved = NumStmtsBefore - S->getSize();
-    DEBUG(dbgs() << "Removed " << StmtsRemoved << " (of " << NumStmtsBefore
+    LLVM_DEBUG(dbgs() << "Removed " << StmtsRemoved << " (of " << NumStmtsBefore
                       << ") statements\n");
     TotalStmtsRemoved[CallNo] += StmtsRemoved;
   }
 
   /// Remove accesses that have an empty domain.
   void removeEmptyPartialAccesses() {
     for (ScopStmt &Stmt : *S) {
       // Defer the actual removal to not invalidate iterators.
       SmallVector<MemoryAccess *, 8> DeferredRemove;
 
       for (MemoryAccess *MA : Stmt) {
         if (!MA->isWrite())
           continue;
 
         isl::map AccRel = MA->getAccessRelation();
         if (!AccRel.is_empty().is_true())
           continue;
 
-        DEBUG(dbgs() << "Removing " << MA
-                     << " because it's a partial access that never occurs\n");
+        LLVM_DEBUG(
+            dbgs() << "Removing " << MA
+                   << " because it's a partial access that never occurs\n");
         DeferredRemove.push_back(MA);
       }
 
       for (MemoryAccess *MA : DeferredRemove) {
         Stmt.removeSingleMemoryAccess(MA);
         EmptyPartialAccessesRemoved++;
         TotalEmptyPartialAccessesRemoved[CallNo]++;
       }

     // iterators when removing them.
     SmallVector<MemoryAccess *, 64> AllMAs;
     for (ScopStmt &Stmt : *S)
       AllMAs.append(Stmt.begin(), Stmt.end());
 
     for (MemoryAccess *MA : AllMAs) {
       if (UsedMA.count(MA))
         continue;
-      DEBUG(dbgs() << "Removing " << MA << " because its value is not used\n");
+      LLVM_DEBUG(dbgs() << "Removing " << MA
+                        << " because its value is not used\n");
       ScopStmt *Stmt = MA->getStatement();
       Stmt->removeSingleMemoryAccess(MA);
 
       DeadAccessesRemoved++;
       TotalDeadAccessesRemoved[CallNo]++;
     }
 
     // Remove all non-reachable instructions.
     for (ScopStmt &Stmt : *S) {
       // Note that for region statements, we can only remove the non-terminator
       // instructions of the entry block. All other instructions are not in the
       // instructions list, but implicitly always part of the statement.
 
       SmallVector<Instruction *, 32> AllInsts(Stmt.insts_begin(),
                                               Stmt.insts_end());
       SmallVector<Instruction *, 32> RemainInsts;
 
       for (Instruction *Inst : AllInsts) {
         auto It = UsedInsts.find({&Stmt, Inst});
         if (It == UsedInsts.end()) {
-          DEBUG(dbgs() << "Removing "; Inst->print(dbgs());
+          LLVM_DEBUG(dbgs() << "Removing "; Inst->print(dbgs());
                      dbgs() << " because it is not used\n");
           DeadInstructionsRemoved++;
           TotalDeadInstructionsRemoved[CallNo]++;
           continue;
         }
 
         RemainInsts.push_back(Inst);
 
         // If instructions appear multiple times, keep only the first.

     // Reset statistics of last processed SCoP.
     releaseMemory();
     assert(!isModified());
 
     // Prepare processing of this SCoP.
     this->S = &S;
     ScopsProcessed[CallNo]++;
 
-    DEBUG(dbgs() << "Removing partial writes that never happen...\n");
+    LLVM_DEBUG(dbgs() << "Removing partial writes that never happen...\n");
     removeEmptyPartialAccesses();
 
-    DEBUG(dbgs() << "Removing overwrites...\n");
+    LLVM_DEBUG(dbgs() << "Removing overwrites...\n");
     removeOverwrites();
 
-    DEBUG(dbgs() << "Coalesce partial writes...\n");
+    LLVM_DEBUG(dbgs() << "Coalesce partial writes...\n");
     coalesceWrites();
 
-    DEBUG(dbgs() << "Removing redundant writes...\n");
+    LLVM_DEBUG(dbgs() << "Removing redundant writes...\n");
     removeRedundantWrites();
 
-    DEBUG(dbgs() << "Cleanup unused accesses...\n");
+    LLVM_DEBUG(dbgs() << "Cleanup unused accesses...\n");
     LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     markAndSweep(LI);
 
-    DEBUG(dbgs() << "Removing statements without side effects...\n");
+    LLVM_DEBUG(dbgs() << "Removing statements without side effects...\n");
     removeUnnecessaryStmts();
 
     if (isModified())
       ScopsModified[CallNo]++;
-    DEBUG(dbgs() << "\nFinal Scop:\n");
-    DEBUG(dbgs() << S);
+    LLVM_DEBUG(dbgs() << "\nFinal Scop:\n");
+    LLVM_DEBUG(dbgs() << S);
 
     auto ScopStats = S.getStatistics();
     NumValueWrites[CallNo] += ScopStats.NumValueWrites;
     NumValueWritesInLoops[CallNo] += ScopStats.NumValueWritesInLoops;
     NumPHIWrites[CallNo] += ScopStats.NumPHIWrites;
     NumPHIWritesInLoops[CallNo] += ScopStats.NumPHIWritesInLoops;
     NumSingletonWrites[CallNo] += ScopStats.NumSingletonWrites;
     NumSingletonWritesInLoops[CallNo] += ScopStats.NumSingletonWritesInLoops;

lib/Transform/ZoneAlgo.cpp

     // To avoid solving any ILP problems, always add entire arrays instead of
     // just the elements that are accessed.
     auto ArrayElts = isl::set::universe(AccRelMap.get_space().range());
     AllElts = AllElts.add_set(ArrayElts);
 
     if (MA->isRead()) {
       // Reject load after store to same location.
       if (!isl_union_map_is_disjoint(Stores.keep(), AccRel.keep())) {
-        DEBUG(dbgs() << "Load after store of same element in same statement\n");
+        LLVM_DEBUG(
+            dbgs() << "Load after store of same element in same statement\n");
         OptimizationRemarkMissed R(PassName, "LoadAfterStore",
                                    MA->getAccessInstruction());
         R << "load after store of same element in same statement";
         R << " (previous stores: " << Stores;
         R << ", loading: " << AccRel << ")";
         S->getFunction().getContext().diagnose(R);
 
         IncompatibleElts = IncompatibleElts.add_set(ArrayElts);
       }
 
       Loads = give(isl_union_map_union(Loads.take(), AccRel.take()));
 
       continue;
     }
 
     // In region statements the order is less clear, eg. the load and store
     // might be in a boxed loop.
     if (Stmt->isRegionStmt() &&
         !isl_union_map_is_disjoint(Loads.keep(), AccRel.keep())) {
-      DEBUG(dbgs() << "WRITE in non-affine subregion not supported\n");
+      LLVM_DEBUG(dbgs() << "WRITE in non-affine subregion not supported\n");
       OptimizationRemarkMissed R(PassName, "StoreInSubregion",
                                  MA->getAccessInstruction());
       R << "store is in a non-affine subregion";
       S->getFunction().getContext().diagnose(R);
 
       IncompatibleElts = IncompatibleElts.add_set(ArrayElts);
     }
 
     // Do not allow more than one store to the same location.
     if (!isl_union_map_is_disjoint(Stores.keep(), AccRel.keep()) &&
         !onlySameValueWrites(Stmt)) {
-      DEBUG(dbgs() << "WRITE after WRITE to same element\n");
+      LLVM_DEBUG(dbgs() << "WRITE after WRITE to same element\n");
       OptimizationRemarkMissed R(PassName, "StoreAfterStore",
                                  MA->getAccessInstruction());
       R << "store after store of same element in same statement";
       R << " (previous stores: " << Stores;
       R << ", storing: " << AccRel << ")";
       S->getFunction().getContext().diagnose(R);
 
       IncompatibleElts = IncompatibleElts.add_set(ArrayElts);