[LiveDebugVariables] Use lexical scope to trim debug value live intervals

[rob.lougher]

Summary

This is a fix for PR33730.

The following program causes Live Debug Variables to emit unnecessary debug values:

extern int foobar(int, int, int, int, int);

int F(int i1, int i2, int i3, int i4, int i5) {
  return foobar(i1, i2, i3, i4, i5);
}

int foo(int a, int b, int c, int d, int e) {
  return F(a,b,c,d,e) +
         F(a,b,c,d,e) +
         F(a,b,c,d,e) +
         F(a,b,c,d,e);
}

$ clang foo.c -c -O2 -g -emit-llvm
$ llc foo.bc -print-after virtregrewriter 2>&1 | grep DBG_VALUE | grep i4 | grep 8:10

		DBG_VALUE %EBX, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:8:10 ]
		DBG_VALUE <fi#2>, 0, !"i4", <!17>; line no:3 inlined @[ foo.c:8:10 ]
		DBG_VALUE %EBP, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:8:10 ]

According to this the first inlined "i4" parameter is in 3 registers (in fact, on entry it is only in %EBX). This can also be seen in the DWARF output, where the debug location ends up with 3 entries:

0x00000110:     DW_TAG_inlined_subroutine [9] *
                  DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x0061 => {0x00000061} "F")
                  DW_AT_low_pc [DW_FORM_addr]	(0x000000000000002f)
                  DW_AT_high_pc [DW_FORM_data4]	(0x00000009)
                  DW_AT_call_file [DW_FORM_data1]	("foo.c")
                  DW_AT_call_line [DW_FORM_data1]	(8)

0x0000013e:       DW_TAG_formal_parameter [10]  
                    DW_AT_location [DW_FORM_sec_offset]	(0x00000312)
                    DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x008e => {0x0000008e} "i4")
...
.debug_loc contents:
...
0x00000312: Beginning address offset: 0x000000000000002f
               Ending address offset: 0x0000000000000046
                Location description: 53 

            Beginning address offset: 0x0000000000000046
               Ending address offset: 0x0000000000000065
                Location description: 77 0c 

            Beginning address offset: 0x0000000000000065
               Ending address offset: 0x000000000000009a
                Location description: 56

Similarly, "i4"s debug value for the second, third and fourth inlining also show the same 3 DBG_VALUES:

$ llc foo.bc -print-after virtregrewriter 2>&1 | grep DBG_VALUE | grep i4 | grep 9:10

		DBG_VALUE %EBX, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:9:10 ]
		DBG_VALUE <fi#2>, 0, !"i4", <!17>; line no:3 inlined @[ foo.c:9:10 ]
		DBG_VALUE %EBP, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:9:10 ]
...

The problem is caused by the live intervals assigned to the debug values by Live Debug Variables. All four inlined debug values for "i4" share the same virtual register. The live interval spans all the inlined callsites, although each inlined instance accounts for only a region of the full range. The register allocator later splits the virtual register, and as each debug value is associated with the entire live range they are also split, creating a number of intervals per value. Later, debug values are emitted for each of the intervals, although most of the intervals are outside the inlined instance.

Splitting of the debug values can also create a compile-time explosion. If the above program is modified to create 1500 inlined calls, the program takes over 40 minutes to compile with -g (3.5 GHz Core-i7) and Live Debug Variables inserts over 6 million DBG_VALUEs (see PR33730 for further details).

This patch fixes the problem by using the lexical scope of the inlined debug locations to "trim" the debug value live intervals. After this we generate a single debug value:

$ llc foo.bc -print-after virtregrewriter 2>&1 | grep DBG_VALUE | grep i4 | grep 8:10

		DBG_VALUE %EBX, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:8:10 ]

The DWARF also now contains a single entry in the debug location:

0x00000110:     DW_TAG_inlined_subroutine [9] *
                  DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x0061 => {0x00000061} "F")
                  DW_AT_low_pc [DW_FORM_addr]	(0x000000000000002f)
                  DW_AT_high_pc [DW_FORM_data4]	(0x00000009)
                  DW_AT_call_file [DW_FORM_data1]	("foo.c")
                  DW_AT_call_line [DW_FORM_data1]	(8)

                    DW_AT_location [DW_FORM_sec_offset]	(0x0000017f)
                    DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x008e => {0x0000008e} "i4")
