[WIP][Example] Drop out-of-scope variable locations

[Orlando]

Summary

I have no intention of this code landing. It's a quick prototype I made for https://bugs.llvm.org/show_bug.cgi?id=45889.

This "feature" is enabled by default and you can turn it off with the llvm flag -disable-thing.

NOTE: This is based on top of the not-yet-landed D79571

[Orlando]

The real thing exists over at D82129 (landed).

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "dwarfdebug"
 
 STATISTIC(NumCSParams, "Number of dbg call site params created");
+STATISTIC(XXX_ExcludedRanges, "XXX Num DBG_VALUE ranges outside of the var scope");
+STATISTIC(XXX_ExcludeChecks, "XXX Range broken, exit checks");
+
+static cl::opt<bool> DisableThing("disable-thing", cl::init(false));
 
 static cl::opt<bool>
 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
                          cl::desc("Disable debug info printing"));
 
 static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier(
     "use-dwarf-ranges-base-address-specifier", cl::Hidden,
     cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
for (auto EB = Entries.begin(), EI = EB, EE = Entries.end(); EI != EE; ++EI) {
 
     if (EI->isDbgValue())
       LLVM_DEBUG(dbgs() << "DotDebugLoc: " << *Instr << "\n");
 
     // If this history map entry has a debug value, add that to the list of
     // open ranges and check if its location is valid for a single value
     // location.
     if (EI->isDbgValue()) {
+      // Return true if the var loc range being evaluated lives entirely outside
+      // its scope.
+      auto RangeExistsOutsideScope = [&]() -> bool {
+        XXX_ExcludeChecks++;
+        auto MBB = Instr->getParent();
+        auto DL = Instr->getDebugLoc();
+        LexicalScope *InstrScope = LScopes.findLexicalScope(DL);
+        // Scope doesn't exist?
+        if (!InstrScope)
+          return false;
+
+        DbgValueHistoryMap::EntryIndex EndIndex = EI->getEndIndex();
+        if (EndIndex == DbgValueHistoryMap::NoEntry)
+          // FIXME: I didn't want to think too hard about what to do here.
+          return false;
+        const DbgValueHistoryMap::Entry& End = Entries[EndIndex];
+        auto *EndInstr = End.getInstr();
+        // Make sure we're only looking in the same BB.
+        if (EndInstr->getParent() != Instr->getParent())
+          return false;
+
+        // FIXME: Is this necessary?
+        auto &LSRange = InstrScope->getRanges();
+        if (LSRange.size() == 0)
+          return false;
+
+        // Scan forwards; return false if we find any instruction which lives in
+        // a scope dominated by our DBG_VALUE's scope.
+        MachineBasicBlock::const_iterator Next(Instr);
+        MachineBasicBlock::const_iterator RangeEndInstr(EndInstr);
+        for (++Next; Next != MBB->end(); ++Next) {
+          auto NextDL = Next->getDebugLoc();
+          if (!NextDL)
+            // We don't know anything about this instr, let's just bail.
+            return false;
+          LexicalScope *NextScope = LScopes.findLexicalScope(NextDL);
+          if (!NextScope)
+            // We don't know anything about this instr, let's just bail.
+            return false;
+          // scope(Next) is child of scope(Instr) so do not omit this range.
+          if (InstrScope->dominates(NextScope))
+            // FIXME: This is too restrictive. If the range end is a DBG_VALUE
+            // in a scope dominated by Instr we'll exit here. Maybe we need
+            // a check like the one below (Next==RangeEndInstr) at the top
+            // of this loop?
+            //  if(!End.isClobber() && Next==RangeEndInstr)
+            //    return true;
+            return false;
+          if (Next == RangeEndInstr) {
+            XXX_ExcludedRanges++;
+            // We've got all the way to the range end without touching a
+            // dominated scope.
+            return true;
+          }
+        }
+
+        XXX_ExcludedRanges++;
+        return true;
+      };
+
+      if (!DisableThing && RangeExistsOutsideScope())
+        continue;
+
       // Do not add undef debug values, as they are redundant information in
       // the location list entries. An undef debug results in an empty location
       // description. If there are any non-undef fragments then padding pieces
       // with empty location descriptions will automatically be inserted, and if
       // all fragments are undef then the whole location list entry is
       // redundant.
       if (!Instr->isUndefDebugValue()) {
         auto Value = getDebugLocValue(Instr);
for (auto EB = Entries.begin(), EI = EB, EE = Entries.end(); EI != EE; ++EI) {
     if (OpenRanges.empty())
       continue;
 
     // Omit entries with empty ranges as they do not have any effect in DWARF.
     if (StartLabel == EndLabel) {
       LLVM_DEBUG(dbgs() << "Omitting location list entry with empty range.\n");
       continue;
     }
    
     SmallVector<DbgValueLoc, 4> Values;
     for (auto &R : OpenRanges)
       Values.push_back(R.second);
     DebugLoc.emplace_back(StartLabel, EndLabel, Values);
 
     // Attempt to coalesce the ranges of two otherwise identical
     // DebugLocEntries.
     auto CurEntry = DebugLoc.rbegin();