[Assignment Tracking Analysis][5/*] Tests

[Orlando]

Summary

The tests all check that the resultant MIR debug instructions look right when using SelectionDAG with AssignmentTrackingAnalysis.

---

Notes

I've bundled the tests together because the "core", "redundant removal", and "fragment fill" parts of the pass were not written in isolation as they are presented. I suppose the tests could be separated out into the patches if D136331 is applied before D136321 and D136325, but some disentangling will be required so it is my preference to keep them bundled if possible.

Maybe there is a better way to test the analysis that doesn't rely on something interpreting the results? OTOH, we do also want to be sure the results are being interpreted sensibly.

I'm definitely open to adding more tests if anyone has any suggestions.

[StephenTozer]

Some minor comments, but otherwise LGTM.

llvm/test/DebugInfo/assignment-tracking/X86/diamond-1.ll

29

47

llvm/test/DebugInfo/assignment-tracking/X86/diamond-2.ll

17

35

llvm/test/DebugInfo/assignment-tracking/X86/diamond-3.ll

20–22

llvm/test/DebugInfo/assignment-tracking/X86/loop-hoist.ll

21

34

Are the variables other than "a" actually needed for this test? Usually I think we'd delete variables that aren't relevant to the behaviour being tested.

llvm/test/DebugInfo/assignment-tracking/X86/loop-sink.ll

30–31

Could you try and test this with a vreg that isn't dropped? Checking for $noreg means that the expected behaviour is only being half tested for imo; if this particular "use a DbgDef instead of a MemDef" branch had a bug and just dropped defs instead of using the correct Value, this test wouldn't pick it up.

43

Same comment as the above test, if the variables other than "a" aren't being tested for could they be deleted from the test?

llvm/test/DebugInfo/assignment-tracking/X86/lower-to-value.ll

47–48

More just a question for my understanding than anything relevant to the test, but as far as I can tell continuing to use a stack location for the [0, 64] fragment would be correct in this case - is a partial invalidation of the stack location pessimistically considered to invalidate the whole stack location in some cases, and if so what makes it different from the frag-agg case (where we do redeclare the stack location for the valid bytes) in the next test?

llvm/test/DebugInfo/assignment-tracking/X86/mem-loc-frag-fill-cfg.ll

12

48

Nit, but I don't think this needs to be a CHECK-DAG, the metadata section comes before the MIR contents of the file iirc.

llvm/test/DebugInfo/assignment-tracking/X86/mem-loc-frag-fill.ll

32

Ditto above, no need for -DAG

[StephenTozer]

llvm/test/DebugInfo/assignment-tracking/X86/lower-to-value.ll

9

Add an implicit-check-not for DBG_INSTR_REF for the experiemental-debug-locations case?

llvm/test/DebugInfo/assignment-tracking/X86/mem-loc-frag-fill.ll

9

llvm/test/DebugInfo/assignment-tracking/X86/no-redundant-def-after-alloca.ll

4

6

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

10

Just for formatting consistency, maybe include the "Use X loc" here.

14

30–32

With these adjacent DBG_VALUEs describing the same variable, if the "remove redundant debug values" step understands that the first DBG_VALUE is entirely covered by the following two fragments then this test would start to fail. Maybe add an additional instruction between the first dbg.assign and dbg.value so that these two are not redundant (even if they currently aren't recognized as being so)? AFAIK that might also result in an extra debug value being produced by the agg-frag step, but I don't think there's any problem with that being included in the test if so.

llvm/test/DebugInfo/assignment-tracking/X86/use-known-value-at-early-mem-def-2.ll

6

44–46

Just to confirm - we're aware that c = 5, but because we're trying to produce an implicit value for the fragment it would take a bit of work to confirm what the lower 32 bits actually are? Which I think (assuming we don't examine the constant itself - also this is not a request to implement as part of this patch stack) would require us to insert an AND into the DIExpression to pull out only the lower 32 bits of the implicit value, i.e. DBG_VALUE 5, $noreg, ![[var]], !DIExpression(DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_stack_value). Does that sound correct?

[Orlando]

Thanks for another eagle-eyed review @StephenTozer

llvm/test/DebugInfo/assignment-tracking/X86/lower-to-value.ll

47–48

as far as I can tell continuing to use a stack location for the [0, 64] fragment would be correct in this case

That's right. We don't need to redeclare that the [0, 64) fragment is on the stack because the [64, 128) fragment loc def doesn't overlap the previous loc def for [0, 64), and non-overlapping fragment locations compose properly (i.e., mem-loc-frag-fill doesn't need to do anything here because it already works as expected).

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

30–32

f the "remove redundant debug values" step understands that the first DBG_VALUE is entirely covered by the following two fragments

IMO it'd be better to update the test if/when that happens - it feels like slightly unnecessary future-proofing to me. wdyt?

The important parts of the test are steps 4 (value/value) and 5 (mem/value after untagged store to lower bits).

llvm/test/DebugInfo/assignment-tracking/X86/use-known-value-at-early-mem-def-2.ll

44–46

Yeah that's right

[Orlando]

This can still be reviewed by others because the changes are not intrusive, but I plan to:

• Update the tests to use opaque pointers
• Remove TBAA metadata

[Orlando]

Removed tbaa metadata & updated tests to use opaque pointers.

[StephenTozer]

Changes all LGTM, except the one unaddressed comment about not using $noreg in loop-sink.ll.

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

30–32

Sure - at least it wouldn't be a "silent" failure, and if someone is modifying the redundant debug values code it shouldn't be hard to identify the cause of this failure. Though it also wouldn't hurt for posterity to add a comment along the lines of "TODO: If removeRedundantDbgInstrs gets smarter, add an instruction here to preserve this set of debug values".

[jmorse]

Worth putting implicit-check-not on all the tests?

(got up to loop-unroll.ll)

llvm/test/DebugInfo/assignment-tracking/X86/dbg-phi-produces-undef.ll

5–6

What would happen if non-constants were used, but there were no out-of-block users? The reason being that today we can recover variable locations that are coincidentally PHI'd correctly due to being in the right registers, even if there isn't an IR PHI happening and being used. But that won't happen if an explicit DBG_VALUE $noreg is produced at the merge point.

24

Nit -- something other than literal "XXX" would be preferred, I don't know whether this matches other peoples styles, but I've only ever seen XXX used to indicate TODOs or sketchy situations. In the default vim syntax highlighting config, XXX is highlighted in yellow as a TODO.

llvm/test/DebugInfo/assignment-tracking/X86/diamond-3.ll

34–37

I endorse the syntax; if this isn't happening, isn't that a regression from LowerDbgDeclare? debug-info-on-edges is a serious problem that we don't have a solution for right now sadly.

llvm/test/DebugInfo/assignment-tracking/X86/loop-hoist.ll

10–19

Just thinking out loud -- I suppose that without assignment tracking, we would end up with one dbg.value in the entry block for the argument, then one in the middle of the do.body loop. And because where the do.body loop joins there's no PHI to merge those values, there's no way to get a correct variable location on the multiplication.

I don't see any way to improve this with assignment tracking, right? It always requires there to be a PHI, so that we know which loop iteration we're in.

(Not a criticism, just confirming to myself that I understand what's going on).

llvm/test/DebugInfo/assignment-tracking/X86/loop-sink.ll

30–31

Looks like it's because it's an Argument rather than any other value -- I agree that it'd be better to fiddle with the test to avoid checking for undef, this will ensure good coverage in the future.

58

I had the slight expectation that this was going to get a dbg.value attached to it, this is deliberately dropped then?

[Orlando]

Address / respond to inline comments.

Worth putting implicit-check-not on all the tests?

NOTE to self: look into this.

[Orlando]

(forgot to submit the inline comments)

llvm/test/DebugInfo/assignment-tracking/X86/dbg-phi-produces-undef.ll

5–6

Interesting question -- the DBG_VALUE $noreg is not actually produced at the merge point though, it's inserted after the store which is storing performing assignment named !2 while the debug program asserts that assignment !1 should still be visible.

AssignmentTrackingAnalysis just tracks merge points, it does not insert location defs (/undef) at merge points itself.

llvm/test/DebugInfo/assignment-tracking/X86/diamond-3.ll

34–37

Yeah it is a regression. I think TODO / WISHLIST should probably be renamed FIXME to indicate this. This is on my mental TODO list but I should add this to the actual TODO list in the documentation - leaving this comment as "not done" as a reminder to do that before landing.

llvm/test/DebugInfo/assignment-tracking/X86/loop-hoist.ll

10–19

Yeah that all sounds correct.

llvm/test/DebugInfo/assignment-tracking/X86/loop-sink.ll

30–31

Sorry I left this one not-done to come back to, and forgot to come back to it. Done.

58

As in by the analysis pass (as a DBG_VALUE/INSTR_REF), or in this IR? Wasn't there a patch that stopped insertDebugValuesForPHIs being called by LCSSA maybe a year or so ago?

[jmorse]

I can't really work out what untagged-store-frag.ll is testing as I don't get the notation, alas.

llvm/test/DebugInfo/assignment-tracking/X86/diamond-3.ll

34–37

Cool; I think we're alright landing things + evaluating so long as we've got this limitation on the radar. It's not like LowerDbgDeclare is perfect anyway.

llvm/test/DebugInfo/assignment-tracking/X86/loop-sink.ll

58

Yeah, but IIRC that was only for PHIs with single operands -- the loop here doesn't dominate the exit block, thus the PHI is relevant. Prodding this (full marks for including original source) with clang-15 shows it's not a regression. I'll write this down as something to examine later I guess. I think in the general case LiveDebugValues will recover this anyway.

llvm/test/DebugInfo/assignment-tracking/X86/order-of-defs.ll

11

!20 needs to be a captured variable

llvm/test/DebugInfo/assignment-tracking/X86/remove-redundant-defs-to-prevent-reordering.ll

20

Not sure if it's "A" or "An", depends how you pronounce it I guess

llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll

72

You'll make the undef-to-poison people happy if you don't add this in a test.

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

4–5

From a standing start, I don't know what mem(a) and dbg(a) represent -- presumably the in-memory-or-in-value result computed by assignment tracing? But then the comment on 2. conflicts with that?

llvm/test/DebugInfo/assignment-tracking/X86/use-known-value-at-early-mem-def.ll

5

[Orlando]

(just responding to one inline comment to try to clear up my confusing comments)

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

4–5

1. mem(a): bits [0, 64) = !14 represents a store to the memory location of a (bits [0, 64)) with a !DIAssignID !14 attachment .
2. dbg(a): bits [0, 64) = !14 represents a for the same var/bits using !DIAssignID !14

The end-of-line comment indicates what the analysis is working out. The analysis sees that at (/just after) position 2 the (conceptual/source) variable and the variable's memory location are both dominated by the assignment !14 at this point, so we can use the memory location. Does that help at all?

[Orlando]

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

4–5

2. dbg(a): bits [0, 64) = !14 represents a for the same var/bits using !DIAssignID !14 is meant to read "...represents a dbg.assign for the same...

Sorry!

[Orlando]

llvm/test/DebugInfo/assignment-tracking/X86/order-of-defs.ll

11

Removed - I don't think they add anything valuable to the test.

[jmorse]

Just thinking out loud about coverage -- it seems to me that there are several dimensions over which the assignment-tracking lattice analysis should run, which are:

• The domain of dbg.assign "state"/value, i.e. whether it has complete information in the intrinsic: {`both, value-only, link-only, neither},
• Whether there's a linked store or not,
• Whether the store comes before or after the intrinsic,
• CFG patterns between the store, intrinsic, and intrinsics with a different state/value, i.e. whether there's straight-line-code, diamonds, loops, in the way.

Put it all together and you get something like 50 or 60 different scenarios to test. We don't need explicit tests for every single path through the compiler, however to my mind what we're missing right now is interactions between loops and dbg.assigns with different states. This is something that LiveDebugValues used to get very wrong. For example, IMO we want an explicit test like loop-sink.ll but where there's a second loop exit path where there's a dbg.value(undef,). In that situation we'd want to ensure that the subsequent store doesn't become the variable location.

[jmorse]

I suppose another way of thinking about that is ensuring every lattice transition gets explored across every CFG join pattern that can exist.

[Orlando]

+ Add nested-loop.ll that tests a variety of inputs/lattices

Note that this actually currently fails (just the part for variable 'f') - the test uncovered a bug with untagged store handling. I thought it would be worth getting the test up for review anyway.

If you're happy with this style of test then I'll add another that uses fragments to check that all works too.

[Orlando]

In D136335#3960681, @Orlando wrote:

+ Add nested-loop.ll that tests a variety of inputs/lattices

Note that this actually currently fails (just the part for variable 'f') - the test uncovered a bug with untagged store handling. I thought it would be worth getting the test up for review anyway.

If you're happy with this style of test then I'll add another that uses fragments to check that all works too.

I've fixed the analysis patch so that this test now passes.

[Orlando]

Add nested-loop-sroa.ll which is a copy of nested-loop.ll except that the allocas hold a fragment of a variable except the whole variable. In writing this I discovered another bug with untagged store handling (I introduced it in my last update addressing the previous bug).

[jmorse]

The new two tests look good, and the documentation is highly appreciated -- is there are need to check for new "loc=none" locations being fed in, or is that something that's in the domain of LiveDebugValues? (I keep on switching back to the mindset of "every piece of information needs a dbg.value", which is not the situation in this pass).

llvm/test/DebugInfo/assignment-tracking/X86/nested-loop-sroa.ll

89–97 ↗

(On Diff #479314)

To help my understanding -- the dbg=phi on entry to do.body is because entry feeds in constant-value 9, while the assignment in do.body1 feeds in constant-value 8, yes? While stores of !77 to the stack location dominate from entry onwards.

[Orlando]

llvm/test/DebugInfo/assignment-tracking/X86/nested-loop-sroa.ll

89–97 ↗

(On Diff #479314)

the dbg=phi on entry to do.body is because entry feeds in constant-value 9, while the assignment in do.body1 feeds in constant-value 8, yes

Yes except it's the DIAssignIDs associated with those constant-value dbg.assigns being different that matters, rather than the constant values. The 8 and 9 could both be 8, for example, and the table would look the same.

While stores of !77 to the stack location dominate from entry onwards.

Yep

160 ↗

(On Diff #479314)

Note to self: the end of line comment above should be VAR:e rather than VAR:c.

[Orlando]

is there are need to check for new "loc=none" locations being fed in

The two new tests both do encounter None in process but I think you're right that neither check that None is joined correctly. I'll add another variable to them both to check that.

FYI I'm working on one final test that exercises the mem-loc-frag-fill pass too.

[Orlando]

+ Fix comments in tests
+ Add nested-loop-frags.ll which is similar to nested-loop-sora.ll and nested-loop.ll. It has 64 bit variables/allocas, with a mix of 32 and 64 bit stores.

Another bug was found when writing that new test which I will patch shortly. All of these bugs have been to do with fragment handling (unsurprisingly).

[jmorse]

I had another chat with Orlando about how we're testing these patches -- I'm pretty happy that we're now testing all the important paths through the assignment-tracking analysis pass, and the different ways that CFGs can compose and have different lattice input/output values. Nothing really springs to mind about what else we can be testing -- and significantly, this work is not going to be enabled by default, we'll be doing a decent amount of validating on larger projects first.

With that in mind, LGTM to land. I anticipate that validation is going to find other bugs in this pass, but we're past the point of more guessing-at-what-to-test being a good return on investment....

Another bug was found when writing that new test which I will patch shortly. All of these bugs have been to do with fragment handling (unsurprisingly).

Assuming this is now fixed!

[Orlando]

Squashed into 1d1de7467c32d52926ca56b9167a2c65c451ecfa

[Orlando]

llvm/test/DebugInfo/assignment-tracking/X86/diamond-3.ll

34–37

Added to todo list in 7ea80c279f59b0567d26c77155d982b5d6ce1c81

[saghir]

Hi @Orlando, the test case (remove-undef-fragment.ll) that you added as part of 1d1de7467c32d52926ca56b9167a2c65c451ecfa is breaking one of our bots: https://lab.llvm.org/staging/#/builders/14/builds/1332. Can you please take a look? Thanks!

[stefanp]

It looks like the test test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll fails on multiple PPC bots.
https://lab.llvm.org/buildbot/#/builders/214/builds/4756
https://lab.llvm.org/buildbot/#/builders/231/builds/6006
https://lab.llvm.org/buildbot/#/builders/121/builds/26032

The test only has two checks:

; CHECK: DBG{{.*}}DIExpression(DW_OP_LLVM_fragment, 0, 32)
; CHECK: DBG{{.*}}DIExpression(DW_OP_LLVM_fragment, 64, 32)

On PPC the output from ISel only has the second line. Was this test meant to be X86 specific? (I'm asking based on the path).
I'm inclined to restrict this test to X86 until we figure out the problem.

[haowei]

Test "DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll" is failing on Fuchsia's Linux ARM64 Clang builder as well. Error message:

Script:
--
: 'RUN: at line 1';   /b/s/w/ir/x/w/staging/llvm_build/bin/llc /b/s/w/ir/x/w/llvm-llvm-project/llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll -o - -stop-after=finalize-isel     -experimental-assignment-tracking   | /b/s/w/ir/x/w/staging/llvm_build/bin/FileCheck /b/s/w/ir/x/w/llvm-llvm-project/llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll --implicit-check-not=DBG
--
Exit Code: 1

Command Output (stderr):
--
/b/s/w/ir/x/w/llvm-llvm-project/llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll:26:10: error: CHECK: expected string not found in input
; CHECK: DBG{{.*}}DIExpression(DW_OP_LLVM_fragment, 0, 32)
         ^
<stdin>:1:1: note: scanning from here
--- |
^
<stdin>:2:80: note: possible intended match here
 ; ModuleID = '/b/s/w/ir/x/w/llvm-llvm-project/llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll'
                                                                               ^

Input file: <stdin>
Check file: /b/s/w/ir/x/w/llvm-llvm-project/llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll

-dump-input=help explains the following input dump.

Input was:
<<<<<<
            1: --- | 
check:26'0     X~~~~~ error: no match found
            2:  ; ModuleID = '/b/s/w/ir/x/w/llvm-llvm-project/llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll' 
check:26'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
check:26'1                                                                                    ?                                      possible intended match
            3:  source_filename = "/b/s/w/ir/x/w/llvm-llvm-project/llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll" 
check:26'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            4:  target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" 
check:26'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            5:   
check:26'0     ~~
            6:  define void @_Z1kv({ <2 x float>, <2 x float> } %call, <2 x float> %0, float %n.sroa.6.8.vec.extract) !dbg !7 { 
check:26'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            7:  entry: 
check:26'0     ~~~~~~~~
            .
            .
            .
>>>>>>

builder link: https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-linux-arm64/b8795235652012316209/overview

Please take a look and if it takes a while to fix, please revert this patch.

[stefanp]

I've made the test X86 only to allow time for this to be investigated.
34a3259fab86aaa1a20224e08849775f3593e6a3
This should help bring the bots back to green in the meantime.

[stefanp]

In D136335#3985562, @haowei wrote:

Test "DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll" is failing on Fuchsia's Linux ARM64 Clang builder as well. Error message:

Sorry, I didn't realize that this was failing on other platforms as well. If you need to revert this patch feel free to revert the patch that I added as well.

[Orlando]

In D136335#3985585, @stefanp wrote:

I've made the test X86 only to allow time for this to be investigated.
34a3259fab86aaa1a20224e08849775f3593e6a3
This should help bring the bots back to green in the meantime.

Thank you for sorting this out. These failures came in out of work hours for me here - I just came back to check on this patch and you've already kindly unblocked the bots.

It looks like llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll is missing a target triple - I fix this on Monday.

Thanks again.

llvm/test/DebugInfo/assignment-tracking/X86/DSE.ll

+; RUN: llc %s -stop-before=finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking  \
+; RUN: | FileCheck %s
+
+; Check basic lowering behaviour of dbg.assign intrinsics. The first
+; assignment to `local`, which has been DSE'd, should be represented with a
+; constant value DBG_VALUE. The second assignment should have a DBG_VALUE
+; describing the stack home of the variable.
+
+; $ cat test.c
+; void esc(int*);
+; void fun() {
+;   int local = 5;
+;   // ^ killed by v
+;   local = 6;
+;   esc(&local);
+; }
+; $ clang -O2 -g -emit -llvm -S test.c -o -
+
+; CHECK: ![[LOCAL:[0-9]+]] = !DILocalVariable(name: "local",
+; CHECK: DBG_VALUE 5, $noreg, ![[LOCAL]], !DIExpression(), debug-location ![[DBG:[0-9]+]]
+; CHECK-NEXT: MOV32mi [[DEST:.*]], 1, $noreg, 0, $noreg, 6
+; CHECK-NEXT: DBG_VALUE [[DEST]], $noreg, ![[LOCAL]], !DIExpression(DW_OP_deref), debug-location ![[DBG]]
+
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local void @fun() local_unnamed_addr !dbg !7 {
+entry:
+  %local = alloca i32, align 4
+  call void @llvm.dbg.assign(metadata i32 5, metadata !11, metadata !DIExpression(), metadata !30, metadata ptr %local, metadata !DIExpression()), !dbg !16
+  store i32 6, ptr %local, align 4, !dbg !23, !DIAssignID !31
+  call void @llvm.dbg.assign(metadata i32 6, metadata !11, metadata !DIExpression(), metadata !31, metadata ptr %local, metadata !DIExpression()), !dbg !16
+  call void @esc(ptr nonnull %local), !dbg !24
+  ret void, !dbg !25
+}
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+declare !dbg !26 dso_local void @esc(ptr) local_unnamed_addr
+
+!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 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "fun", scope: !1, file: !1, line: 2, type: !8, scopeLine: 2, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "local", scope: !7, file: !1, line: 3, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!14 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !12)
+!15 = !DILocation(line: 3, column: 3, scope: !7)
+!16 = !DILocation(line: 0, scope: !7)
+!17 = !DILocation(line: 4, column: 3, scope: !7)
+!18 = !DILocation(line: 4, column: 16, scope: !7)
+!23 = !DILocation(line: 5, column: 9, scope: !7)
+!24 = !DILocation(line: 6, column: 3, scope: !7)
+!25 = !DILocation(line: 7, column: 1, scope: !7)
+!26 = !DISubprogram(name: "esc", scope: !1, file: !1, line: 1, type: !27, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!27 = !DISubroutineType(types: !28)
+!28 = !{null, !29}
+!29 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
+!30 = distinct !DIAssignID()
+!31 = distinct !DIAssignID()
+

llvm/test/DebugInfo/assignment-tracking/X86/dbg-phi-produces-undef.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s
+
+;; Hand written test because the scenario is unlikely. Check that the "value"
+;; of a debug def PHIs is "undef" (because we don't actually track PHIs).
+;;
+;; entry:
+;;   memdef 5, !1
+;;   dbgdef !1
+;;   br if.then, exit
+;;
+;; if.then:
+;;   memdef 0, !1
+;;   dbgdef !1
+;;   br exit
+;;
+;; exit:
+;;                  ; <-- Dbg=!1, Stack=!1, Loc=Mem
+;;   memddef 1, !2  ; <-- Dbg=!1, Stack=!2, Loc=Val(undef) @HERE
+;;   call
+;;   dbgdef !2
+;;
+;; Check that the dbg.value inserted at @HERE is undef because there's no
+;; appropriate alternative value to choose.
+
+; CHECK: bb.0.entry:
+; CHECK: DBG_VALUE %stack.0.c, $noreg, ![[var:[0-9]+]], !DIExpression(DW_OP_deref), debug-location
+; CHECK-NEXT: MOV8mi %stack.0.c, 1, $noreg, 0, $noreg, 5, debug-location
+; CHECL-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var]], !DIExpression(DW_OP_deref), debug-location
+
+; CHECK: bb.1.if.then:
+; CHECK: MOV8mi %stack.0.c, 1, $noreg, 0, $noreg, 0
+; CHECK: DBG_VALUE %stack.0.c, $noreg, ![[var]], !DIExpression(DW_OP_deref), debug-location
+
+; CHECK:  bb.2.exit:
+; CHECK-NEXT: MOV8mi %stack.0.c, 1, $noreg, 0, $noreg, 1
+;; @HERE
+; CHECK-NEXT: DBG_VALUE $noreg, $noreg, ![[var]], !DIExpression()
+; CHECK: CALL64pcrel32 @d
+; CHECK-NEXT: ADJCALLSTACKUP64
+; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var]], !DIExpression(DW_OP_deref), debug-location
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @b(i1 %cond) local_unnamed_addr #0 !dbg !7 {
+entry:
+  %c = alloca i8, align 1, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(), metadata !13, metadata ptr %c, metadata !DIExpression()), !dbg !14
+  store i8 5, ptr %c, align 1, !dbg !16, !DIAssignID !31
+  call void @llvm.dbg.assign(metadata i8 5, metadata !11, metadata !DIExpression(), metadata !31, metadata ptr %c, metadata !DIExpression()), !dbg !14
+  br i1 %cond, label %if.then, label %exit
+
+if.then:
+  tail call void (...) @d() #4, !dbg !21
+  store i8 0, ptr %c, align 1, !dbg !16, !DIAssignID !31
+  call void @llvm.dbg.assign(metadata i8 0, metadata !11, metadata !DIExpression(), metadata !31, metadata ptr %c, metadata !DIExpression()), !dbg !14
+  br label %exit
+
+exit:
+  store i8 1, ptr %c, align 1, !dbg !16, !DIAssignID !20
+  tail call void (...) @d() #4, !dbg !21
+  call void @llvm.dbg.assign(metadata i8 1, metadata !11, metadata !DIExpression(), metadata !20, metadata ptr %c, metadata !DIExpression()), !dbg !14
+  call void @a(ptr nonnull %c) #4, !dbg !22
+  ret void, !dbg !23
+}
+
+
+declare !dbg !24 dso_local void @d(...) local_unnamed_addr #2
+declare !dbg !27 dso_local void @a(ptr) local_unnamed_addr #2
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
+
+!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 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "reduce.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "b", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "c", scope: !7, file: !1, line: 4, type: !12)
+!12 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!13 = distinct !DIAssignID()
+!14 = !DILocation(line: 0, scope: !7)
+!15 = !DILocation(line: 4, column: 3, scope: !7)
+!16 = !DILocation(line: 4, column: 8, scope: !7)
+!20 = distinct !DIAssignID()
+!21 = !DILocation(line: 5, column: 3, scope: !7)
+!22 = !DILocation(line: 6, column: 3, scope: !7)
+!23 = !DILocation(line: 7, column: 1, scope: !7)
+!24 = !DISubprogram(name: "d", scope: !1, file: !1, line: 2, type: !25, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!25 = !DISubroutineType(types: !26)
+!26 = !{null, null}
+!27 = !DISubprogram(name: "a", scope: !1, file: !1, line: 1, type: !28, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!28 = !DISubroutineType(types: !29)
+!29 = !{null, !30}
+!30 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
+!31 = distinct !DIAssignID()

llvm/test/DebugInfo/assignment-tracking/X86/diamond-1.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s
+
+;; cat test.cpp
+;; void d();
+;; void e();
+;; void es(int*);
+;; int  f(int a) {
+;;   if (a) {
+;;     e();
+;;     a = 100;    
+;;   } else {
+;;     d();
+;;     a = 500;    
+;;   }
+;;   es(&a);
+;;   return a;
+;; }
+;; $ clang++ test.cpp -S -emit-llvm -Xclang -fexperimental-assignment-tracking
+
+;; Check that the memory location is selected after the store in if.end:
+;; entry:
+;;   a = param-value
+;; if.then:
+;;   a = 100
+;; if.else:
+;;   a = 500
+;; if.end:
+;;   store (phi if.then: 100, if.else: 500)
+;;   a = in memory
+
+; CHECK-DAG: ![[VAR:[0-9]+]] = !DILocalVariable(name: "a",
+
+; CHECK: bb.0.entry:
+; CHECK: DBG_VALUE $edi, $noreg, ![[VAR]], !DIExpression()
+
+; CHECK: bb.1.if.then:
+; CHECK: DBG_VALUE 100, $noreg, ![[VAR]], !DIExpression()
+
+; CHECK: bb.2.if.else:
+; CHECK: DBG_VALUE 500, $noreg, ![[VAR]], !DIExpression()
+
+; CHECK: bb.3.if.end:
+; CHECK-NEXT: %0:gr32 = PHI %2, %bb.1, %3, %bb.2
+; CHECK-NEXT: MOV32mr %stack.0.a.addr, 1, $noreg, 0, $noreg, %0
+; CHECK-NEXT: DBG_VALUE %stack.0.a.addr, $noreg, ![[VAR]], !DIExpression(DW_OP_deref)
+
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: mustprogress uwtable
+define dso_local noundef i32 @_Z1fi(i32 noundef %a) local_unnamed_addr #0 !dbg !7 {
+entry:
+  %a.addr = alloca i32, align 4, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !12, metadata !DIExpression(), metadata !13, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  call void @llvm.dbg.assign(metadata i32 %a, metadata !12, metadata !DIExpression(), metadata !15, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  %tobool.not = icmp eq i32 %a, 0, !dbg !16
+  br i1 %tobool.not, label %if.else, label %if.then, !dbg !18
+
+if.then:                                          ; preds = %entry
+  tail call void @_Z1ev(), !dbg !19
+  call void @llvm.dbg.assign(metadata i32 100, metadata !12, metadata !DIExpression(), metadata !21, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  br label %if.end, !dbg !22
+
+if.else:                                          ; preds = %entry
+  tail call void @_Z1dv(), !dbg !23
+  call void @llvm.dbg.assign(metadata i32 500, metadata !12, metadata !DIExpression(), metadata !21, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+  %storemerge = phi i32 [ 500, %if.else ], [ 100, %if.then ], !dbg !25
+  store i32 %storemerge, ptr %a.addr, align 4, !dbg !25, !DIAssignID !21
+  call void @_Z2esPi(ptr noundef nonnull %a.addr), !dbg !30
+  %0 = load i32, ptr %a.addr, align 4, !dbg !31
+  ret i32 %0, !dbg !32
+}
+
+declare !dbg !33 dso_local void @_Z1ev() local_unnamed_addr #1
+declare !dbg !37 dso_local void @_Z1dv() local_unnamed_addr #1
+declare !dbg !38 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 1}
+!6 = !{!"clang version 14.0.0"}
+!7 = distinct !DISubprogram(name: "f", linkageName: "_Z1fi", scope: !1, file: !1, line: 4, type: !8, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 4, type: !10)
+!13 = distinct !DIAssignID()
+!14 = !DILocation(line: 0, scope: !7)
+!15 = distinct !DIAssignID()
+!16 = !DILocation(line: 5, column: 7, scope: !17)
+!17 = distinct !DILexicalBlock(scope: !7, file: !1, line: 5, column: 7)
+!18 = !DILocation(line: 5, column: 7, scope: !7)
+!19 = !DILocation(line: 6, column: 5, scope: !20)
+!20 = distinct !DILexicalBlock(scope: !17, file: !1, line: 5, column: 10)
+!21 = distinct !DIAssignID()
+!22 = !DILocation(line: 8, column: 3, scope: !20)
+!23 = !DILocation(line: 9, column: 5, scope: !24)
+!24 = distinct !DILexicalBlock(scope: !17, file: !1, line: 8, column: 10)
+!25 = !DILocation(line: 0, scope: !17)
+!30 = !DILocation(line: 12, column: 3, scope: !7)
+!31 = !DILocation(line: 13, column: 10, scope: !7)
+!32 = !DILocation(line: 13, column: 3, scope: !7)
+!33 = !DISubprogram(name: "e", linkageName: "_Z1ev", scope: !1, file: !1, line: 2, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
+!34 = !DISubroutineType(types: !35)
+!35 = !{null}
+!36 = !{}
+!37 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !1, file: !1, line: 1, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
+!38 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !1, file: !1, line: 3, type: !39, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
+!39 = !DISubroutineType(types: !40)
+!40 = !{null, !41}
+!41 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)

llvm/test/DebugInfo/assignment-tracking/X86/diamond-2.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s
+
+;; Same as diamond-1.ll except that the DIAssignID attached to the store has
+;; been deleted. In this case, we expect the same output as for diamond-1.ll
+;; because we choose to interpret stores to stack slots that don't link to
+;; debug intrinsics for a variable in the stack slot as a though they're linked
+;; to one placed immediately after.
+;;
+;; entry:
+;;   a = param-value
+;; if.then:
+;;   a = 100
+;; if.else:
+;;   a = 500
+;; if.end:
+;;   store (phi if.then: 100, if.else: 500)
+;;   a = in memory
+
+; CHECK-DAG: ![[VAR:[0-9]+]] = !DILocalVariable(name: "a",
+
+; CHECK: bb.0.entry:
+; CHECK: DBG_VALUE $edi, $noreg, ![[VAR]], !DIExpression()
+
+; CHECK: bb.1.if.then:
+; CHECK: DBG_VALUE 100, $noreg, ![[VAR]], !DIExpression()
+
+; CHECK: bb.2.if.else:
+; CHECK: DBG_VALUE 500, $noreg, ![[VAR]], !DIExpression()
+
+; CHECK: bb.3.if.end:
+; CHECK-NEXT: %0:gr32 = PHI %2, %bb.1, %3, %bb.2
+; CHECK-NEXT: MOV32mr %stack.0.a.addr, 1, $noreg, 0, $noreg, %0
+; CHECK-NEXT: DBG_VALUE %stack.0.a.addr, $noreg, ![[VAR]], !DIExpression(DW_OP_deref)
+
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: mustprogress uwtable
+define dso_local noundef i32 @_Z1fi(i32 noundef %a) local_unnamed_addr #0 !dbg !7 {
+entry:
+  %a.addr = alloca i32, align 4, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !12, metadata !DIExpression(), metadata !13, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  call void @llvm.dbg.assign(metadata i32 %a, metadata !12, metadata !DIExpression(), metadata !15, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  %tobool.not = icmp eq i32 %a, 0, !dbg !16
+  br i1 %tobool.not, label %if.else, label %if.then, !dbg !18
+
+if.then:                                          ; preds = %entry
+  tail call void @_Z1ev(), !dbg !19
+  call void @llvm.dbg.assign(metadata i32 100, metadata !12, metadata !DIExpression(), metadata !21, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  br label %if.end, !dbg !22
+
+if.else:                                          ; preds = %entry
+  tail call void @_Z1dv(), !dbg !23
+  call void @llvm.dbg.assign(metadata i32 500, metadata !12, metadata !DIExpression(), metadata !21, metadata ptr %a.addr, metadata !DIExpression()), !dbg !14
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+  %storemerge = phi i32 [ 500, %if.else ], [ 100, %if.then ], !dbg !25
+  store i32 %storemerge, ptr %a.addr, align 4, !dbg !25
+  call void @_Z2esPi(ptr noundef nonnull %a.addr), !dbg !30
+  %0 = load i32, ptr %a.addr, align 4, !dbg !31
+  ret i32 %0, !dbg !32
+}
+
+declare !dbg !33 dso_local void @_Z1ev() local_unnamed_addr #1
+declare !dbg !37 dso_local void @_Z1dv() local_unnamed_addr #1
+declare !dbg !38 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 1}
+!6 = !{!"clang version 14.0.0"}
+!7 = distinct !DISubprogram(name: "f", linkageName: "_Z1fi", scope: !1, file: !1, line: 4, type: !8, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 4, type: !10)
+!13 = distinct !DIAssignID()
+!14 = !DILocation(line: 0, scope: !7)
+!15 = distinct !DIAssignID()
+!16 = !DILocation(line: 5, column: 7, scope: !17)
+!17 = distinct !DILexicalBlock(scope: !7, file: !1, line: 5, column: 7)
+!18 = !DILocation(line: 5, column: 7, scope: !7)
+!19 = !DILocation(line: 6, column: 5, scope: !20)
+!20 = distinct !DILexicalBlock(scope: !17, file: !1, line: 5, column: 10)
+!21 = distinct !DIAssignID()
+!22 = !DILocation(line: 8, column: 3, scope: !20)
+!23 = !DILocation(line: 9, column: 5, scope: !24)
+!24 = distinct !DILexicalBlock(scope: !17, file: !1, line: 8, column: 10)
+!25 = !DILocation(line: 0, scope: !17)
+!30 = !DILocation(line: 12, column: 3, scope: !7)
+!31 = !DILocation(line: 13, column: 10, scope: !7)
+!32 = !DILocation(line: 13, column: 3, scope: !7)
+!33 = !DISubprogram(name: "e", linkageName: "_Z1ev", scope: !1, file: !1, line: 2, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
+!34 = !DISubroutineType(types: !35)
+!35 = !{null}
+!36 = !{}
+!37 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !1, file: !1, line: 1, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
+!38 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !1, file: !1, line: 3, type: !39, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !36)
+!39 = !DISubroutineType(types: !40)
+!40 = !{null, !41}
+!41 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)

llvm/test/DebugInfo/assignment-tracking/X86/diamond-3.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+
+;; Hand written to test scenario we can definitely run into in the wild. This
+;; file name includes "diamond" because the idea is that we lose (while
+;; optimizing) one of the diamond branches which was empty except for a debug
+;; intrinsic. In this case, the debug intrinsic linked to the common-and-sunk
+;; store now in if.end. So we've got this:
+;;
+;; entry:          ; -> br if.then, if.end
+;;    mem(a) = !19
+;;    dbg(a) = !21 ; dbg and mem disagree, don't use mem loc.
+;; if.then:        ; -> br if.end
+;;    dbg(a) = !20
+;; if.end:
+;;    mem(a) = !20 ; two preds disagree that !20 is the last assignment, don't
+;;                 ; use mem loc.
+;;    ; This feels highly unfortunate, and highlights the need to reinstate the
+;;    ; memory location at call sites leaking the address (in an ideal world,
+;;    ; the memory location would always be in use at that point and so this
+;;    ; wouldn't be necessary).
+;;    esc(a)       ; force the memory location
+
+;; In real world examples this is caused by InstCombine sinking common code
+;; followed by SimplifyCFG deleting empty-except-for-dbg blocks.
+
+; CHECK-DAG: ![[A:[0-9]+]] = !DILocalVariable(name: "a",
+; CHECK-LABEL: bb.0.entry:
+; CHECK:         DBG_VALUE $edi, $noreg, ![[A]], !DIExpression()
+; CHECK-LABEL: bb.1.if.then:
+; CHECK:         DBG_VALUE 0, $noreg, ![[A]], !DIExpression()
+
+;; === TODO / WISHLIST ===
+; LEBAL-KCEHC: bb.2.if.end:
+; KCEHC:         CALL64pcrel32 target-flags(x86-plt) @es
+; KCEHC:         DBG_VALUE %stack.0.a.addr, $noreg, ![[A]], !DIExpression(DW_OP_deref)
+
+target triple = "x86_64-unknown-linux-gnu"
+
+@g = dso_local local_unnamed_addr global ptr null, align 8, !dbg !0
+
+define dso_local noundef i32 @_Z1fiii(i32 noundef %a, i32 noundef %b, i32 noundef %c) local_unnamed_addr #0 !dbg !12 {
+entry:
+  %a.addr = alloca i32, align 4, !DIAssignID !19
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !16, metadata !DIExpression(), metadata !19, metadata ptr %a.addr, metadata !DIExpression()), !dbg !20
+  call void @llvm.dbg.assign(metadata i32 %a, metadata !16, metadata !DIExpression(), metadata !21, metadata ptr %a.addr, metadata !DIExpression()), !dbg !20
+  %tobool.not = icmp eq i32 %c, 0
+  br i1 %tobool.not, label %if.then, label %if.end
+
+if.then:
+  call void @e()
+  call void @llvm.dbg.assign(metadata i32 0, metadata !16, metadata !DIExpression(), metadata !22, metadata ptr %a.addr, metadata !DIExpression()), !dbg !20
+  br label %if.end
+
+if.end:                                           ; preds = %do.body
+  store i32 0, ptr %a.addr, align 4, !DIAssignID !22
+  call void @es(ptr %a.addr)
+  ret i32 0
+}
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
+declare void @e()
+declare void @es(ptr)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "test.cpp", directory: "/")
+!4 = !{!0}
+!5 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64)
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 7, !"Dwarf Version", i32 5}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{i32 7, !"uwtable", i32 1}
+!11 = !{!"clang version 14.0.0"}
+!12 = distinct !DISubprogram(name: "f", linkageName: "_Z1fiii", scope: !3, file: !3, line: 5, type: !13, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!6, !6, !6, !6}
+!15 = !{!16, !17, !18}
+!16 = !DILocalVariable(name: "a", arg: 1, scope: !12, file: !3, line: 5, type: !6)
+!17 = !DILocalVariable(name: "b", arg: 2, scope: !12, file: !3, line: 5, type: !6)
+!18 = !DILocalVariable(name: "c", arg: 3, scope: !12, file: !3, line: 5, type: !6)
+!19 = distinct !DIAssignID()
+!20 = !DILocation(line: 0, scope: !12)
+!21 = distinct !DIAssignID()
+!22 = distinct !DIAssignID()
+!23 = distinct !DIAssignID()
+!28 = distinct !DIAssignID()
+!29 = !DILocation(line: 6, column: 3, scope: !12)
+!30 = !DILocation(line: 8, column: 7, scope: !31)
+!31 = distinct !DILexicalBlock(scope: !12, file: !3, line: 6, column: 6)
+!32 = distinct !DIAssignID()
+!33 = !DILocation(line: 10, column: 5, scope: !31)
+!34 = !DILocation(line: 11, column: 12, scope: !12)
+!35 = !DILocation(line: 11, column: 3, scope: !31)
+!36 = distinct !{!36, !29, !37, !38}
+!37 = !DILocation(line: 11, column: 15, scope: !12)
+!38 = !{!"llvm.loop.mustprogress"}
+!39 = !DILocation(line: 12, column: 3, scope: !12)
+!40 = !DILocation(line: 13, column: 10, scope: !12)
+!41 = !DILocation(line: 13, column: 12, scope: !12)
+!42 = !DILocation(line: 13, column: 3, scope: !12)
+!43 = !DISubprogram(name: "e", linkageName: "_Z1ev", scope: !3, file: !3, line: 2, type: !44, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
+!44 = !DISubroutineType(types: !45)
+!45 = !{null}
+!46 = !{}
+!47 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !3, file: !3, line: 1, type: !48, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
+!48 = !DISubroutineType(types: !49)
+!49 = !{!6}
+!50 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !3, file: !3, line: 3, type: !51, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
+!51 = !DISubroutineType(types: !52)
+!52 = !{null, !5}

llvm/test/DebugInfo/assignment-tracking/X86/lit.local.cfg

+if not 'X86' in config.root.targets:
+    config.unsupported = True

llvm/test/DebugInfo/assignment-tracking/X86/loop-hoist.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+
+;; $ cat test.cpp
+;; int d();
+;; void e();
+;; void es(int*);
+;; int *g;
+;; int f(int a, int b, int c) {
+;;   do {
+;;     /* stuff */
+;;     c *= c;
+;;     a = b;
+;;     e();
+;;   } while (d());
+;;   es(&a);
+;;   return a + c;
+;; }
+
+;; The variable of interest is `a`, which has a store that is hoisted out of the
+;; loop into the entry BB. Check the memory location is not used after the
+;; hoisted store until the assignment position within the loop.
+
+; CHECK-DAG: ![[A:[0-9]+]] = !DILocalVariable(name: "a",
+
+; CHECK: bb.0.entry:
+; CHECK:      DBG_VALUE $edi, $noreg, ![[A]], !DIExpression()
+
+; CHECK: bb.1.do.body:
+; CHECK: DBG_VALUE %stack.0.a.addr, $noreg, ![[A]], !DIExpression(DW_OP_deref)
+
+target triple = "x86_64-unknown-linux-gnu"
+
+@g = dso_local local_unnamed_addr global ptr null, align 8, !dbg !0
+
+define dso_local noundef i32 @_Z1fiii(i32 noundef %a, i32 noundef %b, i32 noundef %c) local_unnamed_addr #0 !dbg !12 {
+entry:
+  %a.addr = alloca i32, align 4, !DIAssignID !19
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !16, metadata !DIExpression(), metadata !19, metadata ptr %a.addr, metadata !DIExpression()), !dbg !20
+  call void @llvm.dbg.assign(metadata i32 %a, metadata !16, metadata !DIExpression(), metadata !21, metadata ptr %a.addr, metadata !DIExpression()), !dbg !20
+  store i32 %b, ptr %a.addr, align 4, !DIAssignID !28
+  br label %do.body, !dbg !29
+
+do.body:                                          ; preds = %do.body, %entry
+  %c.addr.0 = phi i32 [ %c, %entry ], [ %mul, %do.body ]
+  %mul = mul nsw i32 %c.addr.0, %c.addr.0, !dbg !30
+  call void @llvm.dbg.assign(metadata i32 %b, metadata !16, metadata !DIExpression(), metadata !28, metadata ptr %a.addr, metadata !DIExpression()), !dbg !20
+  tail call void @_Z1ev(), !dbg !33
+  %call = tail call noundef i32 @_Z1dv(), !dbg !34
+  %tobool.not = icmp eq i32 %call, 0, !dbg !34
+  br i1 %tobool.not, label %do.end, label %do.body, !dbg !35, !llvm.loop !36
+
+do.end:                                           ; preds = %do.body
+  call void @_Z2esPi(ptr noundef nonnull %a.addr), !dbg !39
+  %0 = load i32, ptr %a.addr, align 4, !dbg !40
+  %add = add nsw i32 %0, %mul, !dbg !41
+  ret i32 %add, !dbg !42
+}
+
+declare !dbg !43 dso_local void @_Z1ev() local_unnamed_addr #1
+declare !dbg !47 dso_local noundef i32 @_Z1dv() local_unnamed_addr #1
+declare !dbg !50 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
+declare void @llvm.dbg.value(metadata, metadata, metadata) #3
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "test.cpp", directory: "/")
+!4 = !{!0}
+!5 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64)
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 7, !"Dwarf Version", i32 5}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{i32 7, !"uwtable", i32 1}
+!11 = !{!"clang version 14.0.0"}
+!12 = distinct !DISubprogram(name: "f", linkageName: "_Z1fiii", scope: !3, file: !3, line: 5, type: !13, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!6, !6, !6, !6}
+!15 = !{!16, !17, !18}
+!16 = !DILocalVariable(name: "a", arg: 1, scope: !12, file: !3, line: 5, type: !6)
+!17 = !DILocalVariable(name: "b", arg: 2, scope: !12, file: !3, line: 5, type: !6)
+!18 = !DILocalVariable(name: "c", arg: 3, scope: !12, file: !3, line: 5, type: !6)
+!19 = distinct !DIAssignID()
+!20 = !DILocation(line: 0, scope: !12)
+!21 = distinct !DIAssignID()
+!22 = distinct !DIAssignID()
+!23 = distinct !DIAssignID()
+!28 = distinct !DIAssignID()
+!29 = !DILocation(line: 6, column: 3, scope: !12)
+!30 = !DILocation(line: 8, column: 7, scope: !31)
+!31 = distinct !DILexicalBlock(scope: !12, file: !3, line: 6, column: 6)
+!32 = distinct !DIAssignID()
+!33 = !DILocation(line: 10, column: 5, scope: !31)
+!34 = !DILocation(line: 11, column: 12, scope: !12)
+!35 = !DILocation(line: 11, column: 3, scope: !31)
+!36 = distinct !{!36, !29, !37, !38}
+!37 = !DILocation(line: 11, column: 15, scope: !12)
+!38 = !{!"llvm.loop.mustprogress"}
+!39 = !DILocation(line: 12, column: 3, scope: !12)
+!40 = !DILocation(line: 13, column: 10, scope: !12)
+!41 = !DILocation(line: 13, column: 12, scope: !12)
+!42 = !DILocation(line: 13, column: 3, scope: !12)
+!43 = !DISubprogram(name: "e", linkageName: "_Z1ev", scope: !3, file: !3, line: 2, type: !44, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
+!44 = !DISubroutineType(types: !45)
+!45 = !{null}
+!46 = !{}
+!47 = !DISubprogram(name: "d", linkageName: "_Z1dv", scope: !3, file: !3, line: 1, type: !48, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
+!48 = !DISubroutineType(types: !49)
+!49 = !{!6}
+!50 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !3, file: !3, line: 3, type: !51, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !46)
+!51 = !DISubroutineType(types: !52)
+!52 = !{null, !5}

llvm/test/DebugInfo/assignment-tracking/X86/loop-sink.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s --implicit-check-not=DBG
+
+;; Tiny loop with a store sunk out of it:
+;; void e();
+;; void es(int*);
+;; int *g;
+;; int getInt();
+;; int f(int a, int b) {
+;;   int z = getInt();
+;;   while (g) {
+;;     e();
+;;     a = z;
+;;   }
+;;   es(&a);
+;;   return a;
+;; }
+;;
+;; Store to `a` has been sunk out the loop - there's a dbg.assign left in the
+;; loop that is linked the store that is now outside it. Check that the memory
+;; location is not used inside the loop and is reinstated after the sunk store.
+
+; CHECK-DAG: ![[A:[0-9]+]] = !DILocalVariable(name: "a",
+
+; CHECK-LABEL: bb.0.entry:
+; CHECK: DBG_VALUE $edi, $noreg, ![[A]], !DIExpression()
+; CHECK: CALL64pcrel32 @getInt{{.*}}debug-instr-number 1
+
+; CHECK-LABEL: bb.2.while.body:
+; CHECK: DBG_INSTR_REF 1, 6, ![[A]], !DIExpression()
+
+; CHECK-LABEL: bb.3.while.end:
+; CHECK: MOV32mr %stack.0.a.addr, 1, $noreg, 0, $noreg, %1
+; CHECK-NEXT: DBG_VALUE %stack.0.a.addr, $noreg, ![[A]], !DIExpression(DW_OP_deref)
+
+target triple = "x86_64-unknown-linux-gnu"
+
+@g = dso_local local_unnamed_addr global ptr null, align 8, !dbg !0
+
+; Function Attrs: mustprogress uwtable
+define dso_local noundef i32 @_Z1fii(i32 noundef %a, i32 noundef %b) local_unnamed_addr #0 !dbg !12 {
+entry:
+  %a.addr = alloca i32, align 4, !DIAssignID !18
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !16, metadata !DIExpression(), metadata !18, metadata ptr %a.addr, metadata !DIExpression()), !dbg !19
+  call void @llvm.dbg.assign(metadata i32 %a, metadata !16, metadata !DIExpression(), metadata !20, metadata ptr %a.addr, metadata !DIExpression()), !dbg !19
+  %z = call i32 @getInt()
+  %0 = load ptr, ptr @g, align 8, !dbg !22
+  %tobool.not1 = icmp eq ptr %0, null, !dbg !22
+  br i1 %tobool.not1, label %while.end, label %while.body, !dbg !27
+
+while.body:                                       ; preds = %entry, %while.body
+  tail call void @_Z1ev(), !dbg !28
+  call void @llvm.dbg.assign(metadata i32 %z, metadata !16, metadata !DIExpression(), metadata !20, metadata ptr %a.addr, metadata !DIExpression()), !dbg !19
+  %1 = load ptr, ptr @g, align 8, !dbg !22
+  %tobool.not = icmp eq ptr %1, null, !dbg !22
+  br i1 %tobool.not, label %while.end, label %while.body, !dbg !27, !llvm.loop !30
+
+while.end:                                        ; preds = %while.body, %entry
+  %storemerge.lcssa = phi i32 [ %a, %entry ], [ %b, %while.body ]
+  store i32 %storemerge.lcssa, ptr %a.addr, align 4, !DIAssignID !20
+  call void @_Z2esPi(ptr noundef nonnull %a.addr), !dbg !35
+  %2 = load i32, ptr %a.addr, align 4, !dbg !36
+  %r = add i32 %2, %z
+  ret i32 %r, !dbg !37
+}
+
+declare !dbg !38 dso_local void @_Z1ev() local_unnamed_addr #1
+declare !dbg !42 dso_local void @_Z2esPi(ptr noundef) local_unnamed_addr #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
+declare dso_local i32 @getInt()
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "test.cpp", directory: "/")
+!4 = !{!0}
+!5 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64)
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 7, !"Dwarf Version", i32 5}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{i32 7, !"uwtable", i32 1}
+!11 = !{!"clang version 14.0.0"}
+!12 = distinct !DISubprogram(name: "f", linkageName: "_Z1fii", scope: !3, file: !3, line: 5, type: !13, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!6, !6, !6}
+!15 = !{!16, !17}
+!16 = !DILocalVariable(name: "a", arg: 1, scope: !12, file: !3, line: 5, type: !6)
+!17 = !DILocalVariable(name: "b", arg: 2, scope: !12, file: !3, line: 5, type: !6)
+!18 = distinct !DIAssignID()
+!19 = !DILocation(line: 0, scope: !12)
+!20 = distinct !DIAssignID()
+!21 = distinct !DIAssignID()
+!22 = !DILocation(line: 6, column: 10, scope: !12)
+!27 = !DILocation(line: 6, column: 3, scope: !12)
+!28 = !DILocation(line: 7, column: 5, scope: !29)
+!29 = distinct !DILexicalBlock(scope: !12, file: !3, line: 6, column: 13)
+!30 = distinct !{!30, !27, !31, !32}
+!31 = !DILocation(line: 9, column: 3, scope: !12)
+!32 = !{!"llvm.loop.mustprogress"}
+!35 = !DILocation(line: 10, column: 3, scope: !12)
+!36 = !DILocation(line: 11, column: 10, scope: !12)
+!37 = !DILocation(line: 11, column: 3, scope: !12)
+!38 = !DISubprogram(name: "e", linkageName: "_Z1ev", scope: !3, file: !3, line: 2, type: !39, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !41)
+!39 = !DISubroutineType(types: !40)
+!40 = !{null}
+!41 = !{}
+!42 = !DISubprogram(name: "es", linkageName: "_Z2esPi", scope: !3, file: !3, line: 3, type: !43, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !41)
+!43 = !DISubroutineType(types: !44)
+!44 = !{null, !5}

