[CGP] Set debug locations when optimizing phi types

[dmgreen]

Summary

This sets the debug location from the old instructions when converting phi types.

The debug values may be more difficult to correct given that they are now a different type. Otherwise, I do not believe that debug instructions alters the optimization.

[dmgreen]

Rebase. I don't claim to be a big debug expert, I'm not sure if the debug value on bitcasts/phis is super important.

[SjoerdMeijer]

I am also not a debug expert, but this looks like an "innocent" patch to me that makes things a bit better, so that's good. What I am wondering about though why setDebugLoc isn't done in the constructor, which makes the code cleaner here and also it won't be forgotten. But I don't want to make this bigger than it is, and since I have never really looked into debug info, I also don't know if there would be any disadvantages doing that. Perhaps others can comment on that.

[bjope]

Just want to clarify that my questions regarding "what about debug info" in the earlier patch introducing these phi-type-rewrites actually was about dbg.value rather than the debugloc:s. I kind of wanted to have test cases verifying that the the presence of dbg.value uses didn't impact the optimization (-g invariance). But also to see that the dbg.value uses were handled somehow (either being salvaged in some way or being properly invalidated).

Nevertheless, if we should focus on the DebugLoc:s here, the patch seems pretty harmless to me. There are often some different opinions about having debug locations on things that doesn't really map to something in the original source. Afaik not having debug locations could mess up stepping in a debugger a bit, while having locations could impact profiling and code coverage. As far as I can see you pick locations from the replaced och adjacent instruction, so you won't end up hoisting/sinking a location risking to impact code coverage.

[bjope]

llvm/lib/CodeGen/CodeGenPrepare.cpp

5970

I guess this is what makes the dbg.value after the phi to be invalidated (getting undef as value instead of the phi result)?

Techincally I think it would have been OK to replace uses in dbg.value with the new PHI result (such as changing from i32 to float). At least salvageDebugInfoImpl in Local.cpp seem to just look through no-op-casts when. Maybe it isn't that important to deal with it here. I think it is more complicated than just calling salvageDebugInfo(*I) here, since it won't detect that you replaced the PHI with a new PHI. But maybe it is worth a comment explaining that we don't salvage any debug uses here (even thought it could be done in the future).

[Orlando]

llvm/lib/CodeGen/CodeGenPrepare.cpp

5884–5886

This is unrelated to your change (but is debug-info related), sorry for the extra noise...

It looks like we early-out of optimizePhiType here if II has a user which doesn't match the conditions above (i.e. not a phi, store, or bitcast). Couldn't this cause a change in behaviour based on debug-info if II is used by a debug intrinsic (isa<DbgVariableIntrinsic>(V))?

[Orlando]

llvm/lib/CodeGen/CodeGenPrepare.cpp

5884–5886

Ah, ignore this, I was being silly. I somehow forgot that debug intrinsics wrap the values as metadata.

[dmgreen]

Thanks for taking a look folks.

llvm/lib/CodeGen/CodeGenPrepare.cpp

5884–5886

Yep. This and other mulitple uses were what made me think this could cause a problem, but like you said it seems to be doing OK, both when I ran it like this with debugify and the original case with debug info.

5970

Oh of course. For some reason I was just thinking the undefs were from removing the node. I had not considered that we replace them with undef as we remove them, due to the cycles that can be found between phi nodes.

I have attempted to add some code to salvage debug info (largely as an excuse to learn a little more about debug info).

Let me know if it looks wonky.

[jmorse]

This completely fell off my radar sorry,

This looks good, particularly the extra salvaging. A question inline about whether some of it is already covered by a RAUW though.

llvm/lib/CodeGen/CodeGenPrepare.cpp

5925–5933

I'm not overly familiar with this optimisation, but won't the debug users of Phi be RAUW'd to the bitcast by the next loop? If so, there Shouldn't (TM) be a need to explicitly point them at the new PHI.

[dmgreen]

llvm/lib/CodeGen/CodeGenPrepare.cpp

5925–5933

The offending part is down in CodeGenPrepare::optimizePhiTypes where we call I->replaceAllUsesWith(UndefValue::get(I->getType())). Because we are dealing with a collection of phi nodes, that may form a loop, we need to ensure they really have no users before we erase them.

And we are converting the type of the phis from float to int, so don't RAUW on them directly. We add new phi nodes and remove the old.

I'm certainly not a debug expert and if this code is going to cause more trouble that it's worth we can remove it. But I think (unconfidently) that it's needed to keep the debug values present and connected.

[djtodoro]

llvm/lib/CodeGen/CodeGenPrepare.cpp

5908

I think this should be a separate patch with the test case covering this.

[jmorse]