...
.debug_loc contents:
...
0x0000017f: Beginning address offset: 0x000000000000002f
               Ending address offset: 0x000000000000004c
                Location description: 53

The other inlined debug values for "i4" now also show the correct values:

$ llc foo.bc -print-after virtregrewriter 2>&1 | grep DBG_VALUE | grep i4 | grep 9:10

		DBG_VALUE %EBX, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:9:10 ]
		DBG_VALUE <fi#2>, 0, !"i4", <!17>; line no:3 inlined @[ foo.c:9:10 ]

$ llc foo.bc -print-after virtregrewriter 2>&1 | grep DBG_VALUE | grep i4 | grep 10:10

		DBG_VALUE <fi#2>, 0, !"i4", <!17>; line no:3 inlined @[ foo.c:10:10 ]
		DBG_VALUE %EBP, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:10:10 ]

$ llc foo.bc -print-after virtregrewriter 2>&1 | grep DBG_VALUE | grep i4 | grep 11:10

		DBG_VALUE %EBP, %noreg, !"i4", <!17>; line no:3 inlined @[ foo.c:11:10 ]

[aprantl]

lib/CodeGen/LiveDebugVariables.cpp

692

I would personally prefer a short summary of the problem over a reference to a PR.

[aprantl]

lib/CodeGen/LiveDebugVariables.cpp

107

///

694

Why only do this for inlined variables? Couldn't non-inlined variables also benefit from being trimmed at their lexical scope's end? Or is this situation impossible for non-inlined variables?

704

Can you add a high-level comment here what the loop is doing?

[probinson]

lib/CodeGen/LiveDebugVariables.cpp

25

Not in alphabetical order.

32

Not in alphabetical order.

[aprantl]

lib/CodeGen/LiveDebugVariables.cpp

707

could you run the patch through clang-format?

[rob.lougher]

Address review comments. Now enabled for non-inlined variables. This required fixing a test to make it more resilient (it checks that we get the expected number of debug values, but was also enforcing a specific order). I've also changed where the LexicalScopes are generated, as they're only needed when computing the intervals.

[aprantl]

Small nitpick on the test, but otherwise this looks good now, thanks!

test/DebugInfo/X86/live-debug-variables.ll

25

If you are only checking for i4, why are all the other dbg.values necessary? I would expect that we either check for them, too, or that we can remove them to keep the test simple.

lib/CodeGen/LiveDebugVariables.cpp

 // are moved between registers and stack slots. Finally emit new DBG_VALUE
 // instructions after register allocation is complete.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LiveDebugVariables.h"
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/CodeGen/LiveIntervalAnalysis.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/LexicalScopes.h"
 #include "llvm/CodeGen/VirtRegMap.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
class UserValue {
   UserValue *next;        ///< Next value in equivalence class, or null.
 
   /// Numbered locations referenced by locmap.
   SmallVector<MachineOperand, 4> locations;
 
   /// Map of slot indices where this value is live.
   LocMap locInts;
 
+  // Set of interval start indexes that have been trimmed to the
+  // lexical scope.
+  SmallSet<SlotIndex, 2> trimmedDefs;
+
   /// coalesceLocation - After LocNo was changed, check if it has become
   /// identical to another location, and coalesce them. This may cause LocNo or
   /// a later location to be erased, but no earlier location will be erased.
   void coalesceLocation(unsigned LocNo);
 
   /// insertDebugValue - Insert a DBG_VALUE into MBB at Idx for LocNo.
   void insertDebugValue(MachineBasicBlock *MBB, SlotIndex Idx, unsigned LocNo,
                         LiveIntervals &LIS, const TargetInstrInfo &TII);
void addDefsFromCopies(LiveInterval *LI, unsigned LocNo,
                       const SmallVectorImpl<SlotIndex> &Kills,
                       SmallVectorImpl<std::pair<SlotIndex, unsigned> > &NewDefs,
                       MachineRegisterInfo &MRI,
                       LiveIntervals &LIS);
 