llvm/test/DebugInfo/assignment-tracking/X86/loop-unroll.ll

+; RUN: llc %s -stop-after=finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN: | FileCheck %s
+;;
+;; Backend counterpart to ../Generic/dbg-assign-loop-unroll.  This IR was
+;; generated by running `opt -loop-unroll -S` on the IR in that test.
+;;
+;; Check that the backend can handle a mesh of dbg.assign and linked
+;; instructions.
+;;
+;; Generated from the following source:
+;; void esc(int*);
+;; void d(int p) {
+;;   for (int i = 0; i < 2; ++i) {
+;;     p = i;
+;;     esc(&p);
+;;   }
+;; }
+
+; CHECK: ![[p:[0-9]+]] = !DILocalVariable(name: "p",
+
+; CHECK: stack:
+; CHECK-NEXT: - { id: 0, name: p.addr, type: default, offset: 0, size: 4, alignment: 4,
+; CHECK-NEXT:     stack-id: default, callee-saved-register: '', callee-saved-restored: true,
+; CHECK-NEXT:     debug-info-variable: '![[p]]', debug-info-expression: '!DIExpression()',
+; CHECK-NEXT:     debug-info-location: '!{{.+}}' }
+
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local void @_Z1di(i32 %p) local_unnamed_addr !dbg !7 {
+entry:
+  %p.addr = alloca i32, align 4
+  store i32 %p, ptr %p.addr, align 4, !DIAssignID !19
+  call void @llvm.dbg.assign(metadata i32 %p, metadata !12, metadata !DIExpression(), metadata !19, metadata ptr %p.addr, metadata !DIExpression()), !dbg !20
+  call void @llvm.dbg.assign(metadata i32 0, metadata !13, metadata !DIExpression(), metadata !21, metadata ptr undef, metadata !DIExpression()), !dbg !22
+  br label %for.body, !dbg !23
+
+for.body:                                         ; preds = %entry
+  store i32 0, ptr %p.addr, align 4, !dbg !24, !DIAssignID !27
+  call void @llvm.dbg.assign(metadata i32 0, metadata !12, metadata !DIExpression(), metadata !27, metadata ptr %p.addr, metadata !DIExpression()), !dbg !24
+  call void @_Z3escPi(ptr nonnull %p.addr), !dbg !28
+  call void @llvm.dbg.assign(metadata i32 1, metadata !13, metadata !DIExpression(), metadata !29, metadata ptr undef, metadata !DIExpression()), !dbg !30
+  store i32 1, ptr %p.addr, align 4, !dbg !24, !DIAssignID !27
+  call void @llvm.dbg.assign(metadata i32 1, metadata !12, metadata !DIExpression(), metadata !27, metadata ptr %p.addr, metadata !DIExpression()), !dbg !24
+  call void @_Z3escPi(ptr nonnull %p.addr), !dbg !28
+  call void @llvm.dbg.assign(metadata i32 2, metadata !13, metadata !DIExpression(), metadata !29, metadata ptr undef, metadata !DIExpression()), !dbg !30
+  ret void, !dbg !31
+}
+
+declare !dbg !32 dso_local void @_Z3escPi(ptr) local_unnamed_addr
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "d", linkageName: "_Z1di", scope: !1, file: !1, line: 2, type: !8, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12, !13}
+!12 = !DILocalVariable(name: "p", arg: 1, scope: !7, file: !1, line: 2, type: !10)
+!13 = !DILocalVariable(name: "i", scope: !14, file: !1, line: 3, type: !10)
+!14 = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 3)
+!19 = distinct !DIAssignID()
+!20 = !DILocation(line: 0, scope: !7)
+!21 = distinct !DIAssignID()
+!22 = !DILocation(line: 3, column: 12, scope: !14)
+!23 = !DILocation(line: 3, column: 3, scope: !14)
+!24 = !DILocation(line: 4, column: 7, scope: !25)
+!25 = distinct !DILexicalBlock(scope: !26, file: !1, line: 3, column: 31)
+!26 = distinct !DILexicalBlock(scope: !14, file: !1, line: 3, column: 3)
+!27 = distinct !DIAssignID()
+!28 = !DILocation(line: 5, column: 5, scope: !25)
+!29 = distinct !DIAssignID()
+!30 = !DILocation(line: 3, column: 26, scope: !26)
+!31 = !DILocation(line: 7, column: 1, scope: !7)
+!32 = !DISubprogram(name: "esc", linkageName: "_Z3escPi", scope: !1, file: !1, line: 1, type: !33, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!33 = !DISubroutineType(types: !34)
+!34 = !{null, !35}
+!35 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)

