[deadargelim] Attach dbg info to the insert/extractvalue instructions

[djtodoro]

Summary

The bug was found by the LLVM DI Checker (pushed as -debugify=original mode) and this was used in the RFC [0] for the utility.

Attach DbgLoc on insertvalue/extractvalue instructions created by DeadArgumentElimination.
This fixes the PR46350.

[0] https://groups.google.com/forum/#!msg/llvm-dev/QOyF-38YPlE/G213uiuwCAAJ

[vsk]

Hi @djtodoro, this popped up in my mail filter so I thought I'd drop a line :). It sounds like there's a substantial amount of overlap with the debugify stuff and the tool here (https://github.com/djolertrk/llvm-di-checker). Do we need both?

For the issue found here for example, one might do: ./bin/llvm-lit -Dopt="opt -debugify-each" test/Transforms/DeadArgElim -av 2>&1 | less, and this prints:

PASS: LLVM :: Transforms/DeadArgElim/multdeadretval.ll (28 of 34)
Script:
--
: 'RUN: at line 5';   opt -debugify-each < /Users/vsk/src/llvm-project-master/llvm/test/Transforms/DeadArgElim/multdeadretval.ll -deadargelim -instcombine -dce -S | /Users/vsk/src/builds/llvm-project-master-RA/bin/not grep i16
--
Exit Code: 0

Command Output (stderr):
--
ERROR: Instruction with empty DebugLoc in function test --  %oldret = extractvalue { i16, i32 } %B, 1
ERROR: Instruction with empty DebugLoc in function test2 --  %oldret = extractvalue { i32, i16 } %B, 0
ERROR: Instruction with empty DebugLoc in function test3 --  %oldret = insertvalue { i16, i32 } undef, i32 %ret, 1
ERROR: Instruction with empty DebugLoc in function test5 --  %oldret = extractvalue { i32, i32, i16 } %C, 0
...

I think there are advantages to looking at real code outside of the llvm unit/regression tests, just wondering whether we need to redo all the DI checking / stats collection work.

[djtodoro]

In D81939#2096463, @vsk wrote:

Hi @djtodoro, this popped up in my mail filter so I thought I'd drop a line :). It sounds like there's a substantial amount of overlap with the debugify stuff and the tool here (https://github.com/djolertrk/llvm-di-checker). Do we need both?

For the issue found here for example, one might do: ./bin/llvm-lit -Dopt="opt -debugify-each" test/Transforms/DeadArgElim -av 2>&1 | less, and this prints:

PASS: LLVM :: Transforms/DeadArgElim/multdeadretval.ll (28 of 34)
Script:
--
: 'RUN: at line 5';   opt -debugify-each < /Users/vsk/src/llvm-project-master/llvm/test/Transforms/DeadArgElim/multdeadretval.ll -deadargelim -instcombine -dce -S | /Users/vsk/src/builds/llvm-project-master-RA/bin/not grep i16
--
Exit Code: 0

Command Output (stderr):
--
ERROR: Instruction with empty DebugLoc in function test --  %oldret = extractvalue { i16, i32 } %B, 1
ERROR: Instruction with empty DebugLoc in function test2 --  %oldret = extractvalue { i32, i16 } %B, 0
ERROR: Instruction with empty DebugLoc in function test3 --  %oldret = insertvalue { i16, i32 } undef, i32 %ret, 1
ERROR: Instruction with empty DebugLoc in function test5 --  %oldret = extractvalue { i32, i32, i16 } %C, 0
...

I think there are advantages to looking at real code outside of the llvm unit/regression tests, just wondering whether we need to redo all the DI checking / stats collection work.

Hi @vsk, thanks for the comment! :)

The debugify tool is very useful for the regression testing/Pass verification; and I use it that way and I think we can all use it in the combination with this. The idea here was to introduce a tool (let me say a sibling of the debugify) that will deal with real debug info metadata. I know that debugify already deals with the DILocations, but I thought to introduce support for all kind of metadata (including DIGlobalVariables, DILexicalBlocks, etc.; which is hard to maintain as synthetic debug info), and support DILocations along the way as well. In addition, I think that extending this to MIR level is also doable/may be straight forward.

We all use the compiler on real projects, and users report issues regarding debug info saying "My variable 'a' is optimized out, but it should not be" or "I cannot attach breakpoint to function 'f' (or instruction 'i')", so I found this tool very useful in these situations, since it points (or it will point when improved; this is initial stage) to real spot of the bug that caused the issue for the concrete entity. Also, there are companies with downstream passes and frontend features that may not be direct cause of the bug, but the bug can occur somewhere else in the pipeline as a consequence. So, I think (by using this) we can come up with variety of test cases that may not be present in the existing tests.

I'll send an RFC and please comment on that! Thanks again!

[djtodoro]

• Cover all the instructions
• Cover all the cases with the test
• Remove [NOT FOR COMMIT] part

[aprantl]

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

975–976

@vsk: would it be better style to ad-hoc create an IRBuilder with the correct debug location here?

llvm/test/Transforms/DeadArgElim/multdeadretval.ll

11 ↗

(On Diff #274464)

I think it would be much better to have a targeted check here that checks the actual instructions. Debugify is great for finding bugs, but I wouldn't recommend it for writing testcases. In this form, nothing guarantees that the code path that triggers the bugfix is still exercised by the test if the pass is modified and the test quickly looses its usefulness.

[djtodoro]

• Check the actual instructions instead of final debugify result in the test provided

[djtodoro]

llvm/test/Transforms/DeadArgElim/multdeadretval.ll

11 ↗

(On Diff #274464)

I've just addressed this.

[aprantl]

llvm/test/Transforms/DeadArgElim/multdeadretval.ll

12 ↗

(On Diff #274711)

Thanks!

Should we also check that the !dbg attachment is the same as some other instruction? Or are we really fine with just *any* !dbg location?

[djtodoro]

llvm/test/Transforms/DeadArgElim/multdeadretval.ll

12 ↗

(On Diff #274711)

It makes sense to me to test the actual locations. I've addressed that as well. Thanks you @aprantl!

[djtodoro]

• Check actual locations in the test

[vsk]

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

975–976

Yes, that seems to be the common idiom. I recommend using IRBuilder<NoFolder> to avoid spurious test changes.

llvm/test/Transforms/DeadArgElim/multdeadretval.ll

7 ↗

(On Diff #275022)

I recommend copying this test, modifying it to include debug info, and dropping the -enable-debugify=synthetic part. This bugfix doesn't need to depend on the debugify original mode patchset. Also, the hardcoded checks for DILocation line numbers will make this test hard to modify, so if we want to check specific synthetic line numbers I think we'd be better served by a dedicated test.

[djtodoro]

llvm/test/Transforms/DeadArgElim/multdeadretval.ll

7 ↗

(On Diff #275022)

It makes sense to me! Thanks!

[djtodoro]

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

975–976

Oh.. The IRBuilder<> will generate a debug loc by default (via insert() method).

[djtodoro]

• Use IRBuilder<> since it generates dbg loc by default
• Create new test

[aprantl]

lgtm from my point of view now.

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

981

Nice!

llvm/test/DebugInfo/X86/dbgloc-insert-extract-val-instrs.ll

6

Why use a custom prefix if there is only one FileCheck invocation?

220

We might as well delete all the column: 1 fields, assuming that 0 is the default.

[vsk]

Are test{1,2,3,4,5,6} and main all necessary to exercise the changes in this patch? On the surface, it looks like there are two primary changes -- one that affects the case when deadargelim changes the function return type, and another that affects the case where deadargelim modifies a function that returns an array/struct. Can the test be pared down to just cover those two cases?

llvm/test/DebugInfo/X86/dbgloc-insert-extract-val-instrs.ll

5

It doesn't look like the -check-debugify output is important, so it shouldn't be necessary to run the pass.

Also, since the dbg.values are also not important, please run -debugify with -debugify-level=locations to omit those intrinsics.

8

Please restructure these checks so they have a clear correspondence to a test function. The typical way to write this is:

; CHECK-LABEL: some_test1
; CHECK: ...
define void @some_test1

; CHECK-LABEL: some_test2
; CHECK: ...
define void @some_test2

etc.

[djtodoro]

@aprantl @vsk Thanks a lot for the feedback!

llvm/test/DebugInfo/X86/dbgloc-insert-extract-val-instrs.ll

5

I see..thanks :)

6

Oh, sure..

8

I was a bit lazy, sure, thanks!

[djtodoro]

• Addressing comments
• Reduce the test

[djtodoro]

• [test] remove unused debugify metadata

[vsk]

Thanks, lgtm!

[djtodoro]

Thanks!

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/NoFolder.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
if (!CB.use_empty() || CB.isUsedByMetadata()) {
         // with all the uses, we will just rebuild it using extract/insertvalue
         // chaining and let instcombine clean that up.
         //
         // Start out building up our return value from undef
         Value *RetVal = UndefValue::get(RetTy);
         for (unsigned Ri = 0; Ri != RetCount; ++Ri)
           if (NewRetIdxs[Ri] != -1) {
             Value *V;
+            IRBuilder<NoFolder> IRB(InsertPt);
             if (RetTypes.size() > 1)
               // We are still returning a struct, so extract the value from our
               // return value
-              V = ExtractValueInst::Create(NewCB, NewRetIdxs[Ri], "newret",
-                                           InsertPt);
+              V = IRB.CreateExtractValue(NewCB, NewRetIdxs[Ri], "newret");
             else
               // We are now returning a single element, so just insert that
               V = NewCB;
             // Insert the value at the old position
-            RetVal = InsertValueInst::Create(RetVal, V, Ri, "oldret", InsertPt);
+            RetVal = IRB.CreateInsertValue(RetVal, V, Ri, "oldret");
           }
         // Now, replace all uses of the old call instruction with the return
         // struct we built
         CB.replaceAllUsesWith(RetVal);
         NewCB->takeName(&CB);
       }
     }
 
if (ArgAlive[ArgI]) {
         I->replaceAllUsesWith(UndefValue::get(I->getType()));
     }
 
   // If we change the return value of the function we must rewrite any return
   // instructions.  Check this now.
   if (F->getReturnType() != NF->getReturnType())
     for (BasicBlock &BB : *NF)
       if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
+        IRBuilder<NoFolder> IRB(RI);
         Value *RetVal = nullptr;
 
         if (!NFTy->getReturnType()->isVoidTy()) {
           assert(RetTy->isStructTy() || RetTy->isArrayTy());
           // The original return value was a struct or array, insert
           // extractvalue/insertvalue chains to extract only the values we need
           // to return and insert them into our new result.
           // This does generate messy code, but we'll let it to instcombine to
           // clean that up.
           Value *OldRet = RI->getOperand(0);
           // Start out building up our return value from undef
           RetVal = UndefValue::get(NRetTy);
           for (unsigned RetI = 0; RetI != RetCount; ++RetI)
             if (NewRetIdxs[RetI] != -1) {
-              ExtractValueInst *EV =
-                  ExtractValueInst::Create(OldRet, RetI, "oldret", RI);
+              Value *EV = IRB.CreateExtractValue(OldRet, RetI, "oldret");
+
               if (RetTypes.size() > 1) {
                 // We're still returning a struct, so reinsert the value into
                 // our new return value at the new index
 
-                RetVal = InsertValueInst::Create(RetVal, EV, NewRetIdxs[RetI],
-                                                 "newret", RI);
+                RetVal = IRB.CreateInsertValue(RetVal, EV, NewRetIdxs[RetI],
+                                               "newret");
               } else {
                 // We are now only returning a simple value, so just return the
                 // extracted value.
                 RetVal = EV;
               }
             }
         }
         // Replace the return instruction with one returning the new return

llvm/test/DebugInfo/X86/dbgloc-insert-extract-val-instrs.ll

+;; Check that every instruction inserted by -deadargelim has a debug location.
+;; The test was generated by using -debugify option.
+
+; RUN: opt < %s -deadargelim -S 2>&1 | FileCheck %s
+
+; CHECK-LABEL: fn
+; CHECK: %oldret = extractvalue { i32, i32, i16 } %z, 0, !dbg ![[LOC:.*]]
+; CHECK: %newret = insertvalue { i32, i32 } undef, i32 %oldret, 0, !dbg ![[LOC:.*]]
+; CHECK: %oldret1 = extractvalue { i32, i32, i16 } %z, 1, !dbg ![[LOC:.*]]
+; CHECK: %newret2 = insertvalue { i32, i32 } %newret, i32 %oldret1, 1, !dbg ![[LOC:.*]]
+
+; CHECK-LABEL: fn1
+; CHECK: %newret = extractvalue { i32, i32 } %ret, 0, !dbg ![[LOC2:.*]]
+; CHECK: %oldret = insertvalue { i32, i32, i16 } undef, i32 %newret, 0, !dbg ![[LOC2:.*]]
+; CHECK: %newret1 = extractvalue { i32, i32 } %ret, 1, !dbg ![[LOC2:.*]]
+; CHECK: %oldret2 = insertvalue { i32, i32, i16 } %oldret, i32 %newret1, 1, !dbg ![[LOC2:.*]]
+
+; ModuleID = 'test.ll'
+source_filename = "test.ll"
+
+define internal { i32, i32, i16 } @fn() !dbg !6 {
+  %x = insertvalue { i32, i32, i16 } undef, i32 1, 0, !dbg !8
+  %y = insertvalue { i32, i32, i16 } %x, i32 2, 1, !dbg !9
+  %z = insertvalue { i32, i32, i16 } %y, i16 3, 2, !dbg !10
+  ret { i32, i32, i16 } %z, !dbg !11
+}
+
+define i32 @fn1() !dbg !12 {
+  %ret = call { i32, i32, i16 } @fn(), !dbg !13
+  %b = extractvalue { i32, i32, i16 } %ret, 0, !dbg !14
+  %c = extractvalue { i32, i32, i16 } %ret, 1, !dbg !15
+  %d = add i32 %b, %c, !dbg !16
+  ret i32 %d, !dbg !17
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "test.ll", directory: "/")
+!2 = !{}
+!5 = !{i32 2, !"Debug Info Version", i32 3}
+!6 = distinct !DISubprogram(name: "fn", linkageName: "fn", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!7 = !DISubroutineType(types: !2)
+!8 = !DILocation(line: 1, column: 1, scope: !6)
+!9 = !DILocation(line: 2, column: 1, scope: !6)
+!10 = !DILocation(line: 3, column: 1, scope: !6)
+!11 = !DILocation(line: 4, column: 1, scope: !6)
+!12 = distinct !DISubprogram(name: "fn1", linkageName: "fn1", scope: null, file: !1, line: 5, type: !7, scopeLine: 5, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!13 = !DILocation(line: 5, column: 1, scope: !12)
+!14 = !DILocation(line: 6, column: 1, scope: !12)
+!15 = !DILocation(line: 7, column: 1, scope: !12)
+!16 = !DILocation(line: 8, column: 1, scope: !12)
+!17 = !DILocation(line: 9, column: 1, scope: !12)
+
+; CHECK: ![[LOC]] = !DILocation(line: 4
+; CHECK: ![[LOC2]] = !DILocation(line: 5