The variable location changes LGTM, I otherwise defer to Djordje who's made a request.

llvm/lib/CodeGen/CodeGenPrepare.cpp

5925–5933

Cool -- the test changes look like they're doing the right thing, and it doesn't look like the other added call to salvageDebugInfo is responsible, so this block is making a good contribution.

llvm/lib/CodeGen/CodeGenPrepare.cpp

for (User *V : II->users()) {
       } else if (auto *OpBC = dyn_cast<BitCastInst>(V)) {
         if (!ConvertTy)
           ConvertTy = OpBC->getType();
         if (OpBC->getType() != ConvertTy)
           return false;
         Uses.insert(OpBC);
         AnyAnchored |=
             any_of(OpBC->users(), [](User *U) { return !isa<StoreInst>(U); });
       } else {
         return false;
       }
     }
   }
 
   if (!ConvertTy || !AnyAnchored || !TLI->shouldConvertPhiType(PhiTy, ConvertTy))
     return false;
 
   LLVM_DEBUG(dbgs() << "Converting " << *I << "\n  and connected nodes to "
                     << *ConvertTy << "\n");
 
   // Create all the new phi nodes of the new type, and bitcast any loads to the
   // correct type.
   ValueToValueMap ValMap;
   ValMap[UndefValue::get(PhiTy)] = UndefValue::get(ConvertTy);
   for (Instruction *D : Defs) {
     if (isa<BitCastInst>(D)) {
       ValMap[D] = D->getOperand(0);
+      salvageDebugInfo(*D);
       DeletedInstrs.insert(D);
     } else {
-      ValMap[D] =
+      Instruction *N =
           new BitCastInst(D, ConvertTy, D->getName() + ".bc", D->getNextNode());
+      N->setDebugLoc(D->getDebugLoc());
+      ValMap[D] = N;
     }
   }
-  for (PHINode *Phi : PhiNodes)
-    ValMap[Phi] = PHINode::Create(ConvertTy, Phi->getNumIncomingValues(),
-                                  Phi->getName() + ".tc", Phi);
+  for (PHINode *Phi : PhiNodes) {
+    PHINode *N = PHINode::Create(ConvertTy, Phi->getNumIncomingValues(),
+    N->setDebugLoc(Phi->getDebugLoc());
+    ValMap[Phi] = N;
+  }
   // Pipe together all the PhiNodes.
   for (PHINode *Phi : PhiNodes) {
     PHINode *NewPhi = cast<PHINode>(ValMap[Phi]);
     for (int i = 0, e = Phi->getNumIncomingValues(); i < e; i++)
       NewPhi->addIncoming(ValMap[Phi->getIncomingValue(i)],
                           Phi->getIncomingBlock(i));
+
+    SmallVector<DbgValueInst *, 1> DbgValues;
+    findDbgValues(DbgValues, Phi);
+    for (DbgValueInst *DVI : DbgValues) {
+      // Bitcasts are apparently irrelevant for debug info. Rewrite the dbg.value
+      // to use the new phi.
+      DVI->setOperand(0, MetadataAsValue::get(Phi->getContext(),
+                                              ValueAsMetadata::get(NewPhi)));
+      LLVM_DEBUG(dbgs() << "SALVAGE: " << DVI << '\n');
+    }
     Visited.insert(NewPhi);
   }
   // And finally pipe up the stores and bitcasts
   for (Instruction *U : Uses) {
     if (isa<BitCastInst>(U)) {
       DeletedInstrs.insert(U);
       U->replaceAllUsesWith(ValMap[U->getOperand(0)]);
     } else {
-      U->setOperand(0,
-                    new BitCastInst(ValMap[U->getOperand(0)], PhiTy, "bc", U));
+      Instruction *N =
+          new BitCastInst(ValMap[U->getOperand(0)], PhiTy, "bc", U);
+      N->setDebugLoc(U->getDebugLoc());
+      U->setOperand(0, N);
     }
   }
 
   // Save the removed phis to be deleted later.
   for (PHINode *Phi : PhiNodes)
     DeletedInstrs.insert(Phi);
   return true;
 }
 
 bool CodeGenPrepare::optimizePhiTypes(Function &F) {
   if (!OptimizePhiTypes)
     return false;
 
   bool Changed = false;
   SmallPtrSet<PHINode *, 4> Visited;
   SmallPtrSet<Instruction *, 4> DeletedInstrs;
 
   // Attempt to optimize all the phis in the functions to the correct type.
   for (auto &BB : F)
     for (auto &Phi : BB.phis())
       Changed |= optimizePhiType(&Phi, Visited, DeletedInstrs);
 
   // Remove any old phi's that have been converted.
   for (auto *I : DeletedInstrs) {
     I->replaceAllUsesWith(UndefValue::get(I->getType()));
     I->eraseFromParent();
   }
 
   return Changed;
 }
 
 /// Return true, if an ext(load) can be formed from an extension in
 /// \p MovedExts.

