From 0d4331af6e01235479e44f9775b3fde9e19200a3 Mon Sep 17 00:00:00 2001

From: Keith Walker <kwalker@arm.com>

Date: Tue, 27 Sep 2016 16:46:07 +0000

Subject: [rust-lang/llvm#53 1/2] Propagate DBG_VALUE entries when there are

 unvisited predecessors

Variables are sometimes missing their debug location information in

blocks in which the variables should be available. This would occur

when one or more predecessor blocks had not yet been visited by the

routine which propagated the information from predecessor blocks.

This is addressed by only considering predecessor blocks which have

already been visited.

The solution to this problem was suggested by Daniel Berlin on the

LLVM developer mailing list.

Differential Revision: https://reviews.llvm.org/D24927

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@282506 91177308-0d34-0410-b5e6-96231b3b80d8

---

 lib/CodeGen/LiveDebugValues.cpp          |  34 ++--

 test/CodeGen/ARM/dbg-range-extension.mir | 282 +++++++++++++++++++++++++++++++

 2 files changed, 306 insertions(+), 10 deletions(-)

 create mode 100644 test/CodeGen/ARM/dbg-range-extension.mir

diff --git a/lib/CodeGen/LiveDebugValues.cpp b/lib/CodeGen/LiveDebugValues.cpp

index 4ff88d528108..4cadd5855ed5 100644

--- a/lib/CodeGen/LiveDebugValues.cpp

+++ b/lib/CodeGen/LiveDebugValues.cpp

@@ -201,7 +201,8 @@ private:

                 VarLocInMBB &OutLocs, VarLocMap &VarLocIDs);

   bool join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs, VarLocInMBB &InLocs,

-            const VarLocMap &VarLocIDs);

+            const VarLocMap &VarLocIDs,