llvm/test/DebugInfo/assignment-tracking/X86/lower-offset-expression.ll

+; RUN: llc %s -stop-after=finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking  \
+; RUN: | FileCheck %s
+
+;; Handwritten test.
+
+;; Here we have dbg.assign intrinsics with fragments (in the value-expression)
+;; and address-expressions that involve arithmetic. The generated DBG_VALUE
+;; intructions needs a DIExpression that:
+;;     a) Uses the fragment from the value-expression,
+;;     b) Uses the offset expression of the address-expression,
+;;     c) Has a DW_OP_deref appended.
+
+; CHECK: DBG_VALUE %stack.0.a, $noreg, {{.+}}, !DIExpression(DW_OP_plus_uconst, 8, DW_OP_deref, DW_OP_LLVM_fragment, 64, 32), debug-location
+
+define dso_local void @fun() !dbg !7 {
+entry:
+  %a = alloca <4 x i32>, !DIAssignID !24
+  call void @llvm.dbg.assign(metadata i32 undef, metadata !16, metadata !DIExpression(), metadata !24, metadata ptr %a, metadata !DIExpression()), !dbg !34
+  ;; unlink and undef a dbg.assign to avoid using sidetable for var loc.
+  call void @llvm.dbg.assign(metadata i32 undef, metadata !16, metadata !DIExpression(), metadata !26, metadata ptr undef, metadata !DIExpression()), !dbg !34
+  %idx2 = getelementptr inbounds i32, i32* %a, i32 2
+  store i32 100, i32* %idx2, !DIAssignID !25
+  call void @llvm.dbg.assign(metadata i32 100, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !25, metadata i32* %a, metadata !DIExpression(DW_OP_plus_uconst, 8)), !dbg !34
+  ret void
+}
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "fun", linkageName: "fun", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10, !10, !10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!16}
+!16 = !DILocalVariable(name: "quad", scope: !7, file: !1, line: 4, type: !17)
+!17 = !DICompositeType(tag: DW_TAG_array_type, baseType: !10, size: 128, elements: !18)
+!18 = !{!19}
+!19 = !DISubrange(count: 4)
+!23 = !DILocation(line: 0, scope: !7)
+!24 = distinct !DIAssignID()
+!25 = distinct !DIAssignID()
+!26 = distinct !DIAssignID()
+!34 = !DILocation(line: 0, column: 0, scope: !7)
+!44 = !{!45, !45, i64 0}
+!45 = !{!"float", !46, i64 0}
+!46 = !{!"omnipotent char", !47, i64 0}
+!47 = !{!"Simple C++ TBAA"}
+!48 = !DILocation(line: 11, column: 3, scope: !7)
+!49 = !DILocation(line: 12, column: 1, scope: !7)
+!50 = !DISubprogram(name: "get", linkageName: "_Z3getv", scope: !1, file: !1, line: 1, type: !51, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!51 = !DISubroutineType(types: !52)
+!52 = !{!10}
+!53 = !DISubprogram(name: "ext", linkageName: "_Z3extPf", scope: !1, file: !1, line: 2, type: !54, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!54 = !DISubroutineType(types: !55)
+!55 = !{!10, !56}
+!56 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+

llvm/test/DebugInfo/assignment-tracking/X86/lower-to-value.ll

+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -experimental-debug-variable-locations=false \
+; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE --implicit-check-not=DBG_VALUE
+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -experimental-debug-variable-locations=true \
+; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF --implicit-check-not=DBG_VALUE \
+; RUN:    --implicit-check-not=DBG_INSTR_REF
+
+;; Check that dbg.assigns for an aggregate variable which lives on the stack
+;; for some of its lifetime are lowered into an appropriate set of DBG_VALUEs.
+;;
+;; $ cat test.cpp
+;; void esc(long* p);
+;; struct Ex {
+;;   long A;
+;;   long B;
+;; };
+;; long fun() {
+;;   Ex X;
+;;   X.B = 0;
+;;   esc(&X.B);
+;;   X.B += 2;
+;;   return X.B;
+;; }
+;; $ clang++ test.cpp -O2 -g -emit-llvm -S -c -Xclang -fexperimental-assignment-tracking
+
+; CHECK: ![[VAR:[0-9]+]] = !DILocalVariable(name: "X",
+;; Check we have no debug info for local in the side table.
+; CHECK: stack:
+; CHECK-NEXT: - { id: 0, name: X, type: default, offset: 0, size: 16, alignment: 8,
+; CHECK-NEXT:     stack-id: default, callee-saved-register: '', callee-saved-restored: true,
+; CHECK-NEXT:     debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+
+;; Initially the whole variable is on the stack.
+; CHECK: bb.0.entry:
+; CHECK-NEXT: DBG_VALUE %stack.0.X, $noreg, ![[VAR]], !DIExpression(DW_OP_deref), debug-location
+
+;; Then there is a store to the upper 64 bits.
+; CHECK: MOV64mi32 %stack.0.X, 1, $noreg, 8, $noreg, 0, debug-location
+;; This DBG_VALUE is added by the mem-loc-frag-fill pass because bits [0, 64)
+;; are still live in memory.
+; CHECK-NEXT: DBG_VALUE %stack.0.X, $noreg, ![[VAR]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 64)
+; CHECK-NEXT: DBG_VALUE %stack.0.X, $noreg, ![[VAR]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_deref, DW_OP_LLVM_fragment, 64, 64), debug-location
+
+;; The final assignment (X.B += 2) doesn't get stored back to the alloca. This
+;; means that that the stack location isn't valid for the entire lifetime of X.
+; DBGVALUE: %2:gr64 = nsw ADD64ri8 %1, 2, implicit-def dead $eflags, debug-location
+; DBGVALUE-NEXT: DBG_VALUE %2, $noreg, ![[VAR]], !DIExpression(DW_OP_LLVM_fragment, 64, 64), debug-location
+; INSTRREF: %2:gr64 = nsw ADD64ri8 %1, 2, implicit-def dead $eflags, debug-instr-number 1
+; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[VAR]], !DIExpression(DW_OP_LLVM_fragment, 64, 64), debug-location
+
+source_filename = "test.cpp"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.Ex = type { i64, i64 }
+
+define dso_local i64 @_Z3funv() local_unnamed_addr !dbg !7 {
+entry:
+  %X = alloca %struct.Ex, align 8, !DIAssignID !17
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !12, metadata !DIExpression(), metadata !17, metadata ptr %X, metadata !DIExpression()), !dbg !18
+  %B = getelementptr inbounds %struct.Ex, ptr %X, i64 0, i32 1, !dbg !20
+  store i64 0, ptr %B, align 8, !dbg !21, !DIAssignID !27
+  call void @llvm.dbg.assign(metadata i64 0, metadata !12, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64), metadata !27, metadata ptr %B, metadata !DIExpression()), !dbg !21
+  call void @_Z3escPl(ptr nonnull %B), !dbg !28
+  %0 = load i64, ptr %B, align 8, !dbg !29
+  %add = add nsw i64 %0, 2, !dbg !29
+  call void @llvm.dbg.assign(metadata i64 %add, metadata !12, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64), metadata !30, metadata ptr %B, metadata !DIExpression()), !dbg !29
+  ret i64 %add, !dbg !32
+}
+
+declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
+declare !dbg !33 dso_local void @_Z3escPl(ptr) local_unnamed_addr
+declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "fun", linkageName: "_Z3funv", scope: !1, file: !1, line: 6, type: !8, scopeLine: 6, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "long int", size: 64, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "X", scope: !7, file: !1, line: 7, type: !13)
+!13 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Ex", file: !1, line: 2, size: 128, flags: DIFlagTypePassByValue, elements: !14, identifier: "_ZTS2Ex")
+!14 = !{!15, !16}
+!15 = !DIDerivedType(tag: DW_TAG_member, name: "A", scope: !13, file: !1, line: 3, baseType: !10, size: 64)
+!16 = !DIDerivedType(tag: DW_TAG_member, name: "B", scope: !13, file: !1, line: 4, baseType: !10, size: 64, offset: 64)
+!17 = distinct !DIAssignID()
+!18 = !DILocation(line: 0, scope: !7)
+!19 = !DILocation(line: 7, column: 3, scope: !7)
+!20 = !DILocation(line: 8, column: 5, scope: !7)
+!21 = !DILocation(line: 8, column: 7, scope: !7)
+!27 = distinct !DIAssignID()
+!28 = !DILocation(line: 9, column: 3, scope: !7)
+!29 = !DILocation(line: 10, column: 7, scope: !7)
+!30 = distinct !DIAssignID()
+!31 = !DILocation(line: 12, column: 1, scope: !7)
+!32 = !DILocation(line: 11, column: 3, scope: !7)
+!33 = !DISubprogram(name: "esc", linkageName: "_Z3escPl", scope: !1, file: !1, line: 1, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!34 = !DISubroutineType(types: !35)
+!35 = !{null, !36}
+!36 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)

