[LV][BUG] Tiny fix for printing debug locations for absolute paths.

[zinovy.nis]

Summary

If a loop was defined in a file referenced by an absolute path (for ex. STL header from the system dir), then DEBUG print would print module dir and then that absolute path, which is wrong.

LV: Checking a loop in "Foo" from /home/myhome//usr/lib/gcc/z42_128-greencap-linux/1.2.3/../../../../include/c++/9.8.7/bits/list.tcc:171

The correct behavior is to just print the absolute path and skip module dir.

LV: Checking a loop in "Foo" from /usr/lib/gcc/z42_128-greencap-linux/1.2.3/../../../../include/c++/9.8.7/bits/list.tcc:171

[echristo]

Seems reasonable.

[zinovy.nis]

1. Slightly refactored to get rid of ugly format<..> calls.
2. Use path::append instead of string concatenation.

[nadav]

Zinovy,

Why is getDebugLocString defined in LoopVectorize.cpp? I am expecting other passes to also need this utility. Please refactor this function and put this function in a place where other passes would be able to use it.

Nadav

[yaron.keren]

If factored out as a function accepting a DebugLoc rather than an llvm::Instruction, it may be mergable with most of printDebugLoc from lib/CodeGen/MachineInstr.cpp. The print format is not identical but I'm not sure if this is a problem.

[zinovy.nis]

Thanks to Nadav and Yaron I refactored the code and significantly simplified it compared to my first patch. Also I added method 'print" to DebugLoc class which does the job.

Please re-review my new patch.

[nadav]

LGTM.

[echristo]

One small nit, otherwise LGTM.

-eric

lib/IR/DebugLoc.cpp

170

Formatting looks wrong here.

[zinovy.nis]

Nadav, Eric thanks!

include/llvm/IR/DebugLoc.h

 #define LLVM_IR_DEBUGLOC_H
 
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
   template <typename T> struct DenseMapInfo;
   class MDNode;
   class LLVMContext;
+  class raw_ostream;
 
   /// DebugLoc - Debug location id.  This is carried by Instruction, SDNode,
   /// and MachineInstr to compactly encode file/line/scope information for an
   /// operation.
   class DebugLoc {
     friend struct DenseMapInfo<DebugLoc>;
 
     /// getEmptyKey() - A private constructor that returns an unknown that is
public:
     MDNode *getAsMDNode(const LLVMContext &Ctx) const;
 
     bool operator==(const DebugLoc &DL) const {
       return LineCol == DL.LineCol && ScopeIdx == DL.ScopeIdx;
     }
     bool operator!=(const DebugLoc &DL) const { return !(*this == DL); }
 
     void dump(const LLVMContext &Ctx) const;
+    /// \brief prints source location /path/to/file.exe:line:col @[inlined at]
+    void print(const LLVMContext &Ctx, raw_ostream &OS) const;
   };
 
   template <>
   struct DenseMapInfo<DebugLoc> {
     static DebugLoc getEmptyKey() { return DebugLoc::getEmptyKey(); }
     static DebugLoc getTombstoneKey() { return DebugLoc::getTombstoneKey(); }
     static unsigned getHashValue(const DebugLoc &Key);
     static bool isEqual(DebugLoc LHS, DebugLoc RHS) { return LHS == RHS; }
   };
 } // end namespace llvm
 
 #endif /* LLVM_SUPPORT_DEBUGLOC_H */