   /// computeIntervals - Compute the live intervals of all locations after
   /// collecting all their def points.
   void computeIntervals(MachineRegisterInfo &MRI, const TargetRegisterInfo &TRI,
-                        LiveIntervals &LIS);
+                        LiveIntervals &LIS, LexicalScopes &LS);
 
   /// splitRegister - Replace OldReg ranges with NewRegs ranges where NewRegs is
   /// live. Returns true if any changes were made.
   bool splitRegister(unsigned OldLocNo, ArrayRef<unsigned> NewRegs,
                      LiveIntervals &LIS);
 
   /// rewriteLocations - Rewrite virtual register locations according to the
   /// provided virtual register map.

 /// LDVImpl - Implementation of the LiveDebugVariables pass.
 namespace {
 class LDVImpl {
   LiveDebugVariables &pass;
   LocMap::Allocator allocator;
   MachineFunction *MF;
   LiveIntervals *LIS;
   const TargetRegisterInfo *TRI;
+  LexicalScopes LS;
 
   /// Whether emitDebugValues is called.
   bool EmitDone;
   /// Whether the machine function is modified during the pass.
   bool ModifiedMF;
 
   /// userValues - All allocated UserValue instances.
   SmallVector<std::unique_ptr<UserValue>, 8> userValues;
for (unsigned j = 0, e = CopyValues.size(); j != e; ++j) {
       break;
     }
   }
 }
 
 void
 UserValue::computeIntervals(MachineRegisterInfo &MRI,
                             const TargetRegisterInfo &TRI,
-                            LiveIntervals &LIS) {
+                            LiveIntervals &LIS,
+                            LexicalScopes &LS) {
   SmallVector<std::pair<SlotIndex, unsigned>, 16> Defs;
 
   // Collect all defs to be extended (Skipping undefs).
   for (LocMap::const_iterator I = locInts.begin(); I.valid(); ++I)
     if (I.value() != ~0u)
       Defs.push_back(std::make_pair(I.start(), I.value()));
 
   // Extend all defs, and possibly add new ones along the way.
for (unsigned i = 0; i != Defs.size(); ++i) {
     // For physregs, use the live range of the first regunit as a guide.
     unsigned Unit = *MCRegUnitIterator(Loc.getReg(), &TRI);
     LiveRange *LR = &LIS.getRegUnit(Unit);
     const VNInfo *VNI = LR->getVNInfoAt(Idx);
     // Don't track copies from physregs, it is too expensive.
     extendDef(Idx, LocNo, LR, VNI, nullptr, LIS);
   }
 
-  // Finally, erase all the undefs.
+  // Erase all the undefs.
   for (LocMap::iterator I = locInts.begin(); I.valid();)
     if (I.value() == ~0u)
       I.erase();
     else
       ++I;
+
+  // If the user value has been inlined trim the computed intervals
+  // to the inlined lexical scope (see PR33730).
+
+  if (!dl->getInlinedAt())
+    return;
+
+  LexicalScope *Scope = LS.findLexicalScope(dl);
+  if (!Scope)
+    return;
+  
+  SlotIndex PrevEnd;
+  LocMap::iterator I = locInts.begin();
+
+  for(const InsnRange &R : Scope->getRanges()) {
+    SlotIndex RStart = LIS.getInstructionIndex(*R.first);
+
+    if(PrevEnd && I.start() < PrevEnd) {
+      SlotIndex IStop = I.stop();
+      unsigned LocNo = I.value();
+
+      I.setStopUnchecked(PrevEnd);
+      ++I;
+
+      if(RStart < IStop)
+        I.insert(RStart, IStop, LocNo);
+    }
+
+    I.advanceTo(RStart);
+    if(!I.valid())
+      return;
+
+    if (I.start() < RStart) {
+      I.setStartUnchecked(RStart);
+      // Remember that this interval was trimmed.
+      trimmedDefs.insert(RStart);
+    }
+
+    PrevEnd = LIS.getInstructionIndex(*R.second);
+    PrevEnd = PrevEnd.getNextIndex();
+
+    I.advanceTo(PrevEnd);
+    if(!I.valid())
+      return;
+  }
+
+  if(PrevEnd && I.start() < PrevEnd)
+    I.setStopUnchecked(PrevEnd);
 }
 
 void LDVImpl::computeIntervals() {
   for (unsigned i = 0, e = userValues.size(); i != e; ++i) {
-    userValues[i]->computeIntervals(MF->getRegInfo(), *TRI, *LIS);
+    userValues[i]->computeIntervals(MF->getRegInfo(), *TRI, *LIS, LS);
     userValues[i]->mapVirtRegs(this);
   }
 }
 
 bool LDVImpl::runOnMachineFunction(MachineFunction &mf) {
   clear();
   MF = &mf;
+  LS.initialize(mf);
   LIS = &pass.getAnalysis<LiveIntervals>();
   TRI = mf.getSubtarget().getRegisterInfo();
   DEBUG(dbgs() << "********** COMPUTING LIVE DEBUG VARIABLES: "
                << mf.getName() << " **********\n");
 
   bool Changed = collectDebugValues(mf);
   computeIntervals();
   DEBUG(print(dbgs()));

 void UserValue::emitDebugValues(VirtRegMap *VRM, LiveIntervals &LIS,
                                 const TargetInstrInfo &TII) {
   MachineFunction::iterator MFEnd = VRM->getMachineFunction().end();
 
   for (LocMap::const_iterator I = locInts.begin(); I.valid();) {
     SlotIndex Start = I.start();
     SlotIndex Stop = I.stop();
     unsigned LocNo = I.value();
+
+    // If the interval start was trimmed to the lexical scope insert the
+    // DBG_VALUE at the previous index (otherwise it appears after the
+    // first instruction in the range).
+    if (trimmedDefs.count(Start))
+      Start = Start.getPrevIndex();
+
     DEBUG(dbgs() << "\t[" << Start << ';' << Stop << "):" << LocNo);
     MachineFunction::iterator MBB = LIS.getMBBFromIndex(Start)->getIterator();
     SlotIndex MBBEnd = LIS.getMBBEndIdx(&*MBB);
 
     DEBUG(dbgs() << " BB#" << MBB->getNumber() << '-' << MBBEnd);
     insertDebugValue(&*MBB, Start, LocNo, LIS, TII);
     // This interval may span multiple basic blocks.
     // Insert a DBG_VALUE into each one.

test/DebugInfo/X86/live-debug-variables.ll

+; RUN: llc -mtriple=x86_64-linux-gnu -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
+
+; The test inlines the function F four times, generating four inlined debug
+; values for "i4" all of which refer to the same virtual register. This
+; virtual register is then split by the register allocator. Check that this
+; does not generate multiple entries within the debug location (see PR33730).
+;
+; Generated from:
+;
+; extern int foobar(int, int, int, int, int);
+; 
+; int F(int i1, int i2, int i3, int i4, int i5) {
+;   return foobar(i1, i2, i3, i4, i5);
+; }
+; 
+; int foo(int a, int b, int c, int d, int e) {
+;   return F(a,b,c,d,e) +
+;          F(a,b,c,d,e) +
+;          F(a,b,c,d,e) +
+;          F(a,b,c,d,e);
+; }
+
+; CHECK: DW_TAG_inlined_subroutine
+; CHECK: DW_AT_location [DW_FORM_sec_offset] ([[LOC:0x[0-9a-f]+]]){{[[:space:]].*}} "i4"
+; CHECK: [[LOC]]: Beginning address offset
+; CHECK-NOT: Beginning address offset
+; CHECK: 0x{{[0-9a-f]+}}: Beginning address offset
+
+define i32 @F(i32 %i1, i32 %i2, i32 %i3, i32 %i4, i32 %i5) !dbg !7 {
+entry:
+  tail call void @llvm.dbg.value(metadata i32 %i1, i64 0, metadata !12, metadata !17), !dbg !18
+  tail call void @llvm.dbg.value(metadata i32 %i2, i64 0, metadata !13, metadata !17), !dbg !19
+  tail call void @llvm.dbg.value(metadata i32 %i3, i64 0, metadata !14, metadata !17), !dbg !20
+  tail call void @llvm.dbg.value(metadata i32 %i4, i64 0, metadata !15, metadata !17), !dbg !21
+  tail call void @llvm.dbg.value(metadata i32 %i5, i64 0, metadata !16, metadata !17), !dbg !22
+  %call = tail call i32 @foobar(i32 %i1, i32 %i2, i32 %i3, i32 %i4, i32 %i5) #3, !dbg !23
+  ret i32 %call, !dbg !24
+}
+
+declare i32 @foobar(i32, i32, i32, i32, i32)
+
+define i32 @foo(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) !dbg !25 {
+entry:
+  tail call void @llvm.dbg.value(metadata i32 %a, i64 0, metadata !27, metadata !17), !dbg !32
+  tail call void @llvm.dbg.value(metadata i32 %b, i64 0, metadata !28, metadata !17), !dbg !33
+  tail call void @llvm.dbg.value(metadata i32 %c, i64 0, metadata !29, metadata !17), !dbg !34
+  tail call void @llvm.dbg.value(metadata i32 %d, i64 0, metadata !30, metadata !17), !dbg !35
+  tail call void @llvm.dbg.value(metadata i32 %e, i64 0, metadata !31, metadata !17), !dbg !36
+  tail call void @llvm.dbg.value(metadata i32 %a, i64 0, metadata !12, metadata !17) #3, !dbg !37
+  tail call void @llvm.dbg.value(metadata i32 %b, i64 0, metadata !13, metadata !17) #3, !dbg !39
+  tail call void @llvm.dbg.value(metadata i32 %c, i64 0, metadata !14, metadata !17) #3, !dbg !40
+  tail call void @llvm.dbg.value(metadata i32 %d, i64 0, metadata !15, metadata !17) #3, !dbg !41
+  tail call void @llvm.dbg.value(metadata i32 %e, i64 0, metadata !16, metadata !17) #3, !dbg !42
+  %call.i = tail call i32 @foobar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #3, !dbg !43
+  tail call void @llvm.dbg.value(metadata i32 %a, i64 0, metadata !12, metadata !17) #3, !dbg !44
+  tail call void @llvm.dbg.value(metadata i32 %b, i64 0, metadata !13, metadata !17) #3, !dbg !46
+  tail call void @llvm.dbg.value(metadata i32 %c, i64 0, metadata !14, metadata !17) #3, !dbg !47
+  tail call void @llvm.dbg.value(metadata i32 %d, i64 0, metadata !15, metadata !17) #3, !dbg !48
+  tail call void @llvm.dbg.value(metadata i32 %e, i64 0, metadata !16, metadata !17) #3, !dbg !49
+  %call.i21 = tail call i32 @foobar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #3, !dbg !50
+  %add = add nsw i32 %call.i21, %call.i, !dbg !51
+  tail call void @llvm.dbg.value(metadata i32 %a, i64 0, metadata !12, metadata !17) #3, !dbg !52
+  tail call void @llvm.dbg.value(metadata i32 %b, i64 0, metadata !13, metadata !17) #3, !dbg !54
+  tail call void @llvm.dbg.value(metadata i32 %c, i64 0, metadata !14, metadata !17) #3, !dbg !55
+  tail call void @llvm.dbg.value(metadata i32 %d, i64 0, metadata !15, metadata !17) #3, !dbg !56
+  tail call void @llvm.dbg.value(metadata i32 %e, i64 0, metadata !16, metadata !17) #3, !dbg !57
+  %call.i22 = tail call i32 @foobar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #3, !dbg !58
+  %add3 = add nsw i32 %add, %call.i22, !dbg !59
+  tail call void @llvm.dbg.value(metadata i32 %a, i64 0, metadata !12, metadata !17) #3, !dbg !60
+  tail call void @llvm.dbg.value(metadata i32 %b, i64 0, metadata !13, metadata !17) #3, !dbg !62
+  tail call void @llvm.dbg.value(metadata i32 %c, i64 0, metadata !14, metadata !17) #3, !dbg !63
+  tail call void @llvm.dbg.value(metadata i32 %d, i64 0, metadata !15, metadata !17) #3, !dbg !64
+  tail call void @llvm.dbg.value(metadata i32 %e, i64 0, metadata !16, metadata !17) #3, !dbg !65
+  %call.i23 = tail call i32 @foobar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #3, !dbg !66
+  %add5 = add nsw i32 %add3, %call.i23, !dbg !67
+  ret i32 %add5, !dbg !68
+}
+
+declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 6.0.0 (trunk 308976)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "foo.c", directory: "")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 6.0.0 (trunk 308976)"}
+!7 = distinct !DISubprogram(name: "F", scope: !1, file: !1, line: 3, type: !8, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10, !10, !10, !10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12, !13, !14, !15, !16}
+!12 = !DILocalVariable(name: "i1", arg: 1, scope: !7, file: !1, line: 3, type: !10)
+!13 = !DILocalVariable(name: "i2", arg: 2, scope: !7, file: !1, line: 3, type: !10)
+!14 = !DILocalVariable(name: "i3", arg: 3, scope: !7, file: !1, line: 3, type: !10)
+!15 = !DILocalVariable(name: "i4", arg: 4, scope: !7, file: !1, line: 3, type: !10)
+!16 = !DILocalVariable(name: "i5", arg: 5, scope: !7, file: !1, line: 3, type: !10)
+!17 = !DIExpression()
+!18 = !DILocation(line: 3, column: 11, scope: !7)
+!19 = !DILocation(line: 3, column: 19, scope: !7)
+!20 = !DILocation(line: 3, column: 27, scope: !7)
+!21 = !DILocation(line: 3, column: 35, scope: !7)
+!22 = !DILocation(line: 3, column: 43, scope: !7)
+!23 = !DILocation(line: 4, column: 10, scope: !7)
+!24 = !DILocation(line: 4, column: 3, scope: !7)
+!25 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 7, type: !8, isLocal: false, isDefinition: true, scopeLine: 7, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !26)
+!26 = !{!27, !28, !29, !30, !31}
+!27 = !DILocalVariable(name: "a", arg: 1, scope: !25, file: !1, line: 7, type: !10)
+!28 = !DILocalVariable(name: "b", arg: 2, scope: !25, file: !1, line: 7, type: !10)
+!29 = !DILocalVariable(name: "c", arg: 3, scope: !25, file: !1, line: 7, type: !10)
+!30 = !DILocalVariable(name: "d", arg: 4, scope: !25, file: !1, line: 7, type: !10)
+!31 = !DILocalVariable(name: "e", arg: 5, scope: !25, file: !1, line: 7, type: !10)
+!32 = !DILocation(line: 7, column: 13, scope: !25)
+!33 = !DILocation(line: 7, column: 20, scope: !25)
+!34 = !DILocation(line: 7, column: 27, scope: !25)
+!35 = !DILocation(line: 7, column: 34, scope: !25)
+!36 = !DILocation(line: 7, column: 41, scope: !25)
+!37 = !DILocation(line: 3, column: 11, scope: !7, inlinedAt: !38)
+!38 = distinct !DILocation(line: 8, column: 10, scope: !25)
+!39 = !DILocation(line: 3, column: 19, scope: !7, inlinedAt: !38)
+!40 = !DILocation(line: 3, column: 27, scope: !7, inlinedAt: !38)
+!41 = !DILocation(line: 3, column: 35, scope: !7, inlinedAt: !38)
+!42 = !DILocation(line: 3, column: 43, scope: !7, inlinedAt: !38)
+!43 = !DILocation(line: 4, column: 10, scope: !7, inlinedAt: !38)
+!44 = !DILocation(line: 3, column: 11, scope: !7, inlinedAt: !45)
+!45 = distinct !DILocation(line: 9, column: 10, scope: !25)
+!46 = !DILocation(line: 3, column: 19, scope: !7, inlinedAt: !45)
+!47 = !DILocation(line: 3, column: 27, scope: !7, inlinedAt: !45)
+!48 = !DILocation(line: 3, column: 35, scope: !7, inlinedAt: !45)
+!49 = !DILocation(line: 3, column: 43, scope: !7, inlinedAt: !45)
+!50 = !DILocation(line: 4, column: 10, scope: !7, inlinedAt: !45)
+!51 = !DILocation(line: 8, column: 23, scope: !25)
+!52 = !DILocation(line: 3, column: 11, scope: !7, inlinedAt: !53)
+!53 = distinct !DILocation(line: 10, column: 10, scope: !25)
+!54 = !DILocation(line: 3, column: 19, scope: !7, inlinedAt: !53)
+!55 = !DILocation(line: 3, column: 27, scope: !7, inlinedAt: !53)
+!56 = !DILocation(line: 3, column: 35, scope: !7, inlinedAt: !53)
+!57 = !DILocation(line: 3, column: 43, scope: !7, inlinedAt: !53)
+!58 = !DILocation(line: 4, column: 10, scope: !7, inlinedAt: !53)
+!59 = !DILocation(line: 9, column: 23, scope: !25)
+!60 = !DILocation(line: 3, column: 11, scope: !7, inlinedAt: !61)
+!61 = distinct !DILocation(line: 11, column: 10, scope: !25)
+!62 = !DILocation(line: 3, column: 19, scope: !7, inlinedAt: !61)
+!63 = !DILocation(line: 3, column: 27, scope: !7, inlinedAt: !61)
+!64 = !DILocation(line: 3, column: 35, scope: !7, inlinedAt: !61)
+!65 = !DILocation(line: 3, column: 43, scope: !7, inlinedAt: !61)
+!66 = !DILocation(line: 4, column: 10, scope: !7, inlinedAt: !61)
+!67 = !DILocation(line: 10, column: 23, scope: !25)
+!68 = !DILocation(line: 8, column: 3, scope: !25)