llvm/test/DebugInfo/assignment-tracking/X86/mem-loc-frag-fill-cfg.ll

+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN:    -experimental-debug-variable-locations=false \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN:    -experimental-debug-variable-locations=true \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+
+;; Check that the mem-loc-frag-fill pseudo-pass works on a simple CFG. When
+;; LLVM sees a dbg.value with an overlapping fragment it essentially considers
+;; the previous location as valid for all bits in that fragment. The pass
+;; inserts dbg.value fragments to preserve memory locations for bits in memory
+;; when overlapping fragments are encountered.
+
+;; nums lives in mem, except prior to the second call to step() where there has
+;; been some DSE. At this point, the memory loc for nums.c is invalid.  But the
+;; rest of num's bits, [0, 64), are in memory, so check there's a dbg.value for
+;; them.
+
+;; $ cat test.cpp
+;; struct Nums { int a, b, c; };
+;;
+;; void esc1(struct Nums*);
+;; void esc2(struct Nums*);
+;; bool step();
+;;
+;; int main() {
+;;   struct Nums nums = { 1, 2, 1 };
+;;   if (step())
+;;     esc1(&nums);
+;;   else
+;;     esc2(&nums);
+;;
+;;   nums.c = 2; //< Include some DSE to force a non-mem location.
+;;   step();
+;;
+;;   nums.c = nums.a;
+;;
+;;   esc1(&nums);
+;;   return 0;
+;; }
+;;
+;; $ clang++ test.cpp -O2 -g -Xclang -fexperimental-assignment-tracking -emit-llvm -S -o -
+
+;; Most check lines are inline in main.
+; CHECK: ![[nums:[0-9]+]] = !DILocalVariable(name: "nums",
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.Nums = type { i32, i32, i32 }
+
+@__const.main.nums = private unnamed_addr constant %struct.Nums { i32 1, i32 2, i32 1 }, align 4
+
+declare void @_Z4esc1P4Nums(ptr nocapture noundef readonly %p)
+declare void @_Z4esc2P4Nums(ptr nocapture noundef readonly %p)
+
+; Function Attrs: mustprogress norecurse uwtable
+define dso_local noundef i32 @main() local_unnamed_addr #3 !dbg !40 {
+; CHECK: name: main
+entry:
+  %nums = alloca %struct.Nums, align 4, !DIAssignID !45
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !44, metadata !DIExpression(), metadata !45, metadata ptr %nums, metadata !DIExpression()), !dbg !46
+; CHECK: DBG_VALUE %stack.0.nums, $noreg, ![[nums]], !DIExpression(DW_OP_deref)
+  call void @llvm.memcpy.p0i8.p0i8.i64(ptr noundef nonnull align 4 dereferenceable(12) %nums, ptr noundef nonnull align 4 dereferenceable(12) %nums, i64 12, i1 false), !dbg !48, !DIAssignID !49
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !44, metadata !DIExpression(), metadata !49, metadata ptr %nums, metadata !DIExpression()), !dbg !46
+  %call = tail call noundef zeroext i1 @_Z4stepv(), !dbg !50
+  br i1 %call, label %if.then, label %if.else, !dbg !52
+
+if.then:                                          ; preds = %entry
+  call void @_Z4esc1P4Nums(ptr noundef nonnull %nums), !dbg !53
+  br label %if.end, !dbg !53
+
+if.else:                                          ; preds = %entry
+  call void @_Z4esc2P4Nums(ptr noundef nonnull %nums), !dbg !54
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+; CHECK: bb.3.if.end:
+; CHECK-NEXT: DBG_VALUE 2, $noreg, ![[nums]], !DIExpression(DW_OP_LLVM_fragment, 64, 32), debug-location
+; CHECK-NEXT: DBG_VALUE %stack.0.nums, $noreg, ![[nums]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 64)
+  %c = getelementptr inbounds %struct.Nums, ptr %nums, i64 0, i32 2, !dbg !55
+  call void @llvm.dbg.assign(metadata i32 2, metadata !44, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !56, metadata ptr %c, metadata !DIExpression()), !dbg !46
+  %call1 = tail call noundef zeroext i1 @_Z4stepv(), !dbg !57
+  store i32 1, ptr %c, align 4, !dbg !58, !DIAssignID !61
+; CHECK:      MOV32mi %stack.0.nums, 1, $noreg, 8, $noreg, 1
+; CHECK-NEXT: DBG_VALUE %stack.0.nums, $noreg, ![[nums]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_deref, DW_OP_LLVM_fragment, 64, 32)
+  call void @llvm.dbg.assign(metadata i32 1, metadata !44, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !61, metadata ptr %c, metadata !DIExpression()), !dbg !46
+  call void @_Z4esc1P4Nums(ptr noundef nonnull %nums), !dbg !62
+  ret i32 0, !dbg !64
+}
+
+declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #4
+declare !dbg !65 dso_local noundef zeroext i1 @_Z4stepv() local_unnamed_addr #5
+declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #4
+declare void @llvm.memcpy.p0i8.p0i8.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!11, !12, !13, !14}
+!llvm.ident = !{!15}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "glob", scope: !2, file: !3, line: 2, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "test.cpp", directory: "/")
+!4 = !{!0}
+!5 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Nums", file: !3, line: 1, size: 96, flags: DIFlagTypePassByValue, elements: !6, identifier: "_ZTS4Nums")
+!6 = !{!7, !9, !10}
+!7 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !5, file: !3, line: 1, baseType: !8, size: 32)
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !5, file: !3, line: 1, baseType: !8, size: 32, offset: 32)
+!10 = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: !5, file: !3, line: 1, baseType: !8, size: 32, offset: 64)
+!11 = !{i32 7, !"Dwarf Version", i32 5}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{i32 1, !"wchar_size", i32 4}
+!14 = !{i32 7, !"uwtable", i32 1}
+!15 = !{!"clang version 14.0.0"}
+!40 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 7, type: !41, scopeLine: 7, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !43)
+!41 = !DISubroutineType(types: !42)
+!42 = !{!8}
+!43 = !{!44}
+!44 = !DILocalVariable(name: "nums", scope: !40, file: !3, line: 8, type: !5)
+!45 = distinct !DIAssignID()
+!46 = !DILocation(line: 0, scope: !40)
+!47 = !DILocation(line: 8, column: 3, scope: !40)
+!48 = !DILocation(line: 8, column: 15, scope: !40)
+!49 = distinct !DIAssignID()
+!50 = !DILocation(line: 9, column: 7, scope: !51)
+!51 = distinct !DILexicalBlock(scope: !40, file: !3, line: 9, column: 7)
+!52 = !DILocation(line: 9, column: 7, scope: !40)
+!53 = !DILocation(line: 10, column: 5, scope: !51)
+!54 = !DILocation(line: 12, column: 5, scope: !51)
+!55 = !DILocation(line: 14, column: 8, scope: !40)
+!56 = distinct !DIAssignID()
+!57 = !DILocation(line: 15, column: 3, scope: !40)
+!58 = !DILocation(line: 17, column: 10, scope: !40)
+!61 = distinct !DIAssignID()
+!62 = !DILocation(line: 19, column: 3, scope: !40)
+!63 = !DILocation(line: 21, column: 1, scope: !40)
+!64 = !DILocation(line: 20, column: 3, scope: !40)
+!65 = !DISubprogram(name: "step", linkageName: "_Z4stepv", scope: !3, file: !3, line: 5, type: !66, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !69)
+!66 = !DISubroutineType(types: !67)
+!67 = !{!68}
+!68 = !DIBasicType(name: "bool", size: 8, encoding: DW_ATE_boolean)
+!69 = !{}

