[DwarfDebug] Improve validThroughout performance (4/4)

[Orlando]

Summary

Almost NFC (see end).

The backwards scan in validThroughout significantly contributed to compile time
for a pathological case, causing the 'X86 Assembly Printer' pass to account for
roughly 70% of the run time. This patch guards the loop against running
unnecessarily for a common case, bringing the pass contribution down to 4%.

Almost NFC:
There is a hack in validThroughout which promotes single constant value
DBG_VALUEs in the prologue to be live throughout the function. We're more
likely to hit this code path with this patch applied. Similarly to the parent patches
there is a small coverage change reported in the order of 10s of bytes.

[Orlando]

Thank you @aprantl.

I think we can (should?) remove the cut-off added in D83236 when this lands - I was testing against the same pathological case when writing this patch. Is there any kind of approval process for that?

[aprantl]

In D86153#2225655, @Orlando wrote:

Thank you @aprantl.

I think we can (should?) remove the cut-off added in D83236 when this lands - I was testing against the same pathological case when writing this patch. Is there any kind of approval process for that?

Sounds good! @vsk?

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

static bool validThroughout(LexicalScopes &LScopes,
   auto *LScope = LScopes.findLexicalScope(DL);
   // Scope doesn't exist; this is a dead DBG_VALUE.
   if (!LScope)
     return false;
   auto &LSRange = LScope->getRanges();
   if (LSRange.size() == 0)
     return false;
 
-
-  // Determine if the DBG_VALUE is valid at the beginning of its lexical block.
   const MachineInstr *LScopeBegin = LSRange.front().first;
-  // Early exit if the lexical scope begins outside of the current block.
+  // If the scope starts before the DBG_VALUE then we may have a negative
+  // result. Otherwise the location is live coming into the scope and we
+  // can skip the following checks.
+  if (!Ordering.isBefore(DbgValue, LScopeBegin)) {
+    // Exit if the lexical scope begins outside of the current block.
     if (LScopeBegin->getParent() != MBB)
       return false;
 
     MachineBasicBlock::const_reverse_iterator Pred(DbgValue);
     for (++Pred; Pred != MBB->rend(); ++Pred) {
       if (Pred->getFlag(MachineInstr::FrameSetup))
         break;
       auto PredDL = Pred->getDebugLoc();
       if (!PredDL || Pred->isMetaInstruction())
         continue;
       // Check whether the instruction preceding the DBG_VALUE is in the same
       // (sub)scope as the DBG_VALUE.
       if (DL->getScope() == PredDL->getScope())
         return false;
       auto *PredScope = LScopes.findLexicalScope(PredDL);
       if (!PredScope || LScope->dominates(PredScope))
         return false;
     }
+  }
 
   // If the range of the DBG_VALUE is open-ended, report success.
   if (!RangeEnd)
     return true;
 
   // Single, constant DBG_VALUEs in the prologue are promoted to be live
   // throughout the function. This is a hack, presumably for DWARF v2 and not
   // necessarily correct. It would be much better to use a dbg.declare instead