[DbgHistoryCalculator] Improve debug messages

[fdeazeve]

Summary

I've found that a frequent source of debug information loss in optimized
code is due to DEBUG_VALUE intrinsics in a position of the instruction
stream that is outside the scope of the variable it describes.

Tracking these is pretty difficult with the existing debug messages of
the history calculator; this patch addresses the issue by making it
obvious when this event happens.

[Orlando]

It looks like we get a print for each dropped range, and one additional print for each variable with any dropped ranges. It might be a bit spammy if there are many ranges getting trimmed, but this is all useful information which probably can't be compressed much further, so LGTM (it might be worth waiting a little to see if anyone disagrees?).

Thanks for improving this!

llvm/include/llvm/CodeGen/DbgEntityHistoryCalculator.h

public:
   void trimLocationRanges(const MachineFunction &MF, LexicalScopes &LScopes,
                           const InstructionOrdering &Ordering);
   bool empty() const { return VarEntries.empty(); }
   void clear() { VarEntries.clear(); }
   EntriesMap::const_iterator begin() const { return VarEntries.begin(); }
   EntriesMap::const_iterator end() const { return VarEntries.end(); }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVM_DUMP_METHOD void dump() const;
+  LLVM_DUMP_METHOD void dump(StringRef FuncName) const;
 #endif
 };
 
 /// For each inlined instance of a source-level label, keep the corresponding
 /// DBG_LABEL instruction. The DBG_LABEL instruction could be used to generate
 /// a temporary (assembler) label before it.
 class DbgLabelInstrMap {
 public:

llvm/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

void DbgValueHistoryMap::trimLocationRanges(
   SmallVector<EntryIndex, 4> ToRemove;
   // Entry reference count for each variable. Clobbers left with no references
   // will be removed.
   SmallVector<int, 4> ReferenceCount;
   // Entries reference other entries by index. Offsets is used to remap these
   // references if any entries are removed.
   SmallVector<size_t, 4> Offsets;
 
+  LLVM_DEBUG(dbgs() << "Trimming location ranges for function '" << MF.getName()
+                    << "'\n");
+
   for (auto &Record : VarEntries) {
     auto &HistoryMapEntries = Record.second;
     if (HistoryMapEntries.empty())
       continue;
 
     InlinedEntity Entity = Record.first;
     const DILocalVariable *LocalVar = cast<DILocalVariable>(Entity.first);
 
for (auto EI = HistoryMapEntries.begin(), EE = HistoryMapEntries.end();
         // If the location range does not intersect any scope range then the
         // DBG_VALUE which opened this location range is usless, mark it for
         // removal.
         ToRemove.push_back(StartIndex);
         // Because we'll be removing this entry we need to update the reference
         // count of the closing entry, if one exists.
         if (EndIndex != NoEntry)
           ReferenceCount[EndIndex] -= 1;
+        LLVM_DEBUG(dbgs() << "Dropping value outside scope range of variable: ";
+                   StartMI->print(llvm::dbgs()););
       }
     }
 
     // If there is nothing to remove then jump to next variable.
     if (ToRemove.empty())
       continue;
 
     // Mark clobbers that will no longer close any location ranges for removal.
for (auto &Record : VarEntries) {
     for (auto &Entry : HistoryMapEntries)
       if (Entry.isClosed())
         Entry.EndIndex -= Offsets[Entry.EndIndex];
 
     // Now actually remove the entries. Iterate backwards so that our remaining
     // ToRemove indices are valid after each erase.
     for (EntryIndex Idx : llvm::reverse(ToRemove))
       HistoryMapEntries.erase(HistoryMapEntries.begin() + Idx);
+    LLVM_DEBUG(llvm::dbgs() << "New HistoryMap('" << LocalVar->getName()
+                            << "') size: " << HistoryMapEntries.size() << "\n");
   }
 }
 
 bool DbgValueHistoryMap::hasNonEmptyLocation(const Entries &Entries) const {
   for (const auto &Entry : Entries) {
     if (!Entry.isDbgValue())
       continue;
 
if (!MBB.empty() && &MBB != &MF->back()) {
 
       LiveEntries.clear();
       RegVars.clear();
     }
   }
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void DbgValueHistoryMap::dump() const {
-  dbgs() << "DbgValueHistoryMap:\n";
+LLVM_DUMP_METHOD void DbgValueHistoryMap::dump(StringRef FuncName) const {
+  dbgs() << "DbgValueHistoryMap('" << FuncName << "'):\n";
   for (const auto &VarRangePair : *this) {
     const InlinedEntity &Var = VarRangePair.first;
     const Entries &Entries = VarRangePair.second;
 
     const DILocalVariable *LocalVar = cast<DILocalVariable>(Var.first);
     const DILocation *Location = Var.second;
 
     dbgs() << " - " << LocalVar->getName() << " at ";

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
   // Calculate history for local variables.
   assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
   assert(DbgLabels.empty() && "DbgLabels map wasn't cleaned!");
   calculateDbgEntityHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
                             DbgValues, DbgLabels);
   InstOrdering.initialize(*MF);
   if (TrimVarLocs)
     DbgValues.trimLocationRanges(*MF, LScopes, InstOrdering);
-  LLVM_DEBUG(DbgValues.dump());
+  LLVM_DEBUG(DbgValues.dump(MF->getName()));
 
   // Request labels for the full history.
   for (const auto &I : DbgValues) {
     const auto &Entries = I.second;
     if (Entries.empty())
       continue;
 
     auto IsDescribedByReg = [](const MachineInstr *MI) {