llvm/test/DebugInfo/assignment-tracking/X86/mem-loc-frag-fill.ll

+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN:    -experimental-debug-variable-locations=false \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN:    -experimental-debug-variable-locations=true \
+; RUN: | FileCheck %s  --implicit-check-not=DBG_
+
+;; Check that the mem-loc-frag-fill analysis works on a simple case; ensure
+;; that location definitions are added to preserve memory locations of
+;; fragments of variables at subsequent location definitions for other
+;; fragments of the variable are not currently in memory.
+
+;; Test generated from:
+;; $ cat test.cpp
+;; struct Nums { int a, b, c; };
+;; void esc(struct Nums*);
+;; void step();
+;; int main() {
+;;   struct Nums nums = { 1, 2, 1 }; //< Store to .c is elided.
+;;   step();
+;;   nums.c = 2; //< Killing store.
+;;   step();
+;;   esc(&nums);
+;;   return 0;
+;; }
+;; $ clang++ test.cpp -O2 -g -Xclang -fexperimental-assignmment-tracking -emit-llvm -S -o -
+
+;; Most check lines are inline in main.
+; CHECK: ![[nums:[0-9]+]] = !DILocalVariable(name: "nums",
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.Nums = type { i32, i32, i32 }
+
+; Function Attrs: mustprogress norecurse uwtable
+define dso_local noundef i32 @main() local_unnamed_addr #0 !dbg !7 {
+entry:
+  %nums = alloca %struct.Nums, align 8, !DIAssignID !18
+; CHECK: DBG_VALUE %stack.0.nums, $noreg, ![[nums]], !DIExpression(DW_OP_deref)
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !12, metadata !DIExpression(), metadata !18, metadata ptr %nums, metadata !DIExpression()), !dbg !19
+  store i64 8589934593, ptr %nums, align 8, !dbg !21, !DIAssignID !22
+; CHECK: MOV64mr %stack.0.nums, 1, $noreg, 0, $noreg, killed %0
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !12, metadata !DIExpression(), metadata !22, metadata ptr %nums, metadata !DIExpression()), !dbg !19
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !12, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !22, metadata ptr undef, metadata !DIExpression()), !dbg !19
+; CHECK-NEXT: DBG_VALUE $noreg, $noreg, ![[nums]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 64, 32)
+; CHECK-NEXT: DBG_VALUE %stack.0.nums, $noreg, ![[nums]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 64)
+  tail call void @_Z4stepv(), !dbg !23
+  %c = getelementptr inbounds %struct.Nums, ptr %nums, i64 0, i32 2, !dbg !24
+  store i32 2, ptr %c, align 8, !dbg !25, !DIAssignID !31
+; CHECK: MOV32mi %stack.0.nums, 1, $noreg, 8, $noreg, 2
+  call void @llvm.dbg.assign(metadata i32 2, metadata !12, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !31, metadata ptr %c, metadata !DIExpression()), !dbg !19
+; CHECK-NEXT: DBG_VALUE %stack.0.nums, $noreg, ![[nums]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_deref, DW_OP_LLVM_fragment, 64, 32)
+  tail call void @_Z4stepv(), !dbg !32
+  call void @_Z3escP4Nums(ptr noundef nonnull %nums), !dbg !33
+  ret i32 0, !dbg !35
+}
+
+declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture) #1
+declare !dbg !36 dso_local void @_Z4stepv() local_unnamed_addr #2
+declare !dbg !40 dso_local void @_Z3escP4Nums(ptr noundef) local_unnamed_addr #2
+declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture) #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 1}
+!6 = !{!"clang version 14.0.0"}
+!7 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 4, type: !8, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "nums", scope: !7, file: !1, line: 5, type: !13)
+!13 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Nums", file: !1, line: 1, size: 96, flags: DIFlagTypePassByValue, elements: !14, identifier: "_ZTS4Nums")
+!14 = !{!15, !16, !17}
+!15 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !13, file: !1, line: 1, baseType: !10, size: 32)
+!16 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !13, file: !1, line: 1, baseType: !10, size: 32, offset: 32)
+!17 = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: !13, file: !1, line: 1, baseType: !10, size: 32, offset: 64)
+!18 = distinct !DIAssignID()
+!19 = !DILocation(line: 0, scope: !7)
+!20 = !DILocation(line: 5, column: 3, scope: !7)
+!21 = !DILocation(line: 5, column: 15, scope: !7)
+!22 = distinct !DIAssignID()
+!23 = !DILocation(line: 6, column: 3, scope: !7)
+!24 = !DILocation(line: 7, column: 8, scope: !7)
+!25 = !DILocation(line: 7, column: 10, scope: !7)
+!31 = distinct !DIAssignID()
+!32 = !DILocation(line: 8, column: 3, scope: !7)
+!33 = !DILocation(line: 9, column: 3, scope: !7)
+!34 = !DILocation(line: 11, column: 1, scope: !7)
+!35 = !DILocation(line: 10, column: 3, scope: !7)
+!36 = !DISubprogram(name: "step", linkageName: "_Z4stepv", scope: !1, file: !1, line: 3, type: !37, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !39)
+!37 = !DISubroutineType(types: !38)
+!38 = !{null}
+!39 = !{}
+!40 = !DISubprogram(name: "esc", linkageName: "_Z3escP4Nums", scope: !1, file: !1, line: 2, type: !41, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !39)
+!41 = !DISubroutineType(types: !42)
+!42 = !{null, !43}
+!43 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64)

llvm/test/DebugInfo/assignment-tracking/X86/no-redundant-def-after-alloca.ll

+; RUN: llc %s -o - -stop-after=finalize-isel \
+; RUN:    -experimental-assignment-tracking  \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+
+;; Hand written. Check that no unnecessary undef is inserted after an alloca
+;; that has a linked dbg.assign that doesn't immediately follow it.
+
+; CHECK: CALL64pcrel32 @a
+; CHECK-NEXT: ADJCALLSTACKUP64
+; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, !{{.+}}, !DIExpression(DW_OP_deref), debug-location
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local void @b() #0 !dbg !7 {
+entry:
+  %c = alloca i8, align 1, !DIAssignID !10
+  call void (...) @a(), !dbg !16
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(), metadata !10, metadata ptr %c, metadata !DIExpression()), !dbg !13
+  ret void, !dbg !17
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+declare dso_local void @a(...)
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, 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 12.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0)"}
+!7 = distinct !DISubprogram(name: "b", scope: !1, file: !1, line: 2, type: !8, scopeLine: 2, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = distinct !DIAssignID()
+!11 = !DILocalVariable(name: "c", scope: !7, file: !1, line: 3, type: !12)
+!12 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 3, column: 8, scope: !7)
+!15 = distinct !DIAssignID()
+!16 = !DILocation(line: 4, column: 3, scope: !7)
+!17 = !DILocation(line: 5, column: 1, scope: !7)

llvm/test/DebugInfo/assignment-tracking/X86/order-of-defs.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+
+;; Ensure that the order of several debug intrinsics between non-debug
+;; instructions is maintained.
+
+; CHECK-DAG: ![[A:[0-9]+]] = !DILocalVariable(name: "a",
+; CHECK-DAG: ![[B:[0-9]+]] = !DILocalVariable(name: "b",
+; CHECK-DAG: ![[C:[0-9]+]] = !DILocalVariable(name: "c",
+
+; CHECK:      DBG_VALUE $esi, $noreg, ![[B]], !DIExpression(), debug-location !20
+; CHECK-NEXT: DBG_VALUE $edx, $noreg, ![[C]], !DIExpression(), debug-location !20
+; CHECK-NEXT: DBG_VALUE $esi, $noreg, ![[A]], !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !20
+; CHECK-NEXT: DBG_VALUE $edx, $noreg, ![[A]], !DIExpression(DW_OP_LLVM_fragment, 32, 32), debug-location !20
+
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local i32 @fun(i64 %a.coerce, i32 noundef %b, i32 noundef %c) local_unnamed_addr #0 !dbg !7 {
+entry:
+  call void @llvm.dbg.assign(metadata i32 %b, metadata !17, metadata !DIExpression(), metadata !19, metadata ptr undef, metadata !DIExpression()), !dbg !20
+  call void @llvm.dbg.assign(metadata i32 %c, metadata !18, metadata !DIExpression(), metadata !21, metadata ptr undef, metadata !DIExpression()), !dbg !20
+  call void @llvm.dbg.assign(metadata i32 %b, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32), metadata !22, metadata ptr undef, metadata !DIExpression()), !dbg !20
+  call void @llvm.dbg.assign(metadata i32 %c, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32), metadata !23, metadata ptr undef, metadata !DIExpression()), !dbg !20
+  %mul = mul nsw i32 %c, %b, !dbg !24
+  ret i32 %mul, !dbg !25
+}
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 1}
+!6 = !{!"clang version 14.0.0"}
+!7 = distinct !DISubprogram(name: "fun", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !15)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !11, !10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !1, line: 2, size: 64, elements: !12)
+!12 = !{!13, !14}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !11, file: !1, line: 2, baseType: !10, size: 32)
+!14 = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: !11, file: !1, line: 2, baseType: !10, size: 32, offset: 32)
+!15 = !{!16, !17, !18}
+!16 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 3, type: !11)
+!17 = !DILocalVariable(name: "b", arg: 2, scope: !7, file: !1, line: 3, type: !10)
+!18 = !DILocalVariable(name: "c", arg: 3, scope: !7, file: !1, line: 3, type: !10)
+!19 = distinct !DIAssignID()
+!20 = !DILocation(line: 0, scope: !7)
+!21 = distinct !DIAssignID()
+!22 = distinct !DIAssignID()
+!23 = distinct !DIAssignID()
+!24 = !DILocation(line: 6, column: 14, scope: !7)
+!25 = !DILocation(line: 6, column: 3, scope: !7)

llvm/test/DebugInfo/assignment-tracking/X86/remove-redundant-defs-to-prevent-reordering.ll