llvm/test/CodeGen/AArch64/convertphitype.ll

 ;
 ; DEBUG-LABEL: @convphi1(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG16:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META9:metadata !.*]], metadata !DIExpression()), [[DBG16]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[ELSE:%.*]], [[DBG17:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG18:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG18]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META11:metadata !.*]], metadata !DIExpression()), [[DBG18]]
 ; DEBUG-NEXT:    br label [[END:%.*]], [[DBG19:!dbg !.*]]
 ; DEBUG:       else:
 ; DEBUG-NEXT:    [[LD:%.*]] = load i32, i32* [[D:%.*]], align 4, [[DBG20:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float, [[DBG20]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LD]], [[META13:metadata !.*]], metadata !DIExpression()), [[DBG20]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG21:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META14:metadata !.*]], metadata !DIExpression()), [[DBG22:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ], [[DBG22:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META14:metadata !.*]], metadata !DIExpression()), [[DBG22]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META15:metadata !.*]], metadata !DIExpression()), [[DBG23:!dbg !.*]]
 ; DEBUG-NEXT:    ret float [[PHI_TC]], [[DBG24:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   br i1 %cmp15, label %then, label %else
 
 then:

 ;
 ; DEBUG-LABEL: @convphi2(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG31:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META27:metadata !.*]], metadata !DIExpression()), [[DBG31]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[END:%.*]], [[DBG32:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG33:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG33]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META28:metadata !.*]], metadata !DIExpression()), [[DBG33]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG34:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ undef, [[ENTRY:%.*]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META29:metadata !.*]], metadata !DIExpression()), [[DBG35:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ undef, [[ENTRY:%.*]] ], [[DBG35:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META29:metadata !.*]], metadata !DIExpression()), [[DBG35]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META30:metadata !.*]], metadata !DIExpression()), [[DBG36:!dbg !.*]]
 ; DEBUG-NEXT:    ret float [[PHI_TC]], [[DBG37:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   br i1 %cmp15, label %then, label %end
 
 then:

 ; CHECK:       end:
 ; CHECK-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[F:%.*]], [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret float [[PHI_TC]]
 ;
 ; DEBUG-LABEL: @convphi3(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG45:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META40:metadata !.*]], metadata !DIExpression()), [[DBG45]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META41:metadata !.*]], metadata !DIExpression()), [[DBG46:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[F:%.*]], [[META41:metadata !.*]], metadata !DIExpression()), [[DBG46:!dbg !.*]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[END:%.*]], [[DBG47:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG48:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG48]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META42:metadata !.*]], metadata !DIExpression()), [[DBG48]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG49:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[F:%.*]], [[ENTRY:%.*]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META43:metadata !.*]], metadata !DIExpression()), [[DBG50:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[F]], [[ENTRY:%.*]] ], [[DBG50:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META43:metadata !.*]], metadata !DIExpression()), [[DBG50]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META44:metadata !.*]], metadata !DIExpression()), [[DBG51:!dbg !.*]]
 ; DEBUG-NEXT:    ret float [[PHI_TC]], [[DBG52:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   %fb = bitcast float %f to i32
   br i1 %cmp15, label %then, label %end
 

 ; CHECK-NEXT:    [[BC:%.*]] = bitcast float [[PHI_TC]] to i32
 ; CHECK-NEXT:    store i32 [[BC]], i32* [[D:%.*]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; DEBUG-LABEL: @convphi4(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG59:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META55:metadata !.*]], metadata !DIExpression()), [[DBG59]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META56:metadata !.*]], metadata !DIExpression()), [[DBG60:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[F:%.*]], [[META56:metadata !.*]], metadata !DIExpression()), [[DBG60:!dbg !.*]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[END:%.*]], [[DBG61:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG62:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG62]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META57:metadata !.*]], metadata !DIExpression()), [[DBG62]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG63:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[F:%.*]], [[ENTRY:%.*]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META58:metadata !.*]], metadata !DIExpression()), [[DBG64:!dbg !.*]]