lib/CodeGen/MachineInstr.cpp

 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   dbgs() << "  " << *this;
 #endif
 }
 
 static void printDebugLoc(DebugLoc DL, const MachineFunction *MF,
                          raw_ostream &CommentOS) {
   const LLVMContext &Ctx = MF->getFunction()->getContext();
-  if (!DL.isUnknown()) {          // Print source line info.
-    DIScope Scope(DL.getScope(Ctx));
-    assert((!Scope || Scope.isScope()) &&
-      "Scope of a DebugLoc should be null or a DIScope.");
-    // Omit the directory, because it's likely to be long and uninteresting.
-    if (Scope)
-      CommentOS << Scope.getFilename();
-    else
-      CommentOS << "<unknown>";
-    CommentOS << ':' << DL.getLine();
-    if (DL.getCol() != 0)
-      CommentOS << ':' << DL.getCol();
-    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx));
-    if (!InlinedAtDL.isUnknown()) {
-      CommentOS << " @[ ";
-      printDebugLoc(InlinedAtDL, MF, CommentOS);
-      CommentOS << " ]";
-    }
-  }
+  DL.print(Ctx, CommentOS);
 }
 
 void MachineInstr::print(raw_ostream &OS, const TargetMachine *TM,
                          bool SkipOpers) const {
   // We can be a bit tidier if we know the TargetMachine and/or MachineFunction.
   const MachineFunction *MF = nullptr;
   const MachineRegisterInfo *MRI = nullptr;
   if (const MachineBasicBlock *MBB = getParent()) {
void MachineInstr::print(raw_ostream &OS, const TargetMachine *TM,
 
   // Print debug location information.
   if (isDebugValue() && getOperand(e - 1).isMetadata()) {
     if (!HaveSemi) OS << ";";
     DIVariable DV(getOperand(e - 1).getMetadata());
     OS << " line no:" <<  DV.getLineNumber();
     if (MDNode *InlinedAt = DV.getInlinedAt()) {
       DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt);
-      if (!InlinedAtDL.isUnknown()) {
+      if (!InlinedAtDL.isUnknown() && MF) {
         OS << " inlined @[ ";
         printDebugLoc(InlinedAtDL, MF, OS);
         OS << " ]";
       }
     }
   } else if (!debugLoc.isUnknown() && MF) {
     if (!HaveSemi) OS << ";";
     OS << " dbg:";

lib/IR/DebugLoc.cpp

if (!InlinedAtDL.isUnknown()) {
       dbgs() << " @ ";
       InlinedAtDL.dump(Ctx);
     } else
       dbgs() << "\n";
   }
 #endif
 }
 
+void DebugLoc::print(const LLVMContext &Ctx,
+                         raw_ostream &OS) const {
+  if (!isUnknown()) {
+    // Print source line info.
+    DIScope Scope(getScope(Ctx));
+    assert((!Scope || Scope.isScope()) &&
+      "Scope of a DebugLoc should be null or a DIScope.");
+    if (Scope)
+      OS << Scope.getFilename();
+    else
+      OS << "<unknown>";
+    OS << ':' << getLine();
+    if (getCol() != 0)
+      OS << ':' << getCol();
+    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(getInlinedAt(Ctx));
+    if (!InlinedAtDL.isUnknown()) {
+      OS << " @[ ";
+      InlinedAtDL.print(Ctx, OS);
+      OS << " ]";
+    }
+  }
+}
+
+
 //===----------------------------------------------------------------------===//
 // DenseMap specialization
 //===----------------------------------------------------------------------===//
 
 unsigned DenseMapInfo<DebugLoc>::getHashValue(const DebugLoc &Key) {
   return static_cast<unsigned>(hash_combine(Key.LineCol, Key.ScopeIdx));
 }
 

lib/Transforms/Vectorize/LoopVectorize.cpp

 #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/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/VectorUtils.h"
 #include <algorithm>
 #include <map>
 #include <tuple>
if (const Instruction *Inst = dyn_cast_or_null<Instruction>(Ptr))
     B.SetCurrentDebugLocation(Inst->getDebugLoc());
   else
     B.SetCurrentDebugLocation(DebugLoc());
 }
 
 #ifndef NDEBUG
 /// \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);
+static std::string getDebugLocString(const Instruction *I) {
+  std::string Result;
+  if (I) {
+    raw_string_ostream OS(Result);
+    const DebugLoc &InstrDebugLoc = I->getDebugLoc();
+    if (!InstrDebugLoc.isUnknown())
+      InstrDebugLoc.print(I->getContext(), OS);
+    else
+      // Just print the module name.
+      OS << I->getParent()->getParent()->getParent()->getModuleIdentifier();
+    OS.flush();
+  }
+  return Result;
 }
 #endif
 
 /// 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
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.");
+
+#ifndef NDEBUG
+    const std::string DebugLocStr =
+        getDebugLocString(L->getHeader()->getFirstNonPHIOrDbgOrLifetime());
+#endif /* NDEBUG */
+
     DEBUG(dbgs() << "\nLV: Checking a loop in \""
                  << L->getHeader()->getParent()->getName() << "\" from "
-                 << getDebugLocString(L->getHeader()->getFirstNonPHIOrDbg())
-                 << "\n");
+                 << DebugLocStr << "\n");
 
     LoopVectorizeHints Hints(L, DisableUnrolling);
 
     DEBUG(dbgs() << "LV: Loop hints:"
                  << " force="
                  << (Hints.getForce() == LoopVectorizeHints::FK_Disabled
                          ? "disabled"
                          : (Hints.getForce() == LoopVectorizeHints::FK_Enabled
const LoopVectorizationCostModel::VectorizationFactor VF =
         CM.selectVectorizationFactor(OptForSize, Hints.getWidth(),
                                      Hints.getForce() ==
                                          LoopVectorizeHints::FK_Enabled);
 
     // Select the unroll factor.
     const unsigned UF =
         CM.selectUnrollFactor(OptForSize, Hints.getUnroll(), VF.Width, VF.Cost);
 
-    DEBUG(dbgs() << "LV: Found a vectorizable loop ("
-                 << VF.Width << ") in "
-                 << getDebugLocString(L->getHeader()->getFirstNonPHIOrDbg())
-                 << '\n');
+    DEBUG(dbgs() << "LV: Found a vectorizable loop (" << VF.Width << ") in "
+                 << DebugLocStr << '\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");