+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN:    -experimental-debug-variable-locations=false \
+; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE --implicit-check-not="DBG_VALUE \$noreg"
+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN:    -experimental-debug-variable-locations=true \
+; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF --implicit-check-not="DBG_VALUE \$noreg"
+
+;; Found in the wild, but this test involves modifications from:
+;; int b;
+;; void ext();
+;; int fun(int a) {
+;;   if (b == 0)
+;;     ext();
+;;
+;;   a += b;
+;;   return a;
+;; }
+;; An `dbg.assign(undef, ...)` has been added by hand in if.end.
+
+;; For some variable we generate:
+;;     %inc = add nuw nsw i32 %i.0128, 1
+;;     call void @llvm.dbg.value(metadata i32 undef, ...
+;;     call void @llvm.dbg.value(metadata i32 %inc, ...
+;;
+;; SelectionDAG swaps the dbg.value positions:
+;;     %31:gr32 = nuw nsw ADD32ri8 %30:gr32(tied-def 0), 1
+;;     DBG_VALUE %31:gr32, ...
+;;     DBG_VALUE $noreg, ...
+;;
+;; Make sure to avoid this by removing redundant dbg.values after lowering
+;; dbg.assigns.
+
+;; Check that there's a debug instruction (--implicit-check-not checks no
+;; `DBG_VALUE $noreg, ...` has been added).
+; CHECK: bb.2.if.end:
+; DBGVALUE: DBG_VALUE
+; INSTRREF: INSTR_REF
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@b = dso_local local_unnamed_addr global i32 0, align 4, !dbg !0
+
+; Function Attrs: uwtable mustprogress
+define dso_local i32 @_Z3funi(i32 %a) local_unnamed_addr #0 !dbg !11 {
+entry:
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !15, metadata !DIExpression(), metadata !16, metadata ptr undef, metadata !DIExpression()), !dbg !17
+  call void @llvm.dbg.assign(metadata i32 %a, metadata !15, metadata !DIExpression(), metadata !18, metadata ptr undef, metadata !DIExpression()), !dbg !17
+  %0 = load i32, ptr @b, align 4, !dbg !19
+  %cmp = icmp eq i32 %0, 0, !dbg !25
+  br i1 %cmp, label %if.then, label %if.end, !dbg !26
+
+if.then:                                          ; preds = %entry
+  tail call void @_Z3extv(), !dbg !27
+  %.pre = load i32, ptr @b, align 4, !dbg !28
+  br label %if.end, !dbg !27
+
+if.end:                                           ; preds = %if.then, %entry
+  %1 = phi i32 [ %.pre, %if.then ], [ %0, %entry ], !dbg !28
+  %add = add nsw i32 %1, %a, !dbg !29
+  ;; Added by hand:
+  call void @llvm.dbg.assign(metadata i32 undef, metadata !15, metadata !DIExpression(), metadata !30, metadata ptr undef, metadata !DIExpression()), !dbg !17
+call void @llvm.dbg.assign(metadata i32 %add, metadata !15, metadata !DIExpression(), metadata !30, metadata ptr undef, metadata !DIExpression()), !dbg !17
+  ret i32 %add, !dbg !31
+}
+
+declare !dbg !32 dso_local void @_Z3extv() local_unnamed_addr #1
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #2
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9}
+!llvm.ident = !{!10}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "test.cpp", directory: "/")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 7, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{!"clang version 12.0.0"}
+!11 = distinct !DISubprogram(name: "fun", linkageName: "_Z3funi", scope: !3, file: !3, line: 3, type: !12, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !14)
+!12 = !DISubroutineType(types: !13)
+!13 = !{!6, !6}
+!14 = !{!15}
+!15 = !DILocalVariable(name: "a", arg: 1, scope: !11, file: !3, line: 3, type: !6)
+!16 = distinct !DIAssignID()
+!17 = !DILocation(line: 0, scope: !11)
+!18 = distinct !DIAssignID()
+!19 = !DILocation(line: 4, column: 7, scope: !20)
+!20 = distinct !DILexicalBlock(scope: !11, file: !3, line: 4, column: 7)
+!25 = !DILocation(line: 4, column: 9, scope: !20)
+!26 = !DILocation(line: 4, column: 7, scope: !11)
+!27 = !DILocation(line: 5, column: 5, scope: !20)
+!28 = !DILocation(line: 7, column: 8, scope: !11)
+!29 = !DILocation(line: 7, column: 5, scope: !11)
+!30 = distinct !DIAssignID()
+!31 = !DILocation(line: 8, column: 3, scope: !11)
+!32 = !DISubprogram(name: "ext", linkageName: "_Z3extv", scope: !3, file: !3, line: 2, type: !33, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !4)
+!33 = !DISubroutineType(types: !34)
+!34 = !{null}

llvm/test/DebugInfo/assignment-tracking/X86/remove-undef-fragment.ll

+; RUN: llc %s -o - -stop-after=finalize-isel \
+; RUN:    -experimental-assignment-tracking  \
+; RUN: | FileCheck %s --implicit-check-not=DBG
+
+;; In the IR below, for variable n, we get dbg intrinsics that describe this:
+;;
+;; entry-block:
+;;     Frag (off=0,  sz=32): non-undef
+;;     Frag (off=64, sz=64): undef
+;;     Frag (off=64, sz=32): non-undef
+;;
+;; The undef is redundant, as it doesn't close any open location ranges. Check
+;; that it has been removed. Removing redundant undefs from the entry block
+;; helps avoid losing coverage due to SelectionDAG doing weird (/bad) things.
+;; Even if SelectionDAG is fixed, fewer redundant DBG instructions is still a
+;; valuable goal.
+
+;; The test
+;; --------
+;; We expect to see two DBG instructions, one for each non-undef fragment. We
+;; don't bother checking the operands because it doesn't matter if either of
+;; these have become undef as a result of SelectionDAG dropping the values
+;; (which happens to be the case here). It's just important that SelectionDAG
+;; was fed these fragments.
+
+; CHECK: DBG{{.*}}DIExpression(DW_OP_LLVM_fragment, 0, 32)
+; CHECK: DBG{{.*}}DIExpression(DW_OP_LLVM_fragment, 64, 32)
+
+;; Source
+;; ------
+;; IR llvm-reduced from optimized IR generated from, itself reduced from
+;; CTMark's bullet source file btScaledBvhTriangleMeshShape.cpp:
+;; class a {
+;; public:
+;;   float b[4];
+;;   __attribute__((nodebug)) a() {}
+;;   __attribute__((nodebug)) a(float c, float p2) {
+;;     b[0] = c;
+;;     b[2] = p2;
+;;   }
+;;   __attribute__((nodebug)) void operator+=(a) {
+;;     b[0] += 0;
+;;     b[2] += 2;
+;;   }
+;;   __attribute__((nodebug)) float d(a c) { return c.b[0] + c.b[2]; }
+;; };
+;;
+;; __attribute__((nodebug)) void operator-(a, a);
+;; __attribute__((nodebug)) a operator*(float, a p2) {
+;;   a e(p2.b[0], p2.b[2]);
+;;   return e;
+;; }
+;;
+;; __attribute__((nodebug)) a x();
+;; __attribute__((nodebug)) a y(int);
+;;
+;; void k() {
+;;   __attribute__((nodebug)) a l = x();
+;;   __attribute__((nodebug)) a m = l;
+;;   __attribute__((nodebug)) a ag;
+;;   a n = 0.f * m;
+;;
+;;   n += a();
+;;   __attribute__((nodebug)) a ah(y(0).d(n), 0);
+;;   ag - ah;
+;; }
+
+define void @_Z1kv({ <2 x float>, <2 x float> } %call, <2 x float> %0, float %n.sroa.6.8.vec.extract) !dbg !7 {
+entry:
+  %call1 = tail call { <2 x float>, <2 x float> } undef(), !dbg !13
+  %1 = extractvalue { <2 x float>, <2 x float> } %call, 1
+  %add.i = fadd float undef, 0.000000e+00
+  call void @llvm.dbg.assign(metadata float %add.i, metadata !11, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32), metadata !14, metadata ptr undef, metadata !DIExpression()), !dbg !15
+  %n.sroa.6.8.vec.extract2 = extractelement <2 x float> %0, i64 0
+  %add4.i = fadd float %n.sroa.6.8.vec.extract, 0.000000e+00
+  call void @llvm.dbg.value(metadata <2 x float> undef, metadata !11, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg !15
+  call void @llvm.dbg.assign(metadata float %add4.i, metadata !11, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !16, metadata ptr undef, metadata !DIExpression()), !dbg !15
+  %add.i23 = fadd float 0.000000e+00, 0.000000e+00
+  %ah.sroa.0.0.vec.insert = insertelement <2 x float> zeroinitializer, float %add4.i, i64 0
+  tail call void undef(<2 x float> zeroinitializer, <2 x float> zeroinitializer, <2 x float> %ah.sroa.0.0.vec.insert, <2 x float> zeroinitializer)
+  ret void
+}
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5, !6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "reduce.cpp", directory: "/")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 1}
+!6 = !{i32 7, !"frame-pointer", i32 2}
+!7 = distinct !DISubprogram(name: "k", linkageName: "_Z1kv", scope: !1, file: !1, line: 25, type: !8, scopeLine: 25, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "n", scope: !7, file: !1, line: 29, type: !12)
+!12 = !DICompositeType(tag: DW_TAG_class_type, name: "a", file: !1, line: 1, size: 128, flags: DIFlagFwdDecl | DIFlagNonTrivial, identifier: "_ZTS1a")
+!13 = !DILocation(line: 26, scope: !7)
+!14 = distinct !DIAssignID()
+!15 = !DILocation(line: 0, scope: !7)
+!16 = distinct !DIAssignID()

llvm/test/DebugInfo/assignment-tracking/X86/sdag-dangling-dbgassign.ll

+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -experimental-debug-variable-locations=false \
+; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE
+; RUN: llc %s -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -experimental-debug-variable-locations=true \
+; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF
+
+;--------------------------------------------------------------------
+; Adapted from sdag-dangling-dbgvalue.ll to test dbg.assign intrinsics. This
+; ensures that dbg.assigns with no linked store are treated as dbg.values.  For
+; ease of writing, all the dbg.assign intrinsics refer to the same DIAssignID
+; !54. There is no linked store in any case.
+;
+; This test case is basically generated from the following C code.
+; Compiled with "--target=x86_64-apple-darwin -S -g -O3" to get debug
+; info for optimized code.
+;
+; struct SS {
+;   int a;
+;   int b;
+; } S = { .a = 23, .b = -17 };
+;
+; int test1() {
+;   struct SS* foo1 = &S;
+;   return (int)foo1;
+; }
+;
+; int test2() {
+;   struct SS* foo2 = &S;
+;   struct SS* bar2 = &S;
+;   return (int)foo2 + (int)bar2;
+; }
+;
+; int test3() {
+;   struct SS* bar3 = &S;
+;   struct SS* foo3 = &S;
+;   return (int)foo3 + (int)bar3;
+; }
+;
+; int test4() {
+;   struct SS* foo4 = &S;
+;   struct SS* bar4 = &S;
+;   foo = 0;
+;   return (int)foo4 + (int)bar4;
+; }
+;
+; int test5() {
+;   struct SS* bar5 = &S;
+;   struct SS* foo5 = &S;
+;   foo5 = 0;
+;   return (int)foo5 + (int)bar5;
+; }
+;--------------------------------------------------------------------
+
+; CHECK:  ![[FOO1:.*]] = !DILocalVariable(name: "foo1"
+; CHECK:  ![[BAR1:.*]] = !DILocalVariable(name: "bar1"
+; CHECK:  ![[FOO2:.*]] = !DILocalVariable(name: "foo2"
+; CHECK:  ![[BAR2:.*]] = !DILocalVariable(name: "bar2"
+; CHECK:  ![[FOO3:.*]] = !DILocalVariable(name: "bar3"
+; CHECK:  ![[BAR3:.*]] = !DILocalVariable(name: "foo3"
+; CHECK:  ![[FOO4:.*]] = !DILocalVariable(name: "foo4"
+; CHECK:  ![[BAR4:.*]] = !DILocalVariable(name: "bar4"
+; CHECK:  ![[BAR5:.*]] = !DILocalVariable(name: "bar5"
+; CHECK:  ![[FOO5:.*]] = !DILocalVariable(name: "foo5"
+
+source_filename = "sdag-dangling-dbgvalue.c"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.4.0"
+
+%struct.SS = type { i32, i32 }
+
+@S = global %struct.SS { i32 23, i32 -17 }, align 4, !dbg !0
+
+; Verify that the def comes before the for foo1.
+define i32 @test1() local_unnamed_addr #0 !dbg !17 {
+; CHECK-LABEL: bb.0.entry1
+; CHECK-NEXT:    DBG_VALUE 0, $noreg, ![[BAR1]], !DIExpression()
+; CHECK-NEXT:    [[REG1:%[0-9]+]]:gr64 = LEA64r
+; INSTRREF-SAME:    debug-instr-number 1
+; INSTRREF-NEXT:  DBG_INSTR_REF 1, 0, ![[FOO1]], !DIExpression()
+; DBGVALUE-NEXT:  DBG_VALUE [[REG1]], $noreg, ![[FOO1]], !DIExpression()
+entry1:
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !20, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !23
+  call void @llvm.dbg.assign(metadata ptr null, metadata !22, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !24
+  ret i32 ptrtoint (ptr @S to i32), !dbg !25
+}
+
+; Verify that the def comes before the for foo2 and bar2.
+define i32 @test2() local_unnamed_addr #0 !dbg !26 {
+; CHECK-LABEL: bb.0.entry2
+; CHECK-NEXT:    [[REG2:%[0-9]+]]:gr64 = LEA64r
+; INSTRREF-SAME:    debug-instr-number 1
+; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[FOO2]], !DIExpression()
+; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[BAR2]], !DIExpression()
+; DBGVALUE-NEXT: DBG_VALUE [[REG2]], $noreg, ![[FOO2]], !DIExpression
+; DBGVALUE-NEXT: DBG_VALUE [[REG2]], $noreg, ![[BAR2]], !DIExpression
+entry2:
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !28, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !30
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !29, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !31
+  ret i32 add (i32 ptrtoint (ptr @S to i32), i32 ptrtoint (ptr @S to i32)), !dbg !32
+}
+
+; Verify that the def comes before the for foo3 and bar3.
+define i32 @test3() local_unnamed_addr #0 !dbg !33 {
+; CHECK-LABEL: bb.0.entry3
+; CHECK-NEXT:    [[REG3:%[0-9]+]]:gr64 = LEA64r
+; INSTRREF-SAME:    debug-instr-number 1
+; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[BAR3]], !DIExpression()
+; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[FOO3]], !DIExpression()
+; DBGVALUE-NEXT: DBG_VALUE [[REG3]], $noreg, ![[BAR3]], !DIExpression()
+; DBGVALUE-NEXT: DBG_VALUE [[REG3]], $noreg, ![[FOO3]], !DIExpression()
+entry3:
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !36, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !38
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !35, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !37
+  ret i32 add (i32 ptrtoint (ptr @S to i32), i32 ptrtoint (ptr @S to i32)), !dbg !39
+}
+
+; Verify that the def comes before the for bar4.
+define i32 @test4() local_unnamed_addr #0 !dbg !40 {
+; CHECK-LABEL: bb.0.entry4
+;; NOTE: The check for `DBG_VALUE $noreg, $noreg, ![[FOO4]], !DIExpression()`
+;; has been removed because AT lowering removes redundant debug intrinsics.
+; CHECK-NEXT:    DBG_VALUE 0, $noreg, ![[FOO4]], !DIExpression()
+; CHECK-NEXT:    [[REG4:%[0-9]+]]:gr64 = LEA64r
+; INSTRREF-SAME:    debug-instr-number 1
+; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[BAR4]], !DIExpression()
+; DBGVALUE-NEXT: DBG_VALUE [[REG4]], $noreg, ![[BAR4]], !DIExpression()
+entry4:
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !42, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !44
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !43, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !45
+  call void @llvm.dbg.assign(metadata ptr null, metadata !42, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !44
+  ret i32 ptrtoint (ptr @S to i32), !dbg !46
+}
+
+; Verify that we do not get a DBG_VALUE that maps foo5 to @S here.
+define i32 @test5() local_unnamed_addr #0 !dbg !47 {
+; CHECK-LABEL: bb.0.entry5:
+; cHECK-NEXT:    DBG_VALUE $noreg, $noreg, ![[FOO5]], !DIExpression()
+; CHECK-NEXT:    DBG_VALUE 0, $noreg, ![[FOO5]], !DIExpression()
+; CHECK-NEXT:    [[REG5:%[0-9]+]]:gr64 = LEA64r
+; INSTRREF-SAME:    debug-instr-number 1
+; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[BAR5]], !DIExpression()
+; DBGVALUE-NEXT: DBG_VALUE [[REG5]], $noreg, ![[BAR5]], !DIExpression()
+; CHECK-NOT:     DBG_{{.*}} ![[FOO5]], !DIExpression()
+; CHECK:         RET
+entry5:
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !49, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !51
+  call void @llvm.dbg.assign(metadata ptr @S, metadata !50, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !52
+  call void @llvm.dbg.assign(metadata ptr null, metadata !50, metadata !DIExpression(), metadata !54, metadata ptr undef, metadata !DIExpression()), !dbg !52
+  ret i32 ptrtoint (ptr @S to i32), !dbg !53
+}
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind readnone uwtable }
+attributes #1 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!12, !13, !14, !15}
+!llvm.ident = !{!16}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "S", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 7.0.0 (trunk 327229) (llvm/trunk 327239)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !5, globals: !7)
+!3 = !DIFile(filename: "sdag-dangling-dbgvalue.c", directory: "/repo/uabbpet/llvm-master")
+!4 = !{}
+!5 = !{!6}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{!0}
+!8 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "SS", file: !3, line: 1, size: 64, elements: !9)
+!9 = !{!10, !11}
+!10 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !8, file: !3, line: 2, baseType: !6, size: 32)
+!11 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !8, file: !3, line: 3, baseType: !6, size: 32, offset: 32)
+!12 = !{i32 2, !"Dwarf Version", i32 2}
+!13 = !{i32 2, !"Debug Info Version", i32 3}
+!14 = !{i32 1, !"wchar_size", i32 4}
+!15 = !{i32 7, !"PIC Level", i32 2}
+!16 = !{!"clang version 7.0.0 (trunk 327229) (llvm/trunk 327239)"}
+!17 = distinct !DISubprogram(name: "test1", scope: !3, file: !3, line: 6, type: !18, isLocal: false, isDefinition: true, scopeLine: 6, isOptimized: true, unit: !2, retainedNodes: !19)
+!18 = !DISubroutineType(types: !5)
+!19 = !{!20, !22}
+!20 = !DILocalVariable(name: "foo1", scope: !17, file: !3, line: 7, type: !21)
+!21 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !8, size: 64)
+!22 = !DILocalVariable(name: "bar1", scope: !17, file: !3, line: 8, type: !21)
+!23 = !DILocation(line: 7, column: 14, scope: !17)
+!24 = !DILocation(line: 8, column: 14, scope: !17)
+!25 = !DILocation(line: 9, column: 3, scope: !17)
+!26 = distinct !DISubprogram(name: "test2", scope: !3, file: !3, line: 12, type: !18, isLocal: false, isDefinition: true, scopeLine: 12, isOptimized: true, unit: !2, retainedNodes: !27)
+!27 = !{!28, !29}
+!28 = !DILocalVariable(name: "foo2", scope: !26, file: !3, line: 13, type: !21)
+!29 = !DILocalVariable(name: "bar2", scope: !26, file: !3, line: 14, type: !21)
+!30 = !DILocation(line: 13, column: 14, scope: !26)
+!31 = !DILocation(line: 14, column: 14, scope: !26)
+!32 = !DILocation(line: 15, column: 3, scope: !26)
+!33 = distinct !DISubprogram(name: "test3", scope: !3, file: !3, line: 18, type: !18, isLocal: false, isDefinition: true, scopeLine: 18, isOptimized: true, unit: !2, retainedNodes: !34)
+!34 = !{!35, !36}
+!35 = !DILocalVariable(name: "bar3", scope: !33, file: !3, line: 19, type: !21)
+!36 = !DILocalVariable(name: "foo3", scope: !33, file: !3, line: 20, type: !21)
+!37 = !DILocation(line: 19, column: 14, scope: !33)
+!38 = !DILocation(line: 20, column: 14, scope: !33)
+!39 = !DILocation(line: 21, column: 3, scope: !33)
+!40 = distinct !DISubprogram(name: "test4", scope: !3, file: !3, line: 24, type: !18, isLocal: false, isDefinition: true, scopeLine: 24, isOptimized: true, unit: !2, retainedNodes: !41)
+!41 = !{!42, !43}
+!42 = !DILocalVariable(name: "foo4", scope: !40, file: !3, line: 25, type: !21)
+!43 = !DILocalVariable(name: "bar4", scope: !40, file: !3, line: 26, type: !21)
+!44 = !DILocation(line: 25, column: 14, scope: !40)
+!45 = !DILocation(line: 26, column: 14, scope: !40)
+!46 = !DILocation(line: 28, column: 3, scope: !40)
+!47 = distinct !DISubprogram(name: "test5", scope: !3, file: !3, line: 31, type: !18, isLocal: false, isDefinition: true, scopeLine: 31, isOptimized: true, unit: !2, retainedNodes: !48)
+!48 = !{!49, !50}
+!49 = !DILocalVariable(name: "bar5", scope: !47, file: !3, line: 32, type: !21)
+!50 = !DILocalVariable(name: "foo5", scope: !47, file: !3, line: 33, type: !21)
+!51 = !DILocation(line: 32, column: 14, scope: !47)
+!52 = !DILocation(line: 33, column: 14, scope: !47)
+!53 = !DILocation(line: 35, column: 3, scope: !47)
+!54 = distinct !DIAssignID()