-; DEBUG-NEXT:    [[BC:%.*]] = bitcast float [[PHI_TC]] to i32
-; DEBUG-NEXT:    store i32 [[BC]], i32* [[D:%.*]], align 4, [[DBG65:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[F]], [[ENTRY:%.*]] ], [[DBG64:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META58:metadata !.*]], metadata !DIExpression()), [[DBG64]]
+; DEBUG-NEXT:    [[BC:%.*]] = bitcast float [[PHI_TC]] to i32, [[DBG65:!dbg !.*]]
+; DEBUG-NEXT:    store i32 [[BC]], i32* [[D:%.*]], align 4, [[DBG65]]
 ; DEBUG-NEXT:    ret void, [[DBG66:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   %fb = bitcast float %f to i32
   br i1 %cmp15, label %then, label %end
 
 then:

 ;
 ; DEBUG-LABEL: @convphi_d2i(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG75:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META69:metadata !.*]], metadata !DIExpression()), [[DBG75]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[ELSE:%.*]], [[DBG76:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load double, double* [[S:%.*]], align 4, [[DBG77:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast double [[LS]] to i64
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast double [[LS]] to i64, [[DBG77]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata double [[LS]], [[META70:metadata !.*]], metadata !DIExpression()), [[DBG77]]
 ; DEBUG-NEXT:    br label [[END:%.*]], [[DBG78:!dbg !.*]]
 ; DEBUG:       else:
 ; DEBUG-NEXT:    [[LD:%.*]] = load double, double* [[D:%.*]], align 4, [[DBG79:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast double [[LD]] to i64
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast double [[LD]] to i64, [[DBG79]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata double [[LD]], [[META72:metadata !.*]], metadata !DIExpression()), [[DBG79]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG80:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i64 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata double undef, [[META73:metadata !.*]], metadata !DIExpression()), [[DBG81:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i64 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ], [[DBG81:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[PHI_TC]], [[META73:metadata !.*]], metadata !DIExpression()), [[DBG81]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[PHI_TC]], [[META74:metadata !.*]], metadata !DIExpression()), [[DBG82:!dbg !.*]]
 ; DEBUG-NEXT:    ret i64 [[PHI_TC]], [[DBG83:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   br i1 %cmp15, label %then, label %else
 
 then:

 ;
 ; DEBUG-LABEL: @convphi_f2i(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG91:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META86:metadata !.*]], metadata !DIExpression()), [[DBG91]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[ELSE:%.*]], [[DBG92:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load float, float* [[S:%.*]], align 4, [[DBG93:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast float [[LS]] to i32
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast float [[LS]] to i32, [[DBG93]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[LS]], [[META87:metadata !.*]], metadata !DIExpression()), [[DBG93]]
 ; DEBUG-NEXT:    br label [[END:%.*]], [[DBG94:!dbg !.*]]
 ; DEBUG:       else:
 ; DEBUG-NEXT:    [[LD:%.*]] = load float, float* [[D:%.*]], align 4, [[DBG95:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast float [[LD]] to i32
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast float [[LD]] to i32, [[DBG95]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[LD]], [[META88:metadata !.*]], metadata !DIExpression()), [[DBG95]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG96:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i32 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float undef, [[META89:metadata !.*]], metadata !DIExpression()), [[DBG97:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i32 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ], [[DBG97:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[PHI_TC]], [[META89:metadata !.*]], metadata !DIExpression()), [[DBG97]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[PHI_TC]], [[META90:metadata !.*]], metadata !DIExpression()), [[DBG98:!dbg !.*]]
 ; DEBUG-NEXT:    ret i32 [[PHI_TC]], [[DBG99:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   br i1 %cmp15, label %then, label %else
 
 then:

 ;
 ; DEBUG-LABEL: @convphi_h2i(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG108:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META102:metadata !.*]], metadata !DIExpression()), [[DBG108]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[ELSE:%.*]], [[DBG109:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load half, half* [[S:%.*]], align 4, [[DBG110:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast half [[LS]] to i16
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast half [[LS]] to i16, [[DBG110]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata half [[LS]], [[META103:metadata !.*]], metadata !DIExpression()), [[DBG110]]
 ; DEBUG-NEXT:    br label [[END:%.*]], [[DBG111:!dbg !.*]]
 ; DEBUG:       else:
 ; DEBUG-NEXT:    [[LD:%.*]] = load half, half* [[D:%.*]], align 4, [[DBG112:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast half [[LD]] to i16
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast half [[LD]] to i16, [[DBG112]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata half [[LD]], [[META105:metadata !.*]], metadata !DIExpression()), [[DBG112]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG113:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i16 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata half undef, [[META106:metadata !.*]], metadata !DIExpression()), [[DBG114:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i16 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ], [[DBG114:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i16 [[PHI_TC]], [[META106:metadata !.*]], metadata !DIExpression()), [[DBG114]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i16 [[PHI_TC]], [[META107:metadata !.*]], metadata !DIExpression()), [[DBG115:!dbg !.*]]
 ; DEBUG-NEXT:    ret i16 [[PHI_TC]], [[DBG116:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   br i1 %cmp15, label %then, label %else
 
 then:

 ;
 ; DEBUG-LABEL: @convphi_ld2i(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG125:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META119:metadata !.*]], metadata !DIExpression()), [[DBG125]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[ELSE:%.*]], [[DBG126:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load fp128, fp128* [[S:%.*]], align 4, [[DBG127:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast fp128 [[LS]] to i128
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast fp128 [[LS]] to i128, [[DBG127]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata fp128 [[LS]], [[META120:metadata !.*]], metadata !DIExpression()), [[DBG127]]
 ; DEBUG-NEXT:    br label [[END:%.*]], [[DBG128:!dbg !.*]]
 ; DEBUG:       else:
 ; DEBUG-NEXT:    [[LD:%.*]] = load fp128, fp128* [[D:%.*]], align 4, [[DBG129:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast fp128 [[LD]] to i128
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast fp128 [[LD]] to i128, [[DBG129]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata fp128 [[LD]], [[META122:metadata !.*]], metadata !DIExpression()), [[DBG129]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG130:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i128 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata fp128 undef, [[META123:metadata !.*]], metadata !DIExpression()), [[DBG131:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi i128 [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ], [[DBG131:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i128 [[PHI_TC]], [[META123:metadata !.*]], metadata !DIExpression()), [[DBG131]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i128 [[PHI_TC]], [[META124:metadata !.*]], metadata !DIExpression()), [[DBG132:!dbg !.*]]
 ; DEBUG-NEXT:    ret i128 [[PHI_TC]], [[DBG133:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   br i1 %cmp15, label %then, label %else
 
 then:

 ; CHECK-NEXT:    [[PHI_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI_TC]], [[LOOP]] ]
 ; CHECK-NEXT:    ret float [[PHI_TC]]
 ;
 ; DEBUG-LABEL: @convphi_loop(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i64 [[N:%.*]], 0, [[DBG161:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META152:metadata !.*]], metadata !DIExpression()), [[DBG161]]
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG162:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG162]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META153:metadata !.*]], metadata !DIExpression()), [[DBG162]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[LOOP:%.*]], label [[END:%.*]], [[DBG163:!dbg !.*]]
 ; DEBUG:       loop:
 ; DEBUG-NEXT:    [[IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ], [[DBG164:!dbg !.*]]
-; DEBUG-NEXT:    [[LPHI_TC:%.*]] = phi float [ [[LS_BC]], [[ENTRY]] ], [ [[LD_BC:%.*]], [[LOOP]] ]
+; DEBUG-NEXT:    [[LPHI_TC:%.*]] = phi float [ [[LS_BC]], [[ENTRY]] ], [ [[LD_BC:%.*]], [[LOOP]] ], [[DBG165:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[IV]], [[META154:metadata !.*]], metadata !DIExpression()), [[DBG164]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META155:metadata !.*]], metadata !DIExpression()), [[DBG165:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[LPHI_TC]], [[META155:metadata !.*]], metadata !DIExpression()), [[DBG165]]
 ; DEBUG-NEXT:    [[LD:%.*]] = load i32, i32* [[D:%.*]], align 4, [[DBG166:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC]] = bitcast i32 [[LD]] to float
+; DEBUG-NEXT:    [[LD_BC]] = bitcast i32 [[LD]] to float, [[DBG166]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LD]], [[META156:metadata !.*]], metadata !DIExpression()), [[DBG166]]
 ; DEBUG-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1, [[DBG167:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[IV_NEXT]], [[META157:metadata !.*]], metadata !DIExpression()), [[DBG167]]
 ; DEBUG-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]], [[DBG168:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[EXITCOND]], [[META158:metadata !.*]], metadata !DIExpression()), [[DBG168]]
 ; DEBUG-NEXT:    br i1 [[EXITCOND]], label [[END]], label [[LOOP]], [[DBG169:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI_TC]], [[LOOP]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META159:metadata !.*]], metadata !DIExpression()), [[DBG170:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI_TC]], [[LOOP]] ], [[DBG170:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META159:metadata !.*]], metadata !DIExpression()), [[DBG170]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META160:metadata !.*]], metadata !DIExpression()), [[DBG171:!dbg !.*]]
 ; DEBUG-NEXT:    ret float [[PHI_TC]], [[DBG172:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i64 %n, 0
   %ls = load i32, i32* %s, align 4
   br i1 %cmp15, label %loop, label %end
 

 ; CHECK-NEXT:    [[PHI_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI2_TC]], [[LOOP]] ]
 ; CHECK-NEXT:    ret float [[PHI_TC]]
 ;
 ; DEBUG-LABEL: @convphi_loopdelayed2(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i64 [[N:%.*]], 0, [[DBG208:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META198:metadata !.*]], metadata !DIExpression()), [[DBG208]]
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG209:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG209]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META199:metadata !.*]], metadata !DIExpression()), [[DBG209]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[LOOP:%.*]], label [[END:%.*]], [[DBG210:!dbg !.*]]
 ; DEBUG:       loop:
 ; DEBUG-NEXT:    [[IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[LOOP]] ], [[DBG211:!dbg !.*]]
-; DEBUG-NEXT:    [[LPHI_TC:%.*]] = phi float [ [[LS_BC]], [[ENTRY]] ], [ [[LD_BC:%.*]], [[LOOP]] ]
-; DEBUG-NEXT:    [[LPHI2_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI_TC]], [[LOOP]] ]
+; DEBUG-NEXT:    [[LPHI_TC:%.*]] = phi float [ [[LS_BC]], [[ENTRY]] ], [ [[LD_BC:%.*]], [[LOOP]] ], [[DBG212:!dbg !.*]]
+; DEBUG-NEXT:    [[LPHI2_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI_TC]], [[LOOP]] ], [[DBG213:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[IV]], [[META200:metadata !.*]], metadata !DIExpression()), [[DBG211]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META201:metadata !.*]], metadata !DIExpression()), [[DBG212:!dbg !.*]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META202:metadata !.*]], metadata !DIExpression()), [[DBG213:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[LPHI_TC]], [[META201:metadata !.*]], metadata !DIExpression()), [[DBG212]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[LPHI2_TC]], [[META202:metadata !.*]], metadata !DIExpression()), [[DBG213]]
 ; DEBUG-NEXT:    [[LD:%.*]] = load i32, i32* [[D:%.*]], align 4, [[DBG214:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC]] = bitcast i32 [[LD]] to float
+; DEBUG-NEXT:    [[LD_BC]] = bitcast i32 [[LD]] to float, [[DBG214]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LD]], [[META203:metadata !.*]], metadata !DIExpression()), [[DBG214]]
 ; DEBUG-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1, [[DBG215:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[IV_NEXT]], [[META204:metadata !.*]], metadata !DIExpression()), [[DBG215]]
 ; DEBUG-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]], [[DBG216:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[EXITCOND]], [[META205:metadata !.*]], metadata !DIExpression()), [[DBG216]]
 ; DEBUG-NEXT:    br i1 [[EXITCOND]], label [[END]], label [[LOOP]], [[DBG217:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI2_TC]], [[LOOP]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META206:metadata !.*]], metadata !DIExpression()), [[DBG218:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ undef, [[ENTRY]] ], [ [[LPHI2_TC]], [[LOOP]] ], [[DBG218:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META206:metadata !.*]], metadata !DIExpression()), [[DBG218]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META207:metadata !.*]], metadata !DIExpression()), [[DBG219:!dbg !.*]]
 ; DEBUG-NEXT:    ret float [[PHI_TC]], [[DBG220:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i64 %n, 0
   %ls = load i32, i32* %s, align 4
   br i1 %cmp15, label %loop, label %end
 

 ; CHECK-NEXT:    [[PHI_TC:%.*]] = phi float [ [[PHI1_TC]], [[IFEND]] ], [ [[PHI3_TC]], [[LOOPEND]] ]
 ; CHECK-NEXT:    ret float [[PHI_TC]]
 ;
 ; DEBUG-LABEL: @convphi_loopmore(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP:%.*]] = icmp eq i64 [[N:%.*]], 1, [[DBG236:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP]], [[META223:metadata !.*]], metadata !DIExpression()), [[DBG236]]
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG237:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG237]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META224:metadata !.*]], metadata !DIExpression()), [[DBG237]]
 ; DEBUG-NEXT:    br i1 [[CMP]], label [[THEN:%.*]], label [[IFEND:%.*]], [[DBG238:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LD:%.*]] = load i32, i32* [[D:%.*]], align 4, [[DBG239:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float, [[DBG239]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LD]], [[META225:metadata !.*]], metadata !DIExpression()), [[DBG239]]
 ; DEBUG-NEXT:    br label [[IFEND]], [[DBG240:!dbg !.*]]
 ; DEBUG:       ifend:
-; DEBUG-NEXT:    [[PHI1_TC:%.*]] = phi float [ [[LD_BC]], [[THEN]] ], [ [[LS_BC]], [[ENTRY:%.*]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META226:metadata !.*]], metadata !DIExpression()), [[DBG241:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI1_TC:%.*]] = phi float [ [[LD_BC]], [[THEN]] ], [ [[LS_BC]], [[ENTRY:%.*]] ], [[DBG241:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI1_TC]], [[META226:metadata !.*]], metadata !DIExpression()), [[DBG241]]
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i64 [[N]], 0, [[DBG242:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META227:metadata !.*]], metadata !DIExpression()), [[DBG242]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[LOOP:%.*]], label [[END:%.*]], [[DBG243:!dbg !.*]]
 ; DEBUG:       loop:
 ; DEBUG-NEXT:    [[IV:%.*]] = phi i64 [ 0, [[IFEND]] ], [ [[IV_NEXT:%.*]], [[LOOPEND:%.*]] ], [[DBG244:!dbg !.*]]
-; DEBUG-NEXT:    [[PHI2_TC:%.*]] = phi float [ [[PHI1_TC]], [[IFEND]] ], [ [[PHI3_TC:%.*]], [[LOOPEND]] ]
+; DEBUG-NEXT:    [[PHI2_TC:%.*]] = phi float [ [[PHI1_TC]], [[IFEND]] ], [ [[PHI3_TC:%.*]], [[LOOPEND]] ], [[DBG245:!dbg !.*]]
 ; DEBUG-NEXT:    [[TMP0:%.*]] = icmp eq i64 [[N]], 1, [[DBG236]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[IV]], [[META228:metadata !.*]], metadata !DIExpression()), [[DBG244]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META229:metadata !.*]], metadata !DIExpression()), [[DBG245:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI2_TC]], [[META229:metadata !.*]], metadata !DIExpression()), [[DBG245]]
 ; DEBUG-NEXT:    br i1 [[TMP0]], label [[LOOPTHEN:%.*]], label [[LOOPEND]], [[DBG246:!dbg !.*]]
 ; DEBUG:       loopthen:
 ; DEBUG-NEXT:    [[LL:%.*]] = load i32, i32* [[D]], align 4, [[DBG247:!dbg !.*]]