+            SmallPtrSet<const MachineBasicBlock *, 16> &Visited);

   bool ExtendRanges(MachineFunction &MF;;

@@ -368,7 +369,8 @@ bool LiveDebugValues::transfer(MachineInstr &MI, OpenRangesSet &OpenRanges,

 /// inserting a new DBG_VALUE instruction at the start of the @MBB - if the same

 /// source variable in all the predecessors of @MBB reside in the same location.

 bool LiveDebugValues::join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs,

-                           VarLocInMBB &InLocs, const VarLocMap &VarLocIDs) {

+                           VarLocInMBB &InLocs, const VarLocMap &VarLocIDs,

+                           SmallPtrSet<const MachineBasicBlock *, 16> &Visited) {

   DEBUG(dbgs() << "join MBB: " << MBB.getName() << "\n");

   bool Changed = false;

@@ -376,21 +378,32 @@ bool LiveDebugValues::join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs,

   // For all predecessors of this MBB, find the set of VarLocs that

   // can be joined.

+  int NumVisited = 0;

   for (auto p : MBB.predecessors()) {

+    // Ignore unvisited predecessor blocks.  As we are processing

+    // the blocks in reverse post-order any unvisited block can

+    // be considered to not remove any incoming values.

+    if (!Visited.count(p))

+      continue;

     auto OL = OutLocs.find(p);

     // Join is null in case of empty OutLocs from any of the pred.

     if (OL == OutLocs.end())

       return false;

-    // Just copy over the Out locs to incoming locs for the first predecessor.

-    if (p == *MBB.pred_begin()) {

+    // Just copy over the Out locs to incoming locs for the first visited

+    // predecessor, and for all other predecessors join the Out locs.

+    if (!NumVisited)

       InLocsT = OL->second;

-      continue;

-    }

-    // Join with this predecessor.

-    InLocsT &= OL->second;

+    else

+      InLocsT &= OL->second;

+    NumVisited++;

   }

+  // As we are processing blocks in reverse post-order we

+  // should have processed at least one predecessor, unless it

+  // is the entry block which has no predecessor.

+  assert((NumVisited || MBB.pred_empty()) &&

+         "Should have processed at least one predecessor");

   if (InLocsT.empty())

     return false;

@@ -463,6 +476,7 @@ bool LiveDebugValues::ExtendRanges(MachineFunction &MF) {

   // To solve it, we perform join() and transfer() using the two worklist method

   // until the ranges converge.

   // Ranges have converged when both worklists are empty.

+  SmallPtrSet<const MachineBasicBlock *, 16> Visited;

   while (!Worklist.empty() || !Pending.empty()) {

     // We track what is on the pending worklist to avoid inserting the same

     // thing twice.  We could avoid this with a custom priority queue, but this

@@ -471,8 +485,8 @@ bool LiveDebugValues::ExtendRanges(MachineFunction &MF) {

     while (!Worklist.empty()) {

       MachineBasicBlock *MBB = OrderToBB[Worklist.top()];

       Worklist.pop();

-      MBBJoined = join(*MBB, OutLocs, InLocs, VarLocIDs);

-

+      MBBJoined = join(*MBB, OutLocs, InLocs, VarLocIDs, Visited);

+      Visited.insert(MBB);

       if (MBBJoined) {

         MBBJoined = false;

         Changed = true;

-- 

2.7.4

From 8a0fc26559123bb6eab3ceae93d5a2c94943614b Mon Sep 17 00:00:00 2001

From: Adrian Prantl <aprantl@apple.com>

Date: Wed, 28 Sep 2016 17:51:14 +0000

Subject: [rust-lang/llvm#53 2/2] Teach LiveDebugValues about lexical scopes.

This addresses PR26055 LiveDebugValues is very slow.

Contrary to the old LiveDebugVariables pass LiveDebugValues currently

doesn't look at the lexical scopes before inserting a DBG_VALUE

intrinsic. This means that we often propagate DBG_VALUEs much further

down than necessary. This is especially noticeable in large C++

functions with many inlined method calls that all use the same

"this"-pointer.

For example, in the following code it makes no sense to propagate the

inlined variable a from the first inlined call to f() into any of the

subsequent basic blocks, because the variable will always be out of

scope:

void sink(int a);

void __attribute((always_inline)) f(int a) { sink(a); }

void foo(int i) {

   f(i);

   if (i)

     f(i);

   f(i);

}

This patch reuses the LexicalScopes infrastructure we have for

LiveDebugVariables to take this into account.

The effect on compile time and memory consumption is quite noticeable:

I tested a benchmark that is a large C++ source with an enormous

amount of inlined "this"-pointers that would previously eat >24GiB

(most of them for DBG_VALUE intrinsics) and whose compile time was

dominated by LiveDebugValues. With this patch applied the memory

consumption is 1GiB and 1.7% of the time is spent in LiveDebugValues.

https://reviews.llvm.org/D24994

Thanks to Daniel Berlin and Keith Walker for reviewing!

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@282611 91177308-0d34-0410-b5e6-96231b3b80d8

---

 lib/CodeGen/LiveDebugValues.cpp                  |  51 ++++-

 test/CodeGen/ARM/dbg-range-extension.mir         |   1 -

 test/DebugInfo/COFF/register-variables.ll        |   8 +-

 test/DebugInfo/MIR/X86/livedebugvalues-limit.mir | 228 +++++++++++++++++++++++

 test/DebugInfo/X86/fission-ranges.ll             |   6 +-

 5 files changed, 278 insertions(+), 16 deletions(-)

 create mode 100644 test/DebugInfo/MIR/X86/livedebugvalues-limit.mir

diff --git a/lib/CodeGen/LiveDebugValues.cpp b/lib/CodeGen/LiveDebugValues.cpp

index 4cadd5855ed5..969944eb24a2 100644

--- a/lib/CodeGen/LiveDebugValues.cpp

+++ b/lib/CodeGen/LiveDebugValues.cpp

@@ -23,6 +23,7 @@

 #include "llvm/ADT/SparseBitVector.h"

 #include "llvm/ADT/Statistic.h"

 #include "llvm/ADT/UniqueVector.h"

+#include "llvm/CodeGen/LexicalScopes.h"

 #include "llvm/CodeGen/MachineFunction.h"

 #include "llvm/CodeGen/MachineFunctionPass.h"

 #include "llvm/CodeGen/MachineInstrBuilder.h"

@@ -60,6 +61,26 @@ class LiveDebugValues : public MachineFunctionPass {

 private:

   const TargetRegisterInfo *TRI;

   const TargetInstrInfo *TII;

+  LexicalScopes LS;

+

+  /// Keeps track of lexical scopes associated with a user value's source

+  /// location.

+  class UserValueScopes {

+    DebugLoc DL;

+    LexicalScopes &LS;

+    SmallPtrSet<const MachineBasicBlock *, 4> LBlocks;

+

+  public:

+    UserValueScopes(DebugLoc D, LexicalScopes &L) : DL(std::move(D)), LS(L) {}

+

+    /// Return true if current scope dominates at least one machine

+    /// instruction in a given machine basic block.

+    bool dominates(MachineBasicBlock *MBB) {

+      if (LBlocks.empty())

+        LS.getMachineBasicBlocks(DL, LBlocks);

+      return LBlocks.count(MBB) != 0 || LS.dominates(DL, MBB);

+    }

+  };

   /// Based on std::pair so it can be used as an index into a DenseMap.

   typedef std::pair<const DILocalVariable *, const DILocation *>

@@ -83,7 +104,7 @@ private:

   struct VarLoc {

     const DebugVariable Var;

     const MachineInstr &MI; ///< Only used for cloning a new DBG_VALUE.

-

+    mutable UserValueScopes UVS;

     enum { InvalidKind = 0, RegisterKind } Kind;

     /// The value location. Stored separately to avoid repeatedly

@@ -96,9 +117,9 @@ private:

       uint64_t Hash;

     } Loc;

-    VarLoc(const MachineInstr &MI)

+    VarLoc(const MachineInstr &MI, LexicalScopes &LS)

         : Var(MI.getDebugVariable(), MI.getDebugLoc()->getInlinedAt()), MI(MI),

-          Kind(InvalidKind) {

+          UVS(MI.getDebugLoc(), LS), Kind(InvalidKind) {

       static_assert((sizeof(Loc) == sizeof(uint64_t)),

                     "hash does not cover all members of Loc");

       assert(MI.isDebugValue() && "not a DBG_VALUE");

@@ -125,6 +146,10 @@ private:

       return 0;

     }

+    /// Determine whether the lexical scope of this value's debug location

+    /// dominates MBB.

+    bool dominates(MachineBasicBlock &MBB) const { return UVS.dominates(&MBB); }

+

     void dump() const { MI.dump(); }

     bool operator==(const VarLoc &Other) const {

@@ -229,6 +254,7 @@ public:

   /// Calculate the liveness information for the given machine function.

   bool runOnMachineFunction(MachineFunction &MF) override;

 };

+

 } // namespace

 //===----------------------------------------------------------------------===//

@@ -295,7 +321,7 @@ void LiveDebugValues::transferDebugValue(const MachineInstr &MI,

   // Add the VarLoc to OpenRanges from this DBG_VALUE.

   // TODO: Currently handles DBG_VALUE which has only reg as location.

   if (isDbgValueDescribedByReg(MI)) {

-    VarLoc VL(MI);

+    VarLoc VL(MI, LS);

     unsigned ID = VarLocIDs.insert(VL);

     OpenRanges.insert(ID, VL.Var);

   }

@@ -399,6 +425,13 @@ bool LiveDebugValues::join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs,

     NumVisited++;

   }

+  // Filter out DBG_VALUES that are out of scope.

+  VarLocSet KillSet;

+  for (auto ID : InLocsT)

+    if (!VarLocIDs[ID].dominates(MBB))

+      KillSet.set(ID);

+  InLocsT.intersectWithComplement(KillSet);

+

   // As we are processing blocks in reverse post-order we

   // should have processed at least one predecessor, unless it

   // is the entry block which has no predecessor.

@@ -519,12 +552,14 @@ bool LiveDebugValues::ExtendRanges(MachineFunction &MF) {

 }

 bool LiveDebugValues::runOnMachineFunction(MachineFunction &MF) {

+  if (!MF.getFunction()->getSubprogram())

+    // LiveDebugValues will already have removed all DBG_VALUEs.

+    return false;

+

   TRI = MF.getSubtarget().getRegisterInfo();

   TII = MF.getSubtarget().getInstrInfo();

+  LS.initialize(MF);

-  bool Changed = false;

-

-  Changed |= ExtendRanges(MF);

-

+  bool Changed = ExtendRanges(MF);

   return Changed;

 }

diff --git a/test/DebugInfo/COFF/register-variables.ll b/test/DebugInfo/COFF/register-variables.ll

index 9bb782853a3d..08246fef9603 100644

--- a/test/DebugInfo/COFF/register-variables.ll

+++ b/test/DebugInfo/COFF/register-variables.ll

@@ -37,8 +37,8 @@

 ; ASM:         #DEBUG_VALUE: c <- %EAX

 ; ASM:         testl   %esi, %esi

 ; ASM:         je      .LBB0_2

+; ASM: [[after_je:\.Ltmp.*]]:

 ; ASM: # BB#1:                                 # %if.then

-; ASM-DAG:     #DEBUG_VALUE: c <- %EAX

 ; ASM-DAG:     #DEBUG_VALUE: inlineinc:a <- %EAX

 ; ASM-DAG:     #DEBUG_VALUE: a <- %EAX

 ; ASM-DAG:     #DEBUG_VALUE: f:p <- %ESI

@@ -65,7 +65,7 @@

 ; ASM:         .cv_def_range    [[after_getint]] [[after_inc_eax]], "A\021\021\000\000\000"

 ; ASM:         .short  4414                    # Record kind: S_LOCAL

 ; ASM:         .asciz  "c"

-; ASM:         .cv_def_range    [[after_getint]] [[after_inc_eax]], "A\021\021\000\000\000"

+; ASM:         .cv_def_range    [[after_getint]] [[after_je]], "A\021\021\000\000\000"

 ; ASM:         .short  4414                    # Record kind: S_LOCAL

 ; ASM:         .asciz  "b"

 ; ASM:         .cv_def_range    [[after_inc_eax]] [[after_if]], "A\021\021\000\000\000"

@@ -132,7 +132,7 @@

 ; OBJ:     LocalVariableAddrRange {

 ; OBJ:       OffsetStart: .text+0xC

 ; OBJ:       ISectStart: 0x0

-; OBJ:       Range: 0x6

+; OBJ:       Range: 0x4

 ; OBJ:     }

 ; OBJ:   }

 ; OBJ:   Local {

@@ -143,7 +143,7 @@

 ; OBJ:   }

 ; OBJ:   DefRangeRegister {

 ; OBJ:     Register: 17

-; OBJ:     LocalVariableAddrRange {

+; OBJ:     MayHaveNoName: 0

 ; OBJ:       OffsetStart: .text+0x12

 ; OBJ:       ISectStart: 0x0

 ; OBJ:       Range: 0x6

diff --git a/test/DebugInfo/X86/fission-ranges.ll b/test/DebugInfo/X86/fission-ranges.ll

index 3c05f223ee79..0dfb13ab66b7 100644

--- a/test/DebugInfo/X86/fission-ranges.ll

+++ b/test/DebugInfo/X86/fission-ranges.ll

@@ -32,13 +32,13 @@

 ; CHECK-NEXT:                    Length: 25

 ; CHECK-NEXT:      Location description: 50 93 04

 ; CHECK: [[E]]: Beginning address index: 4

-; CHECK-NEXT:                    Length: 23

+; CHECK-NEXT:                    Length: 19

 ; CHECK-NEXT:      Location description: 50 93 04

 ; CHECK: [[B]]: Beginning address index: 5

-; CHECK-NEXT:                    Length: 21

+; CHECK-NEXT:                    Length: 17

 ; CHECK-NEXT:      Location description: 50 93 04

 ; CHECK: [[D]]: Beginning address index: 6

-; CHECK-NEXT:                    Length: 21

+; CHECK-NEXT:                    Length: 17

 ; CHECK-NEXT:      Location description: 50 93 04

 ; Make sure we don't produce any relocations in any .dwo section (though in particular, debug_info.dwo)

-- 

2.7.4