llvm/test/DebugInfo/assignment-tracking/X86/sdag-ir-salvage-assign.ll

+; RUN: llc -mtriple=x86_64-unknown-unknown -start-after=codegenprepare \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -stop-before finalize-isel %s -o -  \
+; RUN:    -experimental-debug-variable-locations=false \
+; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE
+; RUN: llc -mtriple=x86_64-unknown-unknown -start-after=codegenprepare \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -stop-before finalize-isel %s -o -  \
+; RUN:    -experimental-debug-variable-locations=true \
+; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF
+
+; Adapted from sdag-ir-salvage.ll to test dbg.assign intrinsics. This ensures
+; that dbg.assigns with no linked store are treated as dbg.values.
+
+; Test that the dbg.value for %baz, which doesn't exist in the 'next' bb,
+; can be salvaged back to the underlying argument vreg.
+
+; CHECK:       ![[AAAVAR:.*]] = !DILocalVariable(name: "aaa",
+; CHECK-LABEL: bb.0.entry:
+; INSTRREF:    DBG_PHI $rdi, 1
+; CHECK-LABEL: bb.1.next:
+; INSTRREF:    DBG_INSTR_REF 1, 0, ![[AAAVAR]]
+; DBGVALUE:    DBG_VALUE %{{[0-9]+}}, $noreg, ![[AAAVAR]]
+
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-linux-gnu"
+
+define i8 @f(ptr %foo) local_unnamed_addr !dbg !6 {
+entry:
+  %bar = getelementptr i32, ptr %foo, i32 4
+  %baz = bitcast ptr %bar to ptr
+  %quux = load i8, ptr %baz
+  br label %next
+
+next:                                             ; preds = %entry
+  tail call void @llvm.dbg.assign(metadata ptr %baz, metadata !15, metadata !DIExpression(), metadata !31, metadata ptr undef, metadata !DIExpression()), !dbg !30
+  %xyzzy = add i8 %quux, 123
+  br label %fin
+
+fin:                                              ; preds = %next
+  %trains = getelementptr i32, ptr %foo, i32 3
+  %planes = bitcast ptr %trains to ptr
+  %cars = load i8, ptr %planes
+  %ret = add i8 %xyzzy, %cars
+  ret i8 %ret
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #0
+
+attributes #0 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!25, !26, !27, !28}
+!llvm.ident = !{!29}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "test.c", directory: ".")
+!2 = !{}
+!6 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 18, type: !7, scopeLine: 19, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !14)
+!7 = !DISubroutineType(types: !8)
+!8 = !{!13}
+!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_unsigned)
+!14 = !{!15}
+!15 = !DILocalVariable(name: "aaa", scope: !6, file: !1, line: 18, type: !13)
+!25 = !{i32 2, !"Dwarf Version", i32 4}
+!26 = !{i32 2, !"Debug Info Version", i32 3}
+!27 = !{i32 1, !"wchar_size", i32 4}
+!28 = !{i32 7, !"PIC Level", i32 2}
+!29 = !{!"clang"}
+!30 = !DILocation(line: 18, column: 14, scope: !6)
+!31 = distinct !DIAssignID()

llvm/test/DebugInfo/assignment-tracking/X86/sdag-transfer-dbgassign.ll

+; RUN: llc %s -start-after=codegenprepare -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -experimental-debug-variable-locations=false \
+; RUN: | FileCheck %s --check-prefixes=CHECK,DBGVALUE
+; RUN: llc %s -start-after=codegenprepare -stop-before finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking   \
+; RUN:    -experimental-debug-variable-locations=true \
+; RUN: | FileCheck %s --check-prefixes=CHECK,INSTRREF
+
+; Adapted from sdag-transfer-dbgvalue.ll to test dbg.assign intrinsics. This
+; ensures that dbg.assigns with no linked store are treated as dbg.values.
+
+; This tests that transferDbgValues() changes order of SDDbgValue transferred
+; to another node and debug info for 'ADD32ri' appears *after* the instruction.
+;
+; This test case was generated from the following program
+; using: clang -g -O3 -S -emit-llvm test.c
+;
+; int foo(int a, int *b) {
+;   int c = a + 512;
+;   if (c != 0)
+;     *b = a;
+;   return c;
+; }
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; CHECK-LABEL: bb.0.entry:
+; DBGVALUE:       %[[REG:[0-9]+]]:gr32 = ADD32ri %1, 512
+; DBGVALUE-NEXT:  DBG_VALUE %[[REG]]
+; INSTRREF:       ADD32ri %1, 512, {{.*}}debug-instr-number 1
+; INSTRREF-NEXT:  DBG_INSTR_REF 1, 0
+
+; Function Attrs: nofree norecurse nounwind uwtable writeonly
+define dso_local i32 @foo(i32 %a, ptr nocapture %b) local_unnamed_addr !dbg !7 {
+entry:
+  %add = add nsw i32 %a, 512, !dbg !18
+  call void @llvm.dbg.assign(metadata i32 %add, metadata !16, metadata !DIExpression(), metadata !19, metadata ptr undef, metadata !DIExpression()), !dbg !17
+  %cmp = icmp eq i32 %add, 0, !dbg !18
+  br i1 %cmp, label %if.end, label %if.then, !dbg !18
+
+if.then:                                          ; preds = %entry
+  store i32 %a, ptr %b, align 4, !dbg !18
+  br label %if.end, !dbg !18
+
+if.end:                                           ; preds = %entry, %if.then
+  ret i32 %add, !dbg !18
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, 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 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "test.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 10.0.0"}
+!7 = distinct !DISubprogram(name: "foo", scope: !8, file: !8, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !13)
+!8 = !DIFile(filename: "test.c", directory: "/")
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !11, !12}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64)
+!13 = !{!14, !15, !16}
+!14 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !8, line: 1, type: !11)
+!15 = !DILocalVariable(name: "b", arg: 2, scope: !7, file: !8, line: 1, type: !12)
+!16 = !DILocalVariable(name: "c", scope: !7, file: !8, line: 2, type: !11)
+!17 = !DILocation(line: 0, scope: !7)
+!18 = !DILocation(line: 2, column: 13, scope: !7)
+!19 = distinct !DIAssignID()

llvm/test/DebugInfo/assignment-tracking/X86/single-memory-location-2.ll