-; DEBUG-NEXT:    [[LL_BC:%.*]] = bitcast i32 [[LL]] to float
+; DEBUG-NEXT:    [[LL_BC:%.*]] = bitcast i32 [[LL]] to float, [[DBG247]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LL]], [[META230:metadata !.*]], metadata !DIExpression()), [[DBG247]]
 ; DEBUG-NEXT:    br label [[LOOPEND]], [[DBG248:!dbg !.*]]
 ; DEBUG:       loopend:
-; DEBUG-NEXT:    [[PHI3_TC]] = phi float [ [[LL_BC]], [[LOOPTHEN]] ], [ [[PHI2_TC]], [[LOOP]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META231:metadata !.*]], metadata !DIExpression()), [[DBG249:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI3_TC]] = phi float [ [[LL_BC]], [[LOOPTHEN]] ], [ [[PHI2_TC]], [[LOOP]] ], [[DBG249:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI3_TC]], [[META231:metadata !.*]], metadata !DIExpression()), [[DBG249]]
 ; DEBUG-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1, [[DBG250:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i64 [[IV_NEXT]], [[META232:metadata !.*]], metadata !DIExpression()), [[DBG250]]
 ; DEBUG-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[IV_NEXT]], [[N]], [[DBG251:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[EXITCOND]], [[META233:metadata !.*]], metadata !DIExpression()), [[DBG251]]
 ; DEBUG-NEXT:    br i1 [[EXITCOND]], label [[END]], label [[LOOP]], [[DBG252:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[PHI1_TC]], [[IFEND]] ], [ [[PHI3_TC]], [[LOOPEND]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META234:metadata !.*]], metadata !DIExpression()), [[DBG253:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[PHI1_TC]], [[IFEND]] ], [ [[PHI3_TC]], [[LOOPEND]] ], [[DBG253:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META234:metadata !.*]], metadata !DIExpression()), [[DBG253]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META235:metadata !.*]], metadata !DIExpression()), [[DBG254:!dbg !.*]]
 ; DEBUG-NEXT:    ret float [[PHI_TC]], [[DBG255:!dbg !.*]]
 ;
 entry:
   %cmp = icmp eq i64 %n, 1
   %ls = load i32, i32* %s, align 4
   br i1 %cmp, label %then, label %ifend
 

 ;
 ; DEBUG-LABEL: @convphi_stop3(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG299:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META294:metadata !.*]], metadata !DIExpression()), [[DBG299]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[ELSE:%.*]], [[DBG300:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG301:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG301]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META295:metadata !.*]], metadata !DIExpression()), [[DBG301]]
 ; DEBUG-NEXT:    br label [[END:%.*]], [[DBG302:!dbg !.*]]
 ; DEBUG:       else:
 ; DEBUG-NEXT:    [[LD:%.*]] = load i32, i32* [[D:%.*]], align 4, [[DBG303:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float, [[DBG303]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LD]], [[META296:metadata !.*]], metadata !DIExpression()), [[DBG303]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG304:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META297:metadata !.*]], metadata !DIExpression()), [[DBG305:!dbg !.*]]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ELSE]] ], [[DBG305:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META297:metadata !.*]], metadata !DIExpression()), [[DBG305]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META298:metadata !.*]], metadata !DIExpression()), [[DBG306:!dbg !.*]]
 ; DEBUG-NEXT:    store float [[PHI_TC]], float* [[E:%.*]], align 4, [[DBG307:!dbg !.*]]
 ; DEBUG-NEXT:    ret float [[PHI_TC]], [[DBG308:!dbg !.*]]
 ;
 entry:
   %cmp15 = icmp sgt i32 %n, 0
   br i1 %cmp15, label %then, label %else
 

 ; CHECK-NEXT:    store float [[PHI2]], float* [[E]], align 4
 ; CHECK-NEXT:    ret void
 ;
 ; DEBUG-LABEL: @convphi_stop4(
 ; DEBUG-NEXT:  entry:
 ; DEBUG-NEXT:    [[CMP15:%.*]] = icmp sgt i32 [[N:%.*]], 0, [[DBG318:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i1 [[CMP15]], [[META311:metadata !.*]], metadata !DIExpression()), [[DBG318]]
 ; DEBUG-NEXT:    [[LD:%.*]] = load i32, i32* [[D:%.*]], align 4, [[DBG319:!dbg !.*]]
-; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float
+; DEBUG-NEXT:    [[LD_BC:%.*]] = bitcast i32 [[LD]] to float, [[DBG319]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LD]], [[META312:metadata !.*]], metadata !DIExpression()), [[DBG319]]
 ; DEBUG-NEXT:    br i1 [[CMP15]], label [[THEN:%.*]], label [[END:%.*]], [[DBG320:!dbg !.*]]
 ; DEBUG:       then:
 ; DEBUG-NEXT:    [[LS:%.*]] = load i32, i32* [[S:%.*]], align 4, [[DBG321:!dbg !.*]]
-; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float
+; DEBUG-NEXT:    [[LS_BC:%.*]] = bitcast i32 [[LS]] to float, [[DBG321]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 [[LS]], [[META313:metadata !.*]], metadata !DIExpression()), [[DBG321]]
 ; DEBUG-NEXT:    br label [[END]], [[DBG322:!dbg !.*]]
 ; DEBUG:       end:
-; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ENTRY:%.*]] ]
+; DEBUG-NEXT:    [[PHI_TC:%.*]] = phi float [ [[LS_BC]], [[THEN]] ], [ [[LD_BC]], [[ENTRY:%.*]] ], [[DBG323:!dbg !.*]]
 ; DEBUG-NEXT:    [[TMP0:%.*]] = icmp sgt i32 [[N]], 0, [[DBG318]]
-; DEBUG-NEXT:    call void @llvm.dbg.value(metadata i32 undef, [[META314:metadata !.*]], metadata !DIExpression()), [[DBG323:!dbg !.*]]
+; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META314:metadata !.*]], metadata !DIExpression()), [[DBG323]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI_TC]], [[META315:metadata !.*]], metadata !DIExpression()), [[DBG324:!dbg !.*]]
-; DEBUG-NEXT:    [[BC:%.*]] = bitcast float [[PHI_TC]] to i32
-; DEBUG-NEXT:    store i32 [[BC]], i32* [[S]], align 4, [[DBG325:!dbg !.*]]
+; DEBUG-NEXT:    [[BC:%.*]] = bitcast float [[PHI_TC]] to i32, [[DBG325:!dbg !.*]]
+; DEBUG-NEXT:    store i32 [[BC]], i32* [[S]], align 4, [[DBG325]]
 ; DEBUG-NEXT:    br i1 [[TMP0]], label [[THEN2:%.*]], label [[END2:%.*]], [[DBG326:!dbg !.*]]
 ; DEBUG:       then2:
 ; DEBUG-NEXT:    [[LF:%.*]] = load float, float* [[E:%.*]], align 4, [[DBG327:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[LF]], [[META316:metadata !.*]], metadata !DIExpression()), [[DBG327]]
 ; DEBUG-NEXT:    br label [[END2]], [[DBG328:!dbg !.*]]
 ; DEBUG:       end2:
 ; DEBUG-NEXT:    [[PHI2:%.*]] = phi float [ [[PHI_TC]], [[END]] ], [ [[LF]], [[THEN2]] ], [[DBG329:!dbg !.*]]
 ; DEBUG-NEXT:    call void @llvm.dbg.value(metadata float [[PHI2]], [[META317:metadata !.*]], metadata !DIExpression()), [[DBG329]]