[LV] More verbose debug info for loop location in the source code

[zinovy.nis]

Summary

Hi.

The patch makes LoopVectorizer print in debug console not only a function name or a module name where analyzing loop was found, but also a line in the source code where the loop resides:

  LV: Checking a loop in "bar" from /some/path/foo.c:42
...
  LV: Found a vectorizable loop (4) in /some/path/foo.c:42
...

It can be useful when debugging loop vectorizer issues.

[nadav]

LGTM!

[echristo]

Nifty.

[zinovy.nis]

Thanks. Could you please commit it for me?

[echristo]

Committed as r205705.

Thanks!

-eric

lib/Transforms/Vectorize/LoopVectorize.cpp

 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpander.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <algorithm>
 #include <map>
 

 /// \brief Set the debug location in the builder using the debug location in the
 /// instruction.
 static void setDebugLocFromInst(IRBuilder<> &B, const Value *Ptr) {
   if (const Instruction *Inst = dyn_cast_or_null<Instruction>(Ptr))
     B.SetCurrentDebugLocation(Inst->getDebugLoc());
   else
     B.SetCurrentDebugLocation(DebugLoc());
 }
-
+/// \return string containing a file name and a line # for the given
+/// instruction.
+static format_object3<const char *, const char *, unsigned>
+getDebugLocString(const Instruction *I) {
+  if (!I)
+    return format<const char *, const char *, unsigned>("", "", "", 0U);
+  MDNode *N = I->getMetadata("dbg");
+  if (!N) {
+    const StringRef ModuleName =
+        I->getParent()->getParent()->getParent()->getModuleIdentifier();
+    return format<const char *, const char *, unsigned>("%s", ModuleName.data(),
+                                                        "", 0U);
+  }
+  const DILocation Loc(N);
+  const unsigned LineNo = Loc.getLineNumber();
+  const char *DirName = Loc.getDirectory().data();
+  const char *FileName = Loc.getFilename().data();
+  return format("%s/%s:%u", DirName, FileName, LineNo);
+}
 /// LoopVectorizationLegality checks if it is legal to vectorize a loop, and
 /// to what vectorization factor.
 /// This class does not look at the profitability of vectorization, only the
 /// legality. This class has two main kinds of checks:
 /// * Memory checks - The code in canVectorizeMemory checks if vectorization
 ///   will change the order of memory accesses in a way that will change the
 ///   correctness of the program.
 /// * Scalars checks - The code in canVectorizeInstrs and canVectorizeMemory
while (!Worklist.empty())
       Changed |= processLoop(Worklist.pop_back_val());
 
     // Process each loop nest in the function.
     return Changed;
   }
 
   bool processLoop(Loop *L) {
     assert(L->empty() && "Only process inner loops.");
-    DEBUG(dbgs() << "LV: Checking a loop in \"" <<
-          L->getHeader()->getParent()->getName() << "\"\n");
+    DEBUG(dbgs() << "LV: Checking a loop in \""
+                 << L->getHeader()->getParent()->getName() << "\" from "
+                 << getDebugLocString(L->getHeader()->getFirstNonPHIOrDbg())
+                 << "\n");
 
     LoopVectorizeHints Hints(L, DisableUnrolling);
 
     if (Hints.Force == 0) {
       DEBUG(dbgs() << "LV: Not vectorizing: #pragma vectorize disable.\n");
       return false;
     }
 
bool processLoop(Loop *L) {
 
     // Select the optimal vectorization factor.
     LoopVectorizationCostModel::VectorizationFactor VF;
     VF = CM.selectVectorizationFactor(OptForSize, Hints.Width);
     // Select the unroll factor.
     unsigned UF = CM.selectUnrollFactor(OptForSize, Hints.Unroll, VF.Width,
                                         VF.Cost);
 
-    DEBUG(dbgs() << "LV: Found a vectorizable loop ("<< VF.Width << ") in "<<
-          F->getParent()->getModuleIdentifier() << '\n');
+    DEBUG(dbgs() << "LV: Found a vectorizable loop ("
+                 << VF.Width << ") in "
+                 << getDebugLocString(L->getHeader()->getFirstNonPHIOrDbg())
+                 << '\n');
     DEBUG(dbgs() << "LV: Unroll Factor is " << UF << '\n');
 
     if (VF.Width == 1) {
       DEBUG(dbgs() << "LV: Vectorization is possible but not beneficial.\n");
       if (UF == 1)
         return false;
       DEBUG(dbgs() << "LV: Trying to at least unroll the loops.\n");
       // We decided not to vectorize, but we may want to unroll.