+; RUN: llc -stop-after=finalize-isel %s -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN: | FileCheck %s
+
+;; Check that a dbg.assign for a fully stack-homed variable causes the variable
+;; location to appear in the Machine Function side table. Similar to
+;; single-memory-location.ll except this has slightly more complicated input
+;; (there's a loop and an assignment).
+;;
+;; $ cat test.cpp
+;; int get();
+;; void esc(int*);
+;; void doSomething(int);
+;; void fun() {
+;;   int local;
+;;   esc(&local);
+;;   while (local) {
+;;     local = get();
+;;     doSomething(local);
+;;     esc(&local);    
+;;   }
+;; }
+;; $ clang++ -O2 -g -emit-llvm -S -c -Xclang -fexperimental-assignment-tracking
+
+; CHECK: ![[VAR:[0-9]+]] = !DILocalVariable(name: "local",
+; CHECK: stack:
+; CHECK-NEXT: - { id: 0, name: local, type: default, offset: 0, size: 4, alignment: 4, 
+; CHECK-NEXT:     stack-id: default, callee-saved-register: '', callee-saved-restored: true, 
+; CHECK-NEXT:     debug-info-variable: '![[VAR]]', debug-info-expression: '!DIExpression()', 
+; CHECK-NEXT:     debug-info-location: '!{{.+}}' }
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: uwtable mustprogress
+define dso_local void @_Z3funv() local_unnamed_addr #0 !dbg !7 {
+entry:
+  %local = alloca i32, align 4, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(), metadata !13, metadata ptr %local, metadata !DIExpression()), !dbg !14
+  %0 = bitcast ptr %local to ptr, !dbg !15
+  call void @llvm.lifetime.start.p0i8(i64 4, ptr nonnull %0) #4, !dbg !15
+  call void @_Z3escPi(ptr nonnull %local), !dbg !16
+  %1 = load i32, ptr %local, align 4, !dbg !17
+  %tobool.not1 = icmp eq i32 %1, 0, !dbg !17
+  br i1 %tobool.not1, label %while.end, label %while.body, !dbg !22
+
+while.body:                                       ; preds = %entry, %while.body
+  %call = call i32 @_Z3getv(), !dbg !23
+  store i32 %call, ptr %local, align 4, !dbg !25, !DIAssignID !26
+  call void @llvm.dbg.assign(metadata i32 %call, metadata !11, metadata !DIExpression(), metadata !26, metadata ptr %local, metadata !DIExpression()), !dbg !14
+  call void @_Z11doSomethingi(i32 %call), !dbg !27
+  call void @_Z3escPi(ptr nonnull %local), !dbg !28
+  %2 = load i32, ptr %local, align 4, !dbg !17
+  %tobool.not = icmp eq i32 %2, 0, !dbg !17
+  br i1 %tobool.not, label %while.end, label %while.body, !dbg !22, !llvm.loop !29
+
+while.end:                                        ; preds = %while.body, %entry
+  call void @llvm.lifetime.end.p0i8(i64 4, ptr nonnull %0) #4, !dbg !32
+  ret void, !dbg !32
+}
+
+declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
+declare !dbg !33 dso_local void @_Z3escPi(ptr) local_unnamed_addr
+declare !dbg !37 dso_local i32 @_Z3getv() local_unnamed_addr
+declare !dbg !40 dso_local void @_Z11doSomethingi(i32) local_unnamed_addr
+declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "fun", linkageName: "_Z3funv", scope: !1, file: !1, line: 4, type: !8, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "local", scope: !7, file: !1, line: 5, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = distinct !DIAssignID()
+!14 = !DILocation(line: 0, scope: !7)
+!15 = !DILocation(line: 5, column: 3, scope: !7)
+!16 = !DILocation(line: 6, column: 3, scope: !7)
+!17 = !DILocation(line: 7, column: 10, scope: !7)
+!22 = !DILocation(line: 7, column: 3, scope: !7)
+!23 = !DILocation(line: 8, column: 13, scope: !24)
+!24 = distinct !DILexicalBlock(scope: !7, file: !1, line: 7, column: 17)
+!25 = !DILocation(line: 8, column: 11, scope: !24)
+!26 = distinct !DIAssignID()
+!27 = !DILocation(line: 9, column: 5, scope: !24)
+!28 = !DILocation(line: 10, column: 5, scope: !24)
+!29 = distinct !{!29, !22, !30, !31}
+!30 = !DILocation(line: 11, column: 3, scope: !7)
+!31 = !{!"llvm.loop.mustprogress"}
+!32 = !DILocation(line: 12, column: 1, scope: !7)
+!33 = !DISubprogram(name: "esc", linkageName: "_Z3escPi", scope: !1, file: !1, line: 2, type: !34, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!34 = !DISubroutineType(types: !35)
+!35 = !{null, !36}
+!36 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
+!37 = !DISubprogram(name: "get", linkageName: "_Z3getv", scope: !1, file: !1, line: 1, type: !38, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!38 = !DISubroutineType(types: !39)
+!39 = !{!12}
+!40 = !DISubprogram(name: "doSomething", linkageName: "_Z11doSomethingi", scope: !1, file: !1, line: 3, type: !41, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!41 = !DISubroutineType(types: !42)
+!42 = !{null, !12}

llvm/test/DebugInfo/assignment-tracking/X86/single-memory-location.ll

+; RUN: llc -stop-after=finalize-isel %s -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN: | FileCheck %s
+
+;; Check that a dbg.assign for a fully stack-homed variable causes the variable
+;; location to appear in the Machine Function side table.
+;;
+;; $ cat test.cpp
+;; void maybe_writes(int*);
+;; void ext(int, int, int, int, int, int, int, int, int, int);
+;; int example() {
+;;    int local;
+;;    maybe_writes(&local);
+;;    ext(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+;;    return local;
+;; }
+;; $ clang++ -O2 -g -emit-llvm -S -c -Xclang -fexperimental-assignment-tracking
+
+; CHECK: ![[VAR:[0-9]+]] = !DILocalVariable(name: "local",
+; CHECK: stack:
+; CHECK-NEXT: - { id: 0, name: local, type: default, offset: 0, size: 4, alignment: 4, 
+; CHECK-NEXT:     stack-id: default, callee-saved-register: '', callee-saved-restored: true, 
+; CHECK-NEXT:     debug-info-variable: '![[VAR]]', debug-info-expression: '!DIExpression()', 
+; CHECK-NEXT:     debug-info-location: '!{{.+}}' }
+
+source_filename = "test.cpp"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local i32 @_Z7examplev() local_unnamed_addr !dbg !7 {
+entry:
+  %local = alloca i32, align 4, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !12, metadata !DIExpression(), metadata !13, metadata ptr %local, metadata !DIExpression()), !dbg !14
+  %0 = bitcast ptr %local to ptr, !dbg !15
+  call void @llvm.lifetime.start.p0i8(i64 4, ptr nonnull %0), !dbg !15
+  call void @_Z12maybe_writesPi(ptr nonnull %local), !dbg !16
+  call void @_Z3extiiiiiiiiii(i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9), !dbg !17
+  %1 = load i32, ptr %local, align 4, !dbg !18
+  call void @llvm.lifetime.end.p0i8(i64 4, ptr nonnull %0), !dbg !23
+  ret i32 %1, !dbg !24
+}
+
+declare !dbg !25 dso_local void @_Z12maybe_writesPi(ptr) local_unnamed_addr
+declare !dbg !29 dso_local void @_Z3extiiiiiiiiii(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) local_unnamed_addr
+declare void @llvm.lifetime.start.p0i8(i64 immarg, ptr nocapture)
+declare void @llvm.lifetime.end.p0i8(i64 immarg, ptr nocapture)
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "example", linkageName: "_Z7examplev", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "local", scope: !7, file: !1, line: 4, type: !10)
+!13 = distinct !DIAssignID()
+!14 = !DILocation(line: 0, scope: !7)
+!15 = !DILocation(line: 4, column: 4, scope: !7)
+!16 = !DILocation(line: 5, column: 4, scope: !7)
+!17 = !DILocation(line: 6, column: 4, scope: !7)
+!18 = !DILocation(line: 7, column: 11, scope: !7)
+!23 = !DILocation(line: 8, column: 1, scope: !7)
+!24 = !DILocation(line: 7, column: 4, scope: !7)
+!25 = !DISubprogram(name: "maybe_writes", linkageName: "_Z12maybe_writesPi", scope: !1, file: !1, line: 1, type: !26, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!26 = !DISubroutineType(types: !27)
+!27 = !{null, !28}
+!28 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!29 = !DISubprogram(name: "ext", linkageName: "_Z3extiiiiiiiiii", scope: !1, file: !1, line: 2, type: !30, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!30 = !DISubroutineType(types: !31)
+!31 = !{null, !10, !10, !10, !10, !10, !10, !10, !10, !10, !10}

llvm/test/DebugInfo/assignment-tracking/X86/split-alloca.ll

+; RUN: llc %s -o - -stop-after=finalize-isel \
+; RUN:    -experimental-assignment-tracking  \
+; RUN: | FileCheck %s --implicit-check-not=DBG
+
+;; Hand written. Check that we fall back to emitting a list of defs for
+;; variables with split allocas (i.e. we want to see DBG_VALUEs and no
+;; debug-info-variable entry in the stack slot table).
+
+; CHECK: stack:
+; CHECK:   - { id: 0, name: a, type: default, offset: 0, size: 4, alignment: 4, 
+; CHECK:       stack-id: default, callee-saved-register: '', callee-saved-restored: true, 
+; CHECK:       debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+; CHECK:   - { id: 1, name: c, type: default, offset: 0, size: 4, alignment: 4, 
+; CHECK:       stack-id: default, callee-saved-register: '', callee-saved-restored: true, 
+; CHECK:       debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+; CHECK: DBG_VALUE %stack.0.a, $noreg, !{{.*}}, !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 32) 
+; CHECK: DBG_VALUE %stack.1.c, $noreg, !{{.*}}, !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 64, 32)
+
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local void @fun() !dbg !7 {
+entry:
+  %a = alloca i32, align 4, !DIAssignID !16
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32), metadata !16, metadata ptr %a, metadata !DIExpression()), !dbg !17
+  %c = alloca i32, align 4, !DIAssignID !20
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata !20, metadata ptr %c, metadata !DIExpression()), !dbg !17
+  store i32 5, ptr %a, !DIAssignID !21
+  ret void, !dbg !19
+}
+
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 1}
+!6 = !{!"clang version 14.0.0"}
+!7 = distinct !DISubprogram(name: "fun", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "local", scope: !7, file: !1, line: 2, type: !12)
+!12 = !DICompositeType(tag: DW_TAG_array_type, baseType: !13, size: 96, elements: !14)
+!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!14 = !{!15}
+!15 = !DISubrange(count: 3)
+!16 = distinct !DIAssignID()
+!17 = !DILocation(line: 0, scope: !7)
+!18 = !DILocation(line: 2, column: 3, scope: !7)
+!19 = !DILocation(line: 3, column: 1, scope: !7)
+!20 = distinct !DIAssignID()
+!21 = distinct !DIAssignID()

llvm/test/DebugInfo/assignment-tracking/X86/untagged-store-frag.ll

+; RUN: llc %s -stop-after=finalize-isel -o - -experimental-assignment-tracking \
+; RUN: | FileCheck %s --implicit-check-not=DBG_
+
+;; Hand-written to test untagged store handling on a simple case. Here's what
+;; we're looking at in the IR:
+
+;; 1. mem(a): bits [0,  64) = !14
+;; 2. dbg(a): bits [0,  64) = !14 ; Use memory loc
+;; 3. dbg(a): bits [0,  32) = <unique ID> ; Use implicit loc, dbg.value has no ID
+;; 4. dbg(a): bits [32, 64) = !16 ; These bits don't use mem loc.
+;;                                ; Linked to a def that comes later ---+
+;; ...                                                                ; |
+;; 5. mem(a): bits [0,  32) = <unique ID> ; Untagged store            ; |
+;; ..                                                                 ; |
+;; 6. mem(a): bits [32, 64) = !16 ; <-----------------------------------+
+
+;; Taking the '<number>.' above as the 'position', check we get defs that look
+;; like this:
+;; Position | bits [0, 32) | bits [32,  64)
+;; ---------+--------------+---------------
+;; 2.       | Mem          | Mem
+;; 3.       | Value        | Mem
+;; 4.       | Value        | Value
+;; 5.       | Mem          | Value
+;; 6.       | Mem          | Mem
+
+; CHECK-DAG: ![[A:[0-9]+]] = !DILocalVariable(name: "a",
+
+; CHECK:      DBG_VALUE %stack.0.a.addr, $noreg, ![[A]], !DIExpression(DW_OP_deref)
+; CHECK-NEXT: DBG_VALUE 5,               $noreg, ![[A]], !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+; CHECK-NEXT: DBG_VALUE $noreg,          $noreg, ![[A]], !DIExpression(DW_OP_LLVM_fragment, 32, 32)
+; CHECK-NEXT:   MOV32mi %stack.0.a.addr, 1, $noreg, 0, $noreg, 123
+; CHECK-NEXT: DBG_VALUE %stack.0.a.addr, $noreg, ![[A]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 32)
+; CHECK-NEXT:   MOV32mr %stack.0.a.addr, 1, $noreg, 4, $noreg, %1 :: (store (s32) into %ir.add.ptr, align 8)
+; CHECK-NEXT: DBG_VALUE %stack.0.a.addr, $noreg, ![[A]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 32, 32)
+
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local noundef i64 @_Z1fl(i64 noundef %a, i32 %b) #0 !dbg !8 {
+entry:
+  %a.addr = alloca i64, align 8, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !14, metadata !DIExpression(), metadata !13, metadata ptr %a.addr, metadata !DIExpression()), !dbg !15
+  call void @llvm.dbg.value(metadata i64 5, metadata !14, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32)), !dbg !15
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !14, metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32), metadata !16, metadata ptr %a.addr, metadata !DIExpression()), !dbg !15
+  %frag.addr = bitcast ptr %a.addr to ptr
+  store i32 123, ptr %frag.addr, align 8
+  %0 = bitcast ptr %a.addr to ptr
+  %add.ptr = getelementptr inbounds i32, ptr %0, i64 1
+  store i32 %b, ptr %add.ptr, align 8, !DIAssignID !16
+  %1 = load i64, ptr %a.addr, align 8
+  ret i64 %1
+}
+
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #1
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: "/")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"uwtable", i32 1}
+!6 = !{i32 7, !"frame-pointer", i32 2}
+!7 = !{!"clang version 14.0.0"}
+!8 = distinct !DISubprogram(name: "f", linkageName: "_Z1fl", scope: !1, file: !1, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !12)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11, !11}
+!11 = !DIBasicType(name: "long", size: 64, encoding: DW_ATE_signed)
+!12 = !{}
+!13 = distinct !DIAssignID()
+!14 = !DILocalVariable(name: "a", arg: 1, scope: !8, file: !1, line: 1, type: !11)
+!15 = !DILocation(line: 0, scope: !8)
+!16 = distinct !DIAssignID()
+!17 = !DILocalVariable(name: "b", arg: 2, scope: !8, file: !1, line: 1, type: !11)

llvm/test/DebugInfo/assignment-tracking/X86/use-known-value-at-early-mem-def-2.ll

+; RUN: llc %s -stop-after=finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking \
+; RUN: | FileCheck %s --implicit-check-not=DBG_VALUE
+
+;; Check that sandwiching instructions between a linked store and dbg.assign
+;; results in a dbg.value(prev_value) being inserted at the store, and a
+;; dbg.value(deref) at the dbg.assign.
+;; Same as use-known-value-at-early-mem-def.ll except the "early mem def" is
+;; for a fragment of the variable rather than the whole.
+
+; CHECK: bb.0.entry:
+; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var:[0-9]+]], !DIExpression(DW_OP_deref), debug-location
+; CHECK: MOV64mi32 %stack.0.c, 1, $noreg, 0, $noreg, 5
+;; No DBG_VALUE required because the stack location is still valid.
+
+; CHECK: MOV32mi %stack.0.c, 1, $noreg, 0, $noreg, 1
+; CHECK-NEXT: DBG_VALUE $noreg, $noreg, ![[var]], !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location
+;; This DBG_VALUE is added by the frag-agg pass because bits [32, 64) are still
+;; live in memory.
+; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_deref, DW_OP_LLVM_fragment, 32, 32)
+
+; CHECK: CALL64pcrel32 @d
+; CHECK-NEXT: ADJCALLSTACKUP64
+; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var]], !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 32), debug-location
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @b() local_unnamed_addr #0 !dbg !7 {
+entry:
+  %c = alloca i64, align 1, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(), metadata !13, metadata i64* %c, metadata !DIExpression()), !dbg !14
+  call void @llvm.lifetime.start.p0i64(i64 1, i64* nonnull %c) #4, !dbg !15
+  store i64 5, i64* %c, align 1, !dbg !16, !DIAssignID !20
+  call void @llvm.dbg.assign(metadata i64 5, metadata !11, metadata !DIExpression(), metadata !20, metadata i64* %c, metadata !DIExpression()), !dbg !14
+  tail call void (...) @d() #4, !dbg !21
+
+  ; --- VV  Hand written  VV --- ;
+  %bc = bitcast i64* %c to i32*
+  store i32 1, i32* %bc, align 1, !dbg !16, !DIAssignID !31
+  ;; Check that a dbg.value(undef, frag(0, 32)) is inserted here. The value of
+  ;; the fragment is "unknown". TODO: In this case the value of the fragment is
+  ;; still obviously 5; a future improvement could be to be smarter and work
+  ;; this out. But that's a lot of work for an uncommon case.
+  tail call void (...) @d() #4, !dbg !21
+  call void @llvm.dbg.assign(metadata i32 1, metadata !11, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32), metadata !31, metadata i32* %bc, metadata !DIExpression()), !dbg !14
+  ; --- AA  Hand written  AA --- ;
+
+  call void @a(i64* nonnull %c) #4, !dbg !22
+  call void @llvm.lifetime.end.p0i64(i64 1, i64* nonnull %c) #4, !dbg !23
+  ret void, !dbg !23
+}
+
+declare void @llvm.lifetime.start.p0i64(i64 immarg, i64* nocapture) #1
+declare !dbg !24 dso_local void @d(...) local_unnamed_addr #2
+declare !dbg !27 dso_local void @a(i64*) local_unnamed_addr #2
+declare void @llvm.lifetime.end.p0i64(i64 immarg, i64* nocapture) #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
+
+!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 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "reduce.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "b", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "c", scope: !7, file: !1, line: 4, type: !12)
+!12 = !DIBasicType(name: "char", size: 64, encoding: DW_ATE_unsigned)
+!13 = distinct !DIAssignID()
+!14 = !DILocation(line: 0, scope: !7)
+!15 = !DILocation(line: 4, column: 3, scope: !7)
+!16 = !DILocation(line: 4, column: 8, scope: !7)
+!20 = distinct !DIAssignID()
+!21 = !DILocation(line: 5, column: 3, scope: !7)
+!22 = !DILocation(line: 6, column: 3, scope: !7)
+!23 = !DILocation(line: 7, column: 1, scope: !7)
+!24 = !DISubprogram(name: "d", scope: !1, file: !1, line: 2, type: !25, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!25 = !DISubroutineType(types: !26)
+!26 = !{null, null}
+!27 = !DISubprogram(name: "a", scope: !1, file: !1, line: 1, type: !28, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!28 = !DISubroutineType(types: !29)
+!29 = !{null, !30}
+!30 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
+!31 = distinct !DIAssignID()

llvm/test/DebugInfo/assignment-tracking/X86/use-known-value-at-early-mem-def.ll

+; RUN: llc %s -stop-after=finalize-isel -o - \
+; RUN:    -experimental-assignment-tracking  \
+; RUN: | FileCheck %s --implicit-check-not=DBG_VALUE
+
+;; Check that sandwitching instructions between a linked store and dbg.assign
+;; results in a dbg.value(prev_value) being inserted at the store, and a
+;; dbg.value(deref) at the dbg.assign.
+
+; CHECK: bb.0.entry:
+; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var:[0-9]+]], !DIExpression(DW_OP_deref), debug-location
+; CHECK: MOV8mi %stack.0.c, 1, $noreg, 0, $noreg, 0
+;; No DBG_VALUE required because the stack location is still valid.
+
+; CHECK: MOV8mi %stack.0.c, 1, $noreg, 0, $noreg, 1
+; CHECK-NEXT: DBG_VALUE 0, $noreg, ![[var]], !DIExpression(), debug-location
+; CHECK: CALL64pcrel32 @d
+; CHECK-NEXT: ADJCALLSTACKUP64
+; CHECK-NEXT: DBG_VALUE %stack.0.c, $noreg, ![[var]], !DIExpression(DW_OP_deref), debug-location
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @b() local_unnamed_addr #0 !dbg !7 {
+entry:
+  %c = alloca i8, align 1, !DIAssignID !13
+  call void @llvm.dbg.assign(metadata i1 undef, metadata !11, metadata !DIExpression(), metadata !13, metadata i8* %c, metadata !DIExpression()), !dbg !14
+  call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %c) #4, !dbg !15
+  store i8 0, i8* %c, align 1, !dbg !16, !DIAssignID !20
+  call void @llvm.dbg.assign(metadata i8 0, metadata !11, metadata !DIExpression(), metadata !20, metadata i8* %c, metadata !DIExpression()), !dbg !14
+  tail call void (...) @d() #4, !dbg !21
+
+  ; --- VV  Hand written  VV --- ;
+  store i8 1, i8* %c, align 1, !dbg !16, !DIAssignID !31
+  ; Check that a dbg.value(0) is inserted here.
+  tail call void (...) @d() #4, !dbg !21
+  call void @llvm.dbg.assign(metadata i8 1, metadata !11, metadata !DIExpression(), metadata !31, metadata i8* %c, metadata !DIExpression()), !dbg !14
+  ; --- AA  Hand written  AA --- ;
+
+  call void @a(i8* nonnull %c) #4, !dbg !22
+  call void @llvm.lifetime.end.p0i8(i64 1, i8* nonnull %c) #4, !dbg !23
+  ret void, !dbg !23
+}
+
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
+declare !dbg !24 dso_local void @d(...) local_unnamed_addr #2
+declare !dbg !27 dso_local void @a(i8*) local_unnamed_addr #2
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
+declare void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata) #3
+
+!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 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "reduce.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "b", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "c", scope: !7, file: !1, line: 4, type: !12)
+!12 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!13 = distinct !DIAssignID()
+!14 = !DILocation(line: 0, scope: !7)
+!15 = !DILocation(line: 4, column: 3, scope: !7)
+!16 = !DILocation(line: 4, column: 8, scope: !7)
+!20 = distinct !DIAssignID()
+!21 = !DILocation(line: 5, column: 3, scope: !7)
+!22 = !DILocation(line: 6, column: 3, scope: !7)
+!23 = !DILocation(line: 7, column: 1, scope: !7)
+!24 = !DISubprogram(name: "d", scope: !1, file: !1, line: 2, type: !25, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!25 = !DISubroutineType(types: !26)
+!26 = !{null, null}
+!27 = !DISubprogram(name: "a", scope: !1, file: !1, line: 1, type: !28, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!28 = !DISubroutineType(types: !29)
+!29 = !{null, !30}
+!30 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
+!31 = distinct !DIAssignID()