fix jump threading failing to update cloned dbg.values

[BenJMudd]

Summary

This is a patch to fix duplicated dbg.values in the JumpThreading pass not pointing towards their local value, and instead towards the variable in the original block.
JumpThreadingPass::cloneInstructions is the changed function to target metadata as well as normal cloned values.

[probinson]

Style comments.

llvm/lib/Transforms/Scalar/JumpThreading.cpp

2052

Please don't mix unrelated formatting/whitespace changes with a functional change.

2086

2096

This one is debatable, if you prefer to keep it as is that's okay.

2100

Indentation here doesn't look right; try using clang-format-patch?

2147

llvm/test/Transforms/JumpThreading/thread-debug-info.ll

7

[BenJMudd]

llvm/lib/Transforms/Scalar/JumpThreading.cpp

2096

I think its more readable with auto, will change

[BenJMudd]

Addressing comments from Paul Robinson

[jmorse]

According to the style guide, "Variable names should [...] be camel case, and start with an upper case letter (e.g. Leader or Boats).", you'll need to update the variable names you've added. Otherwise all looks good.

llvm/test/Transforms/JumpThreading/thread-debug-info.ll

6–7

I'd suggest rewording thus, to describe the action of transforming the IR, rather than the state at the end.

[BenJMudd]

Adding missed fullstop

[BenJMudd]

Changed variable names to camel case, and reworded the comment describing the test

[jmorse]

LGTM -- let's leave it a while to give more opportunity for input.

[Orlando]

This looks good but there's an edge case to consider:

dbg.value intrinsics can be associated with more than one value. I don't think this patch would update %b if it had an entry in ValueMapping for the intrinsic:

call void @llvm.dbg.value(metadata !DIArgList(i32 %a, i32 %b), metadata !n, metadata !DIExpression(DW_OP_arg, 0, DW_OP_arg, 1, DW_OP_plus, DW_OP_stack_value)))

You can iterate over the values using DbgVariableIntrinsic::location_ops() and you can replace them using DbgVariableIntrinsic::replaceVariableLocationOp.

It may be acceptable to leave that as a "TODO" item - I'll leave that up to @jmorse. If it's decided to leave the patch in its current form then please take a look at the inline comment I've added.

Thanks!

llvm/lib/Transforms/Scalar/JumpThreading.cpp

2098

IMO we should use the higher-level DbgVariableIntrinsic::replaceVariableLocationOp(unsigned OpIdx, Value *NewValue) here to replace the value rather than the more general/low-level method setOperand.

[jmorse]

In D140006#3995119, @Orlando wrote:

You can iterate over the values using DbgVariableIntrinsic::location_ops() and you can replace them using DbgVariableIntrinsic::replaceVariableLocationOp.

It may be acceptable to leave that as a "TODO" item - I'll leave that up to @jmorse. If it's decided to leave the patch in its current form then please take a look at the inline comment I've added.

Ah yeah, this is a good idea, and we shouldn't set the example that DIArgList dbg.values are ignorable for some reason.

[BenJMudd]

Refactor of test and to main lambda via Orlando's comment, this can now take into account !DIArgList

[StephenTozer]

Some notes about the DIArgList stuff, otherwise LGTM.

llvm/lib/Transforms/Scalar/JumpThreading.cpp

2099

Unfortunately the use of replaceVariableLocationOp here might invalidate the above iterator - specifically after calling this, DbgInstruction will have a new DIArgList operand but the iterator in this loop will be pointing to the old DIArgList. This will cause an error if an instruction to be replaced appears multiple times in the debug value: If you're replacing %0 with %1 in DIArgList(%0, %0), then in the first iteration the arglist will be updated to !DIArgList(%1, %1), then in the second iteration it will try to replace %0 again, which would trigger an assertion.

A fix for this would be to either build a list of values to be replaced inside the loop and then updating DbgInstruction outside of the loop, or iterating over indices in the loop and using the index version of replaceVariableLocationOp (personally I prefer the former, but either works).

llvm/test/Transforms/JumpThreading/thread-debug-info.ll

30

As long as the test passes this should be fine, but worth noting some functions will assert that the DIExpression for a debug value with a DIArgList contains operands that reference those arguments; a simple example that would work here would be !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus).

[BenJMudd]

llvm/lib/Transforms/Scalar/JumpThreading.cpp

2099

Ah I hadn't thought of the !DIArgList referencing the same value, it is definitely much safer to change the list outside of the loop. I also prefer the former, thanks

[BenJMudd]

Added support for !DIArgList containing duplicate values to be correctly remapped

[jmorse]

LGTM

llvm/lib/Transforms/Scalar/JumpThreading.cpp

for (Instruction &I : *BB) {
     // block, and if so, record them in UsesToRename.
     for (Use &U : I.uses()) {
       Instruction *User = cast<Instruction>(U.getUser());
       if (PHINode *UserPN = dyn_cast<PHINode>(User)) {
         if (UserPN->getIncomingBlock(U) == BB)
           continue;
       } else if (User->getParent() == BB)
         continue;
 
       UsesToRename.push_back(&U);
     }
 
     // If there are no uses outside the block, we're done with this instruction.
     if (UsesToRename.empty())
       continue;
     LLVM_DEBUG(dbgs() << "JT: Renaming non-local uses of: " << I << "\n");
 

 JumpThreadingPass::cloneInstructions(BasicBlock::iterator BI,
                                      BasicBlock::iterator BE, BasicBlock *NewBB,
                                      BasicBlock *PredBB) {
   // We are going to have to map operands from the source basic block to the new
   // copy of the block 'NewBB'.  If there are PHI nodes in the source basic
   // block, evaluate them to account for entry from PredBB.
   DenseMap<Instruction *, Value *> ValueMapping;
 
+  // Retargets llvm.dbg.value to any renamed variables.
+  auto RetargetDbgValueIfPossible = [&](Instruction *NewInst) -> bool {
+    auto DbgInstruction = dyn_cast<DbgValueInst>(NewInst);
+    if (!DbgInstruction)
+      return false;
+
+    SmallSet<std::pair<Value *, Value *>, 16> OperandsToRemap;
+    for (auto DbgOperand : DbgInstruction->location_ops()) {
+      auto DbgOperandInstruction = dyn_cast<Instruction>(DbgOperand);
+      if (!DbgOperandInstruction)
+        continue;
+
+      auto I = ValueMapping.find(DbgOperandInstruction);
+      if (I != ValueMapping.end()) {
+        OperandsToRemap.insert(
+            std::pair<Value *, Value *>(DbgOperand, I->second));
+      }
+    }
+
+    for (auto &[OldOp, MappedOp] : OperandsToRemap)
+      DbgInstruction->replaceVariableLocationOp(OldOp, MappedOp);
+    return true;
+  };
+
   // Clone the phi nodes of the source basic block into NewBB.  The resulting
   // phi nodes are trivial since NewBB only has one predecessor, but SSAUpdater
   // might need to rewrite the operand of the cloned phi.
   for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI) {
     PHINode *NewPN = PHINode::Create(PN->getType(), 1, PN->getName(), NewBB);
     NewPN->addIncoming(PN->getIncomingValueForBlock(PredBB), PredBB);
     ValueMapping[PN] = NewPN;
   }
JumpThreadingPass::cloneInstructions(BasicBlock::iterator BI,
   // instructions.
   for (; BI != BE; ++BI) {
     Instruction *New = BI->clone();
     New->setName(BI->getName());
     New->insertInto(NewBB, NewBB->end());
     ValueMapping[&*BI] = New;
     adaptNoAliasScopes(New, ClonedScopes, Context);
 
+    if (RetargetDbgValueIfPossible(New))
+      continue;
+
     // Remap operands to patch up intra-block references.
     for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
       if (Instruction *Inst = dyn_cast<Instruction>(New->getOperand(i))) {
         DenseMap<Instruction *, Value *>::iterator I = ValueMapping.find(Inst);
         if (I != ValueMapping.end())
           New->setOperand(i, I->second);
       }
   }
 
   return ValueMapping;
 }
 
 /// Attempt to thread through two successive basic blocks.
 bool JumpThreadingPass::maybethreadThroughTwoBasicBlocks(BasicBlock *BB,
                                                          Value *Cond) {

llvm/test/Transforms/JumpThreading/thread-debug-info.ll

+; RUN: opt -S -passes=jump-threading < %s | FileCheck %s
+
+@a = global i32 0, align 4
+; Test that the llvm.dbg.value calls in a threaded block are correctly updated to
+; target the locals in their threaded block, and not the unthreaded one.
+define void @test2(i32 %cond1, i32 %cond2) {
+; CHECK: [[globalptr:@.*]] = global i32 0, align 4
+; CHECK: bb.cond2:
+; CHECK: call void @llvm.dbg.value(metadata ptr null, metadata ![[DBG1ptr:[0-9]+]], metadata !DIExpression()), !dbg ![[DBG2ptr:[0-9]+]]
+; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 %cond2, 0, !dbg ![[DBGLOCtobool1:[0-9]+]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata !DIArgList(ptr null, i1 [[TOBOOL1]], i1 [[TOBOOL1]]), metadata !{{[0-9]+}}, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_LLVM_arg, 2, DW_OP_plus)), !dbg !{{[0-9]+}}
+; CHECK: bb.cond2.thread:
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr [[globalptr]], metadata ![[DBG1ptr]], metadata !DIExpression()), !dbg ![[DBG2ptr]]
+; CHECK-NEXT: [[TOBOOL12:%.*]] = icmp eq i32 %cond2, 0, !dbg ![[DBGLOCtobool1]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata !DIArgList(ptr [[globalptr]], i1 [[TOBOOL12]], i1 [[TOBOOL12]]), metadata !{{[0-9]+}}, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_LLVM_arg, 2, DW_OP_plus)), !dbg !{{[0-9]+}}
+entry:
+  %tobool = icmp eq i32 %cond1, 0, !dbg !15
+  call void @llvm.dbg.value(metadata i1 %tobool, metadata !9, metadata !DIExpression()), !dbg !15
+  br i1 %tobool, label %bb.cond2, label %bb.f1, !dbg !16
+
+bb.f1:                                            ; preds = %entry
+  call void @f1(), !dbg !17
+  br label %bb.cond2, !dbg !18
+
+bb.cond2:                                         ; preds = %bb.f1, %entry
+  %ptr = phi ptr [ null, %bb.f1 ], [ @a, %entry ], !dbg !19
+  call void @llvm.dbg.value(metadata ptr %ptr, metadata !11, metadata !DIExpression()), !dbg !19
+  %tobool1 = icmp eq i32 %cond2, 0, !dbg !20
+  call void @llvm.dbg.value(metadata !DIArgList(ptr %ptr, i1 %tobool1, i1 %tobool1), metadata !13, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_LLVM_arg, 2, DW_OP_plus)), !dbg !20
+  br i1 %tobool1, label %bb.file, label %bb.f2, !dbg !21
+
+bb.f2:                                            ; preds = %bb.cond2
+  call void @f2(), !dbg !22
+  br label %exit, !dbg !23
+
+bb.file:                                          ; preds = %bb.cond2
+  %cmp = icmp eq ptr %ptr, null, !dbg !24
+  call void @llvm.dbg.value(metadata i1 %cmp, metadata !14, metadata !DIExpression()), !dbg !24
+  br i1 %cmp, label %bb.f4, label %bb.f3, !dbg !25
+
+bb.f3:                                            ; preds = %bb.file
+  br label %exit, !dbg !26
+
+bb.f4:                                            ; preds = %bb.file
+  call void @f4(), !dbg !27
+  br label %exit, !dbg !28
+
+exit:                                             ; preds = %bb.f4, %bb.f3, %bb.f2
+  ret void, !dbg !29
+}
+
+declare void @f1()
+
+declare void @f2()
+
+declare void @f3()
+
+declare void @f4()
+
+; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare void @llvm.dbg.value(metadata, metadata, metadata) #0
+
+attributes #0 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+
+!llvm.dbg.cu = !{!0}
+!llvm.debugify = !{!2, !3}
+!llvm.module.flags = !{!4}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!1 = !DIFile(filename: "/home/ben/Documents/llvm-project/llvm/test/Transforms/JumpThreading/thread-debug-info.ll", directory: "/")
+!2 = !{i32 15}
+!3 = !{i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = distinct !DISubprogram(name: "test2", linkageName: "test2", scope: null, file: !1, line: 1, type: !6, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
+!6 = !DISubroutineType(types: !7)
+!7 = !{}
+!8 = !{!9, !11, !13, !14}
+!9 = !DILocalVariable(name: "1", scope: !5, file: !1, line: 1, type: !10)
+!10 = !DIBasicType(name: "ty8", size: 8, encoding: DW_ATE_unsigned)
+!11 = !DILocalVariable(name: "2", scope: !5, file: !1, line: 5, type: !12)
+!12 = !DIBasicType(name: "ty64", size: 64, encoding: DW_ATE_unsigned)
+!13 = !DILocalVariable(name: "3", scope: !5, file: !1, line: 6, type: !10)
+!14 = !DILocalVariable(name: "4", scope: !5, file: !1, line: 10, type: !10)
+!15 = !DILocation(line: 1, column: 1, scope: !5)
+!16 = !DILocation(line: 2, column: 1, scope: !5)
+!17 = !DILocation(line: 3, column: 1, scope: !5)
+!18 = !DILocation(line: 4, column: 1, scope: !5)
+!19 = !DILocation(line: 5, column: 1, scope: !5)
+!20 = !DILocation(line: 6, column: 1, scope: !5)
+!21 = !DILocation(line: 7, column: 1, scope: !5)
+!22 = !DILocation(line: 8, column: 1, scope: !5)
+!23 = !DILocation(line: 9, column: 1, scope: !5)
+!24 = !DILocation(line: 10, column: 1, scope: !5)
+!25 = !DILocation(line: 11, column: 1, scope: !5)
+!26 = !DILocation(line: 12, column: 1, scope: !5)
+!27 = !DILocation(line: 13, column: 1, scope: !5)
+!28 = !DILocation(line: 14, column: 1, scope: !5)
+!29 = !DILocation(line: 15, column: 1, scope: !5)
 No newline at end of file