Fix debug_loc offset difference with basic block sections

[tmsriram]

Summary

debug_loc for params not used in entry block need to be computed with the section start as the base label.

The attached test will not assemble without the patch as the assembler will complain that we are trying to compute a label difference from 2 different sections.

If the basic block containing the first mention of the param is not in the same section as the entry basic block, we cannot use the CurrentFnBegin label. To fix it, we use the Section begin label instead. Using the Section Label will result in loss of debug loc fidelity as we do not capture the basic blocks before the start of this section.

Right now, LabelsBeforeInsn just stores one label for each insn. We can fix the fidelity problem by storing all the basic block section labels that appear before the insn and generating a difference for each of them. Hence, I have made this as a FIXME.

Is this alright? I am not very familiar with debug_loc, other better suggestions are much appreciated here.

[dblaikie]

Trying to reproduce this (by taking the .ll test case and compiling it with clang -c) I don't get any debug_loc section or DW_AT_locations. Is there something I'm missing about how to reproduce this?

(trying to see what the non-bb-sections location description looks like - if it depends on basic block ordering, it's probably incorrect anyway, and might be worth fixing so it doesn't depend on that non-guaranteed property & then there'll be less divergence between bb-sections and not)

[tmsriram]

In D85085#2191679, @dblaikie wrote:

Trying to reproduce this (by taking the .ll test case and compiling it with clang -c) I don't get any debug_loc section or DW_AT_locations. Is there something I'm missing about how to reproduce this?

(trying to see what the non-bb-sections location description looks like - if it depends on basic block ordering, it's probably incorrect anyway, and might be worth fixing so it doesn't depend on that non-guaranteed property & then there'll be less divergence between bb-sections and not)

Yes, you are right. The debug_loc section is not generated without basic block sections, I will dig more.

[tmsriram]

In D85085#2191679, @dblaikie wrote:

Trying to reproduce this (by taking the .ll test case and compiling it with clang -c) I don't get any debug_loc section or DW_AT_locations. Is there something I'm missing about how to reproduce this?

(trying to see what the non-bb-sections location description looks like - if it depends on basic block ordering, it's probably incorrect anyway, and might be worth fixing so it doesn't depend on that non-guaranteed property & then there'll be less divergence between bb-sections and not)

I see why debug_loc is not produced in the default case. This is what happens:

+ For the default case (no bbsections), DebugLoc in https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1744 , it has exactly one value that contains the whole function scope as the start label is lfunc_begin and the end label is the end of the function.
+ Such location lists are handled specially here when the scope is the whole function : https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1841 and the debug_loc is not generated. Diffing the asm by forcing a debug_loc entry, what happens here is that a DW_AT_location is replaced with a DW_AT_const_value. I don't understand this too well but this seems like an optimization to me.

Does this make sense?

[dblaikie]

In D85085#2192340, @tmsriram wrote:

In D85085#2191679, @dblaikie wrote:

Trying to reproduce this (by taking the .ll test case and compiling it with clang -c) I don't get any debug_loc section or DW_AT_locations. Is there something I'm missing about how to reproduce this?

(trying to see what the non-bb-sections location description looks like - if it depends on basic block ordering, it's probably incorrect anyway, and might be worth fixing so it doesn't depend on that non-guaranteed property & then there'll be less divergence between bb-sections and not)

I see why debug_loc is not produced in the default case. This is what happens:

+ For the default case (no bbsections), DebugLoc in https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1744 , it has exactly one value that contains the whole function scope as the start label is lfunc_begin and the end label is the end of the function.
+ Such location lists are handled specially here when the scope is the whole function : https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1841 and the debug_loc is not generated.

OK ^ and with bb sections do we see the same behavior? If not, why not?

Diffing the asm by forcing a debug_loc entry,

Not sure what you mean by this ^ could you explain further?

what happens here is that a DW_AT_location is replaced with a DW_AT_const_value. I don't understand this too well but this seems like an optimization to me.

Does this make sense?

I'm still a bit confused. I think if non-bb-sections doesn't need a location list, then bb-sections shouldn't either. Perhaps that issue should be fixed first, if it's an issue?

In any case/any order - perhaps this patch is still reflective of a bug that exists even in this ^ issue is fixed, but maybe it's that the test case isn't sufficient to demonstrate the remaining bug - perhaps the test case could be complicated a bit further to ensure it's not testing a behavior that shouldn't be happening for other reasons anyway?

[tmsriram]

In D85085#2194130, @dblaikie wrote:

In D85085#2192340, @tmsriram wrote:

In D85085#2191679, @dblaikie wrote:

Trying to reproduce this (by taking the .ll test case and compiling it with clang -c) I don't get any debug_loc section or DW_AT_locations. Is there something I'm missing about how to reproduce this?

(trying to see what the non-bb-sections location description looks like - if it depends on basic block ordering, it's probably incorrect anyway, and might be worth fixing so it doesn't depend on that non-guaranteed property & then there'll be less divergence between bb-sections and not)

I see why debug_loc is not produced in the default case. This is what happens:

+ For the default case (no bbsections), DebugLoc in https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1744 , it has exactly one value that contains the whole function scope as the start label is lfunc_begin and the end label is the end of the function.
+ Such location lists are handled specially here when the scope is the whole function : https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1841 and the debug_loc is not generated.

OK ^ and with bb sections do we see the same behavior? If not, why not?

Please bear with my longish response here:

First, let me explain what happens with the test by default. There is no .debug_loc section by default and here is why:

Without bbsections, the ASM looks like this:

	.text
	.file	"locdspnm.cpp"
...
	.type	_ZL4ncatPcjz,@function
_ZL4ncatPcjz:                           # @_ZL4ncatPcjz
.Lfunc_begin0:
	.file	3 "/proc/self/cwd/third_party/icu/source/common/locdspnm.cpp"
	.loc	3 37 0                          # third_party/icu/source/common/locdspnm.cpp:37:0
	.cfi_startproc
# %bb.0:                                # %.critedge3
	subq	$56, %rsp
...
	je	.LBB0_2
# %bb.1:                                # %.critedge3
...
	movaps	%xmm7, 32(%rsp)
.LBB0_2:                                # %.critedge3
...
	leaq	-128(%rsp), %rax
	#DEBUG_VALUE: ncat:buflen <- 157
.Ltmp0:
	.loc	3 47 3 prologue_end             # third_party/icu/source/common/locdspnm.cpp:47:3
...
	movl	$16, (%rax)
.Ltmp1:
	.p2align	4, 0x90
.LBB0_3:                                # =>This Inner Loop Header: Depth=1
	#DEBUG_VALUE: ncat:buflen <- 157
	.loc	3 0 3 is_stmt 0                 # third_party/icu/source/common/locdspnm.cpp:0:3
	jmp	.LBB0_3
.Lfunc_end0:
	.size	_ZL4ncatPcjz, .Lfunc_end0-_ZL4ncatPcjz
	.cfi_endproc

The function buildLocationList : https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1638 is called and it adds two entries to DebugLoc with StartLabel and Label pairs as follows:

1. .Lfunc_begin0, .Ltmp1
2. .Ltmp1, .Lfunc_end0

The size of DebugLoc is 2 but these two ranges are merged into one range with MergeRanges here: https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1733

There is now one entry in DebugLoc with full function scope .Lfunc_begin0, .Lfunc_end0

whose StartLabel is the start of the function and the EndLabel is the function end.

There is exactly one entry in the Location List DebugLoc in function buildLocationList. Before returning, there is a check to see if this one entry is valid throughout the scope of the function: https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1744 This returns true in this case.

This leads to an optimization to use DW_AT_const_value instead of DW_AT_location and the dwarf standard here seems to suggest this : http://dwarfstd.org/ShowIssue.php?issue=161109.2

This optimization is triggered right here: https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1841

At this point isValidSingleLocation is the return value of buildLocationList and when true does not create a .debug_loc section but instead creates a DW_AT_const_value.

Now, I tried to force a .debug_loc for this by simply making the value of isValidSingleLocation false always and the .debug_loc list shows up as expected. Diffing the asm without and with .debug_loc, the asm differs exactly like this :

Without debug_loc	With debug_loc
	.section .debug_loc
	...
...	...
.byte 28 # DW_AT_const_value	.byte 2 # DW_AT_location
.byte 15 # DW_FORM_udata	.byte 23 # DW_FORM_sec_offset

To summarize, it seems like DW_AT_const_value can be used instead of DW_AT_location under certain conditions and that's what seems to be happening here. Please correct me if this is a wrong assumption.

This is for the default case.

Now, let's look at what happens with bbsections, first without this patch. With bb sections, buildLocationList is called again. Here is the ASM with basic block sections:

	.text
	.file	"locdspnm.cpp"
	.type	_ZL4ncatPcjz,@function
_ZL4ncatPcjz:                           # @_ZL4ncatPcjz
.Lfunc_begin0:
	.loc	3 37 0                          # third_party/icu/source/common/locdspnm.cpp:37:0
	.cfi_startproc
# %bb.0:                                # %.critedge3
...
	je	_ZL4ncatPcjz.2
	jmp	_ZL4ncatPcjz.1
	.cfi_endproc
	.section	.text,"ax",@progbits,unique,1
_ZL4ncatPcjz.1:                         # %.critedge3
	.cfi_startproc
	.cfi_def_cfa %rsp, 64
...
	jmp	_ZL4ncatPcjz.2
.LBB_END0_1:
	.size	_ZL4ncatPcjz.1, .LBB_END0_1-_ZL4ncatPcjz.1
	.cfi_endproc
	.section	.text,"ax",@progbits,unique,2
_ZL4ncatPcjz.2:                         # %.critedge3
	.cfi_startproc
	.cfi_def_cfa %rsp, 64
...
	leaq	-128(%rsp), %rax
	#DEBUG_VALUE: ncat:buflen <- 157
.Ltmp0:
	.loc	3 47 3 prologue_end             # third_party/icu/source/common/locdspnm.cpp:47:3
...
	jmp	_ZL4ncatPcjz.3
.Ltmp1:
.LBB_END0_2:
	.size	_ZL4ncatPcjz.2, .LBB_END0_2-_ZL4ncatPcjz.2
	.cfi_endproc
	.p2align	4, 0x90
	.section	.text,"ax",@progbits,unique,3
_ZL4ncatPcjz.3:                         # =>This Inner Loop Header: Depth=1
	.cfi_startproc
	.cfi_def_cfa %rsp, 64
	#DEBUG_VALUE: ncat:buflen <- 157
	.loc	3 0 3 is_stmt 0                 # third_party/icu/source/common/locdspnm.cpp:0:3
	jmp	_ZL4ncatPcjz.3
.LBB_END0_3:
	.size	_ZL4ncatPcjz.3, .LBB_END0_3-_ZL4ncatPcjz.3
	.cfi_endproc
	.text
.Lfunc_end0:
	.size	_ZL4ncatPcjz, .Lfunc_end0-_ZL4ncatPcjz

Again, buildLocationList at https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1638 adds two entries but their start and end label pairs are now:

1. .Lfunc_begin0, .Ltmp1 // This is the same as the default case.
2. _ZL4ncatPcjz.3, .LBB_END0_3 // Note that the start label is the start of the next section and the end label is the end of the next section

Now, merge ranges will not merge these two into a single range as .Ltmp1 is not equal to _ZL4ncatPcjz3.

So, buildLocationList returns false at : https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1741

That is, the optimization to not make a .debug_loc is not applicable in this case as that only holds if there is a valid single location here : https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1841

So, a loc list is constructed but without this patch this triggers a problem at : https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DebugLocStream.h#L99

This is because the startSym and the endSym have to be in the same section. .Ltmp1 and .Lfunc_begin0 are in different sections. The assembler will complain if we try to assemble this.

So, what triggered this problem? LabelsBeforeInsn[insn] cannot be loosely assigned to be the start of the function with basic block sections if the instruction and the start of the function are in different sections.

Now, this patch fixes it by making LabelsBeforeInsn to be the start of the section. So, the two entries in DebugLoc would become:

1. _ZL4ncatPcjz.2, .Ltmp1
2. _ZL4ncatPcjz.3, .Lfunc_end0

This is good, but we are missing the entries corresponding to (.Lfunc_begin0 ... _ZL4ncatPcjz.2) which denote the 2 basic blocks before. We could handle this if we extend LabelsBeforeInsn to have multiple values in the case of basic block sections.

The way this patch exists, it loses the debug_loc fidelity as it does not capture the other blocks.

Thoughts?

Apologies for the very long reply!

Diffing the asm by forcing a debug_loc entry,

Not sure what you mean by this ^ could you explain further?

what happens here is that a DW_AT_location is replaced with a DW_AT_const_value. I don't understand this too well but this seems like an optimization to me.

Does this make sense?

I'm still a bit confused. I think if non-bb-sections doesn't need a location list, then bb-sections shouldn't either. Perhaps that issue should be fixed first, if it's an issue?

In any case/any order - perhaps this patch is still reflective of a bug that exists even in this ^ issue is fixed, but maybe it's that the test case isn't sufficient to demonstrate the remaining bug - perhaps the test case could be complicated a bit further to ensure it's not testing a behavior that shouldn't be happening for other reasons anyway?

[tmsriram]

@amharc

When basic block sections are on and the debug_loc entries span multiple sections, emit entries for each section. This keeps the fidelity and there is no loss of debug information.

To summarize, by default there is only one entry which is collapsed into a DW_AT_const_value.

WIth basic block sections, this one entry spans multiple sections and must be split into an entry for each section.

[dblaikie]

In D85085#2225420, @tmsriram wrote:

@amharc

When basic block sections are on and the debug_loc entries span multiple sections, emit entries for each section. This keeps the fidelity and there is no loss of debug information.

To summarize, by default there is only one entry which is collapsed into a DW_AT_const_value.

WIth basic block sections, this one entry spans multiple sections and must be split into an entry for each section.

if the location is valid for the entire range of the enclosing scope, it could still be described with a single DW_AT_const_value, I think?

DWARFv5 spec: "[single (non-loclist) location descriptions] are sufficient for describing the location of any object as long as its lifetime is either static or the same as the lexical block that owns it, and it does not move during its lifetime"

[tmsriram]

In D85085#2225425, @dblaikie wrote:

In D85085#2225420, @tmsriram wrote:

@amharc

When basic block sections are on and the debug_loc entries span multiple sections, emit entries for each section. This keeps the fidelity and there is no loss of debug information.

To summarize, by default there is only one entry which is collapsed into a DW_AT_const_value.

WIth basic block sections, this one entry spans multiple sections and must be split into an entry for each section.

if the location is valid for the entire range of the enclosing scope, it could still be described with a single DW_AT_const_value, I think?

DWARFv5 spec: "[single (non-loclist) location descriptions] are sufficient for describing the location of any object as long as its lifetime is either static or the same as the lexical block that owns it, and it does not move during its lifetime"

I am not sure I fully understood what you meant here, could you please elaborate? With sections, since the individual sections could be separated and can become disjoint you need one per section right? Maybe you meant something else.

[dblaikie]

In D85085#2225426, @tmsriram wrote:

In D85085#2225425, @dblaikie wrote:

In D85085#2225420, @tmsriram wrote:

@amharc

When basic block sections are on and the debug_loc entries span multiple sections, emit entries for each section. This keeps the fidelity and there is no loss of debug information.

To summarize, by default there is only one entry which is collapsed into a DW_AT_const_value.

WIth basic block sections, this one entry spans multiple sections and must be split into an entry for each section.

if the location is valid for the entire range of the enclosing scope, it could still be described with a single DW_AT_const_value, I think?

DWARFv5 spec: "[single (non-loclist) location descriptions] are sufficient for describing the location of any object as long as its lifetime is either static or the same as the lexical block that owns it, and it does not move during its lifetime"

I am not sure I fully understood what you meant here, could you please elaborate? With sections, since the individual sections could be separated and can become disjoint you need one per section right? Maybe you meant something else.

Ah, sure, sorry - if a variable only has one location, and that location is valid for the entire range of its enclosing scope (even if that enclosing scope is fragmented/uses ranges (rather than high/low) to describe its valid set of addresses) then the variable can use a simple/single location description.

Take for example this code:

void f1();
void f2() {
  {
    int i = 7;
    f1();
    f1();
  }
  f1();
}

compiled to LLVM IR with optimizations, then manually modified to reorder the 2nd and 3rd calls to f1 (to cause the valid set of addresses for the explicit lexical scope that contains i to become fragmented, and need a DW_AT_ranges to describe its valid addresses (the first f1 call, then the interleaved (originally 3rd, now second) f1 call which isn't part of tnhe scope, then more scope with the last call to f1)), this produces the following DWARF:

DW_TAG_subprogram
  DW_AT_low_pc    (0x0000000000000000)
  DW_AT_high_pc   (0x0000000000000011)
  DW_AT_name      ("f2")
  ...

  DW_TAG_lexical_block
    DW_AT_ranges  (0x00000000
      [0x0000000000000001, 0x0000000000000006)
      [0x000000000000000b, 0x0000000000000011))

    DW_TAG_variable
      DW_AT_const_value   (7)
      DW_AT_name  ("i")
      ...
    NULL

Despite 'i' having a disjoint valid range (it's only valid in the [1, 6)+[b, 11) instructions) - it doesn't need to use a loclist to describe its location, because its location is the same for the entire life of its enclosing scope, which is the implicit range that the location is valid over if no location list is used.

[tmsriram]

Redo the patch according to @dblaikie 's observation that loc list need not be used even with sections.

This change checks if debug loc entries can be merged to form a larger range even if they are split across sections. The test checks that a single range is collapsed into DW_AT_const_value both with and without sections.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1779–1782

This description sounds like it might merge across BB sections even if the location doesn't span the whole outer range.

eg: given a scope like [x, x+5) [y, y+3) and a location range of [x+3, x+5) [y, y+2) it sounds like this code might produce a single [x+3, y+2) range? That would be incorrect - since there's no ordering between the x and y ranges - so there's no way to cross the gap like that.

Could you include some test cases with interesting ranges like this to check that the DWARF is correct there?

[tmsriram]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1779–1782

Should the location range span the entire function? Could it be fully covering a subset of sections? Test cases for this seem very hard, even the one attached is reduced from a larger failure. Any pointers here? Thanks.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1779–1782

llvm-dwarfdump some examples with non-trivial locations (I'll provide some suggestions on how to create non-trivial locations shortly) - if the location doesn't use a location list (ie: it uses a single location that spans the entire enclosing scope) then it should continue to use a single location with BB sections - because the implied range is "whatever addresses the enclosing scope says" - which will use ranges or high/low depending on whether it's disjoint or crosses BB-sections boundaries, etc)

If the location isn't a single location without BB-sections, then it can't be a single location with BB-sections. And any ranges that that location uses should be fragmented in the same way that DW_AT_ranges/high/low would be fragmented.

Would it be possible to use the same logic that handles ranges to handle these location ranges too? Presumably there's some code that transforms a begin/end pair into fragments when that pair crosses BB-section boundaries? So perhaps all the merging can be done here, then it can be checked to see if it's a valid single location (there's got to be some code somewhere that checks whether the final ranges cover all the enclosing scope ranges and uses the same location -> go to single location) and then fragmented if it crosses BB-section boundaries?

Some examples to consider:

void f1();
int f2();
extern bool b;
extern int x;
void test() {
  {
    // constant value with a single location description
    // Shouldn't change with BB-sections
    int i = 7;
    f1();
  } 
  int tmp = f2();
  { 
    // non-constant value with a single location description
    // Shouldn't change with BB-sections
    int i = tmp;
    f1();
    x = i;
  }
  { 
    // constant value through partial scope, but crossing a BB boundary
    // Should change with BB sections, I think - the address range for the
    // constant value will be fragmented.
    int i = 7;
    f1();
    if (b)
      f1();
    i = f2();
    f1();
  } 
  { 
    // constant value through partial scope, no BB boundary
    // Shouldn't change with BB-sections
    int i = 7;
    f1();
    i = f2();
    f1();
  } 
  { 
    // constant value through whole scope, including BB crossing - but LLVM puts
    // this in a location list unnecessarily.
    // You could fix the underlying LLVM bug (would be much appreciated) & make
    // this use a single location description - then with BB sections it should
    // still use a single location description.
    // If this bug remains, then the BB-sections code would need to fragment the
    // location list. (this'll make BB-sections DWARF size overhead higher than
    // it would otherwise be if the bug was fixed).
    int i = 7;
    f1();
    if (b)
      f1();
  } 
}

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1779–1782

Handily enough, this last case got fixed to use a constant location rather than a loclist recently, so this:

{
  int i = 7;
  f1();
  if (b)
    f1();
}

produces this DWARF (without bb sections - and should continue to produce the same DWARF with bb-sections)

DW_TAG_lexical_block
  DW_AT_low_pc  (0x0000000000000044)
  DW_AT_high_pc (0x0000000000000058)

  DW_TAG_variable
    DW_AT_const_value   (7)
    DW_AT_name  ("i")
    DW_AT_decl_file     ("/usr/local/google/home/blaikie/dev/scratch/loc.cpp")
    DW_AT_decl_line     (48)
    DW_AT_type  (0x00000192 "int")

[MaskRay]

llvm/test/DebugInfo/X86/basic-block-sections-debug-loc.ll

32

The attributes can be cleaned up a bit. For example "use-soft-float" defaults to false so it is not needed.

[tmsriram]

Address reviewer comments on adding various test cases to make sure loc lists are generated the same way with and without basic block sections except when the ranges cross section boundaries.

Disabled the temporary fix applied in D87787.

I have mainly added two things in the patch:

• Explicitly check if the ranges can be merged into one with sections and this is similar to how MergeRanges works without sections.
• Split the ranges across sections when a range spans sections. This happens specifically when an argument is used in a non-entry basic block, added a test for it.

Added individual tests for all the different cases pointed out by dblaikie@

[dblaikie]

Thanks for this - tests generally look great. Code mostly makes sense to me (that's on me, not you) - couple of minor quibbles with comment wording, but nothing major I think.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1744–1746

Presumably this happens also when StartLabel isn't the function begin symbol - but could be inside but not at the start of the first BB, or in some other BB - but where the end is in some other BB?
(the test cases are all simple enough/happen to have the interesting location range start in the first BB, but it's not a requirement)

1786–1787

Drop the else after return, ie:

if (x)
  return
if (hasBBSections()) {
  ...

Might also be worth inverting a bunch of these tests to reduce indentation/early return, eg:

if (!isSafeForSingleLocation)
  return false;
if (!validThroughout)
  return false;
if (size == 1)
  return true;
if (hasBBSections())
  return false;
// ...
MachineBasicBlock *RangeMBB = nullptr;
...

1788

presumably this isn't only about const_values - but any location (including non-const values) that's valid across the whole scope?

llvm/test/DebugInfo/X86/basic-block-sections-debug-loc-split-range.ll

18–19

might be worth a few more words, maybe the original source/description of the original test case - so this one can be read more independently (still useful to reference where it came from, though) - otherwise it's hard to know why that test + the transformation should have the location this test is testing for

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-2.ll

14

probably SECTIONS-NEXT

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-3.ll

13–17

I /think/ this test might be able to be made a bit more resilient to future unrelated DWARF changes (such as adding/removing/renaming unrelated attributes) with something like:

CHECK-NEXT: ... reg3
CHECK-NEXT: DW_AT
CHECK-NOT: DW_TAG
CHECK: _name ("i")

I'm not 100% sure that CHECK will match both in the case when there's a DW_AT_name immediately after the DW_TAG_location, and when there's some other attributes between location and name.

We don't always go to this much bother - but at least you can probably remove the decl file/line/type - the name seems enough to verify that the test hasn't accidentally started matching the location of some other variable like 'tmp'

(consider this sort of change/design aspect for the other test cases too)

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-5.ll

14

Guess this should probably be SECTIONS-NEXT to continue matching this location list/not accidentally skip over some other location

I take it there are 3 chunks because there are 3 BBs this constant value is live over (the initial BB, the if, and then a fragment of the last/returning BB (during the execution of the f2 call, but before the result has been assigned that will overwrite the constant value)

[tmsriram]

Address reviewer comments:

• Code refactoring.
• Test case cleanup.

[tmsriram]

In D85085#2708898, @dblaikie wrote:

Thanks for this - tests generally look great. Code mostly makes sense to me (that's on me, not you) - couple of minor quibbles with comment wording, but nothing major I think.

Thanks for reviewing this and providing the test cases. Took me quite a while to understand how to fix this!

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1744–1746

I may have misunderstood your question but I am assuming you are asking if StartLabel and Instr can be in different sections when StartLabel is not function begin?

This is a special case, mentioned in DebugHandlerBase.cpp in function "beginFunction". Quoting : "The first mention of a function argument gets the CurrentFnBegin label, so arguments are visible when breaking at function entry."

This means the Debug Instr and function begin could be in different sections which was the original problem to begin with. We make sure that we update the label each time we cross a section boundary otherwise, so an instr and a label being in different sections apart from this case is not possible. In function "endBasicBlock" PrevLabel is explicitly set to nullptr. This will force an emission of a temp label (or reuse the section's begin label) in the same section as the instruction for which a LabelsBeforeInsn is desired.

1786–1787

Apologies for not refactoring.

1788

Right, reworded to say it is about merging ranges.

llvm/test/DebugInfo/X86/basic-block-sections-debug-loc-split-range.ll

18–19

Understood, I added some more text describing what this test does. The source is not available because the IR was obtained using a reducer from a larger failing compile.

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-3.ll

13–17

I removed file, line and type. Seems like the other stuff is useful but if you think I should prune more, please lmk.

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-5.ll

14

Fixed and you are right about the chunks. The extra chunks for sections because there are the 2 additional basic blocks in different sections which cannot be collapsed.

[dblaikie]

[commented on the wrong review - sorry]

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1744–1746

Stared at this a few times & still a bit confused, sorry.

Hmm, so there's some code somewhere else that handles the normal case of fragmenting basic blocks? Where is that code? (maybe there's a chance some of the logic here could be shared with that code) - what if that code elsewhere was removed, and this code were simplified (removing the "StartLabel == function begin" check) and became the only place location ranges were fragmented for bb sections? Would that be simpler?

This code here is specifically to patch up some strangeness in DebugHandlerBase.cpp - that strangeness is that certain parameter locations have their starting location drawn back up to the start of the function?

OK, so a few things - I'm guessing most of the tests I wrote don't cover this particular case? They do cover the general case of multi-basic block scope locations being fragmented by BB sections (& also the case of multi-basic block but not full-scope locations being broken up by bb sections). Do any of the tests pass/fail with this particular change applied or not?

Then, maybe it's easier for me to understand by looking at a particular test case that this code addresses an issue in - which test case would that be?

1750

Hmm - using "I" for this sort of implies it's an iterator, but it isn't (if it was, we could increment it - but if we try to increment this pointer presumably we end up with garbage/random things that are in memory, because it's a linked list) - maybe if this was Asm->MF->begin() instead of front?

(also the name's still being flagged by the style checker - so would be good to rename it to something that matches the LLVM naming conventions)

It might be possible this could/should be a range-based-for loop?

for (MachineBasicBlock &MBB : *Asm->MF) {
}

And the checks like MBB_I != &Asm->MF->front() could be tested with &MBB != &Asm->MF->front()?

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-3.ll

13–17

Looks good - if you like, the test can be made more robust (in case new unrelated attributes are added in the future) by using CHECK-NOT: DW_TAG between attributes rather than using CHECK-NEXT (that way you'd still be checking that the attributes are all associated with the same tag - but allowing the possibility of other attributes).

It doesn't make the test resilient to changes in the order of attributes (you might be able to do that with something like:

CHECK: DW_TAG_variable
CHECK-DAG: DW_AT_location
CHECK-DAG: DW_AT_name
CHECK: DW_TAG

But if you do that, I'm not sure if the CHECK-NEXT needed for the DW_AT_location would work (not sure how it interacts with CHECK-DAG))

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-5.ll

14

Might be worth a comment in the test explaining this?

Maybe updating/changing/or moving the comment from the C source below and putting it up somewhere to say "When a location list must be used (because the location isn't valid through the entire enclosing scope - the assignment to 'i' towards the end truncates the 7 constant value location) - without basic block sections a single entry location list would be used. With basic block sections that one location list needs to be broken up to describe the separate address ranges in each section" or the like.

[tmsriram]

Address reviewer comments:

• Convert while(true) to for (...)
• Fix tests
• Provide more info on how loc list ranges are formed.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1744–1746

Stared at this a few times & still a bit confused, sorry.

Hmm, so there's some code somewhere else that handles the normal case of fragmenting basic blocks? Where is that code? (maybe there's a chance some of the logic here could be shared with that code) - what if that code elsewhere was removed, and this code were simplified (removing the "StartLabel == function begin" check) and became the only place location ranges were fragmented for bb sections? Would that be simpler?

https://github.com/llvm/llvm-project/blob/main/llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp#L382

Please look at beginInstruction and endInstruction in DebugHandlerBase.cpp. LabelsBeforeInsn and LabelsAfterInsn are start and end label for each location list entry which will be either merged or kept unsplit in buildLocationList. LabelsBeforeInsn and LabelsAfterInsn are set here and these get a new label everytime we cross a basic block boundary via a jmp insn etc. This is true with or without sections.

Every jmp instruction and call insn for example will split the range. This would later be coalesced if possible in buildLocationList. endInstruction() in DebugHandlerBase.cpp is where the fragmenting happens in general, with or without basic block sections.

There is no code elsewhere that does anything specific for basic block sections with regards to location list. The real issue is with the coalescing of ranges which happens here for both sections and no-sections. With sections, this one assumption about the use starting from an intermediate basic block needs special handling.

This code here is specifically to patch up some strangeness in DebugHandlerBase.cpp - that strangeness is that certain parameter locations have their starting location drawn back up to the start of the function?

Correct, that one use case where the parameter is used at a basic block other than the entry but is defined from the start. An alternate way is to repeat the entry for this parameter multiple times pretending it was used in the entry too but that is a lot of code to do it. It also unnecessarily complicates the case for compiling without basic block sections. Please note that if we do this, we would split up the range first and then merge it when building without sections.

OK, so a few things - I'm guessing most of the tests I wrote don't cover this particular case? They do cover the general case of multi-basic block scope locations being fragmented by BB sections (& also the case of multi-basic block but not full-scope locations being broken up by bb sections). Do any of the tests pass/fail with this particular change applied or not?

I added a specific test for this, basic-block-setions-debug-loc-split-range.ll. That test will exercise this code to split the range as the first use is not in the entry basic block. A location list will be generated for this as the two uses of the value "buflen" in this test are different, 157 amd 159.

The original test which prompted the whole cleanup, basic-block-sections-debug-loc.ll will also exercise this code. Here, it will be merged into a const_value 157 as both uses of the value of buflen are the same. This means the range will first be split with basic block sections and then merged again later.

1750

Nice catch!

[tmsriram]

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-3.ll

13–17

Ack, My different incantations seem to be less stable than this one. If you feel strongly about this, I can give this another pass.

[dblaikie]

Thanks for all your explanations/help understanding this. I think it's good to go.

[thakis]

This seems to break tests on mac and win, eg http://45.33.8.238/macm1/10314/step_11.txt

Please take a look and revert for now if it takes a while to fix.

[ahatanak]

Tests are failing here too:
http://lab.llvm.org:8080/green/job/clang-stage1-RA/21182/consoleFull#-706149783d489585b-5106-414a-ac11-3ff90657619c

[thakis]

reverted in 192b4141f0d74dd08a4eacf2184a6881906993ed for now

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

for (auto &MI : MBB) {
         NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
                            HI.TimerGroupDescription, TimePassesIsEnabled);
         HI.Handler->endInstruction();
       }
     }
 
     // We must emit temporary symbol for the end of this basic block, if either
     // we have BBLabels enabled or if this basic blocks marks the end of a
-    // section (except the section containing the entry basic block as the end
-    // symbol for that section is CurrentFnEnd).
+    // section.
     if (MF->hasBBLabels() ||
-        (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection() &&
-         !MBB.sameSection(&MF->front())))
+        (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection()))
       OutStreamer->emitLabel(MBB.getEndSymbol());
 
     if (MBB.isEndSection()) {
       // The size directive for the section containing the entry block is
       // handled separately by the function section.
       if (!MBB.sameSection(&MF->front())) {
         if (MAI->hasDotTypeDotSizeDirective()) {
           // Emit the size directive for the basic block section.

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

for (const auto &I : DbgValues) {
     // so arguments are visible when breaking at function entry.
     //
     // We do not change the label for values that are described by registers,
     // as that could place them above their defining instructions. We should
     // ideally not change the labels for constant debug values either, since
     // doing that violates the ranges that are calculated in the history map.
     // However, we currently do not emit debug values for constant arguments
     // directly at the start of the function, so this code is still useful.
-    // FIXME: If the first mention of an argument is in a unique section basic
-    // block, we cannot always assign the CurrentFnBeginLabel as it lies in a
-    // different section.  Temporarily, we disable generating loc list
-    // information or DW_AT_const_value when the block is in a different
-    // section.
     const DILocalVariable *DIVar =
         Entries.front().getInstr()->getDebugVariable();
     if (DIVar->isParameter() &&
-        getDISubprogram(DIVar->getScope())->describes(&MF->getFunction()) &&
-        Entries.front().getInstr()->getParent()->sameSection(&MF->front())) {
+        getDISubprogram(DIVar->getScope())->describes(&MF->getFunction())) {
       if (!IsDescribedByReg(Entries.front().getInstr()))
         LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin();
       if (Entries.front().getInstr()->getDebugExpression()->isFragment()) {
         // Mark all non-overlapping initial fragments.
         for (auto I = Entries.begin(); I != Entries.end(); ++I) {
           if (!I->isDbgValue())
             continue;
           const DIExpression *Fragment = I->getInstr()->getDebugExpression();
void DebugHandlerBase::endInstruction() {
   // generate code.
   if (!CurMI->isMetaInstruction()) {
     PrevLabel = nullptr;
     PrevInstBB = CurMI->getParent();
   }
 
   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
       LabelsAfterInsn.find(CurMI);
-  CurMI = nullptr;
 
   // No label needed.
-  if (I == LabelsAfterInsn.end())
-    return;
-
-  // Label already assigned.
-  if (I->second)
+  if (I == LabelsAfterInsn.end() || I->second) {
+    CurMI = nullptr;
     return;
+  }
 
-  // We need a label after this instruction.
-  if (!PrevLabel) {
+  // We need a label after this instruction.  With basic block sections, just
+  // use the end symbol of the section if this is the last instruction of the
+  // section.  This reduces the need for an additional label and also helps
+  // merging ranges.
+  if (CurMI->getParent()->isEndSection() && CurMI->getNextNode() == nullptr) {
+    PrevLabel = CurMI->getParent()->getEndSymbol();
+  } else if (!PrevLabel) {
     PrevLabel = MMI->getContext().createTempSymbol();
     Asm->OutStreamer->emitLabel(PrevLabel);
   }
   I->second = PrevLabel;
+  CurMI = nullptr;
 }
 
 void DebugHandlerBase::endFunction(const MachineFunction *MF) {
   if (Asm && hasDebugInfo(MMI, MF))
     endFunctionImpl(MF);
   DbgValues.clear();
   DbgLabels.clear();
   LabelsBeforeInsn.clear();

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (auto EB = Entries.begin(), EI = EB, EE = Entries.end(); EI != EE; ++EI) {
     if (StartLabel == EndLabel) {
       LLVM_DEBUG(dbgs() << "Omitting location list entry with empty range.\n");
       continue;
     }
 
     SmallVector<DbgValueLoc, 4> Values;
     for (auto &R : OpenRanges)
       Values.push_back(R.second);
+
+    // With Basic block sections, it is posssible that the StartLabel and the
+    // Instr are not in the same section.  This happens when the StartLabel is
+    // the function begin label and the dbg value appears in a basic block
+    // that is not the entry.  In this case, the range needs to be split to
+    // span each individual section in the range from StartLabel to EndLabel.
+    if (Asm->MF->hasBBSections() && StartLabel == Asm->getFunctionBegin() &&
+        !Instr->getParent()->sameSection(&Asm->MF->front())) {
+      const MCSymbol *BeginSectionLabel = StartLabel;
+
+      for (const MachineBasicBlock &MBB : *Asm->MF) {
+        if (MBB.isBeginSection() && &MBB != &Asm->MF->front())
+          BeginSectionLabel = MBB.getSymbol();
+
+        if (MBB.sameSection(Instr->getParent())) {
+          DebugLoc.emplace_back(BeginSectionLabel, EndLabel, Values);
+          break;
+        }
+        if (MBB.isEndSection())
+          DebugLoc.emplace_back(BeginSectionLabel, MBB.getEndSymbol(),
+                                Values);
+      }
+    } else {
       DebugLoc.emplace_back(StartLabel, EndLabel, Values);
+    }
 
     // Attempt to coalesce the ranges of two otherwise identical
     // DebugLocEntries.
     auto CurEntry = DebugLoc.rbegin();
     LLVM_DEBUG({
       dbgs() << CurEntry->getValues().size() << " Values:\n";
       for (auto &Value : CurEntry->getValues())
         Value.dump();
       dbgs() << "-----\n";
     });
 
     auto PrevEntry = std::next(CurEntry);
     if (PrevEntry != DebugLoc.rend() && PrevEntry->MergeRanges(*CurEntry))
       DebugLoc.pop_back();
   }
 
-  return DebugLoc.size() == 1 && isSafeForSingleLocation &&
-         validThroughout(LScopes, StartDebugMI, EndMI, getInstOrdering());
+  if (!isSafeForSingleLocation ||
+      !validThroughout(LScopes, StartDebugMI, EndMI, getInstOrdering()))
+    return false;
+
+  if (DebugLoc.size() == 1)
+    return true;
+
+  if (!Asm->MF->hasBBSections())
+    return false;
+
+  // Check here to see if loclist can be merged into a single range. If not,
+  // we must keep the split loclists per section.  This does exactly what
+  // MergeRanges does without sections.  We don't actually merge the ranges
+  // as the split ranges must be kept intact if this cannot be collapsed
+  // into a single range.
+  const MachineBasicBlock *RangeMBB = nullptr;
+  if (DebugLoc[0].getBeginSym() == Asm->getFunctionBegin())
+    RangeMBB = &Asm->MF->front();
+  else
+    RangeMBB = Entries.begin()->getInstr()->getParent();
+  auto *CurEntry = DebugLoc.begin();
+  auto *NextEntry = std::next(CurEntry);
+  while (NextEntry != DebugLoc.end()) {
+    // Get the last machine basic block of this section.
+    while (!RangeMBB->isEndSection())
+      RangeMBB = RangeMBB->getNextNode();
+    if (!RangeMBB->getNextNode())
+      return false;
+    // CurEntry should end the current section and NextEntry should start
+    // the next section and the Values must match for these two ranges to be
+    // merged.
+    if (CurEntry->getEndSym() != RangeMBB->getEndSymbol() ||
+        NextEntry->getBeginSym() != RangeMBB->getNextNode()->getSymbol() ||
+        CurEntry->getValues() != NextEntry->getValues())
+      return false;
+    RangeMBB = RangeMBB->getNextNode();
+    CurEntry = NextEntry;
+    NextEntry = std::next(CurEntry);
+  }
+  return true;
 }
 
 DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU,
                                             LexicalScope &Scope,
                                             const DINode *Node,
                                             const DILocation *Location,
                                             const MCSymbol *Sym) {
   ensureAbstractEntityIsCreatedIfScoped(TheCU, Node, Scope.getScopeNode());

llvm/test/DebugInfo/X86/basic-block-sections-debug-loc-const-value-1.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_const_value (7)
+; CHECK-NEXT: DW_AT_name  ("i")
+
+; Source to generate the IR below:
+; void f1();
+; extern bool b;
+; extern int x;
+; void test() {
+;     // i is a const throughout the whole scope and should
+;     // use DW_AT_const_value
+;     int i = 7;
+;     f1();
+;     if (b)
+;       f1();
+; }
+;
+; $ clang++ -S -emit-llvm -g -O2 simple.cc
+;
+
+@b = external dso_local local_unnamed_addr global i8, align 1
+
+define dso_local void @_Z4testv() local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 7, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !14
+  %0 = load i8, i8* @b, align 1, !dbg !15, !tbaa !17, !range !21
+  %tobool.not = icmp eq i8 %0, 0, !dbg !15
+  br i1 %tobool.not, label %if.end, label %if.then, !dbg !22
+
+if.then:                                          ; preds = %entry
+  tail call void @_Z2f1v(), !dbg !23
+  br label %if.end, !dbg !23
+
+if.end:                                           ; preds = %if.then, %entry
+  ret void, !dbg !24
+}
+
+declare !dbg !25 dso_local void @_Z2f1v() local_unnamed_addr
+
+declare void @llvm.dbg.value(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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "simple.cc", directory: "/code")
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)"}
+!7 = distinct !DISubprogram(name: "test", linkageName: "_Z4testv", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 14, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 15, column: 5, scope: !7)
+!15 = !DILocation(line: 16, column: 9, scope: !16)
+!16 = distinct !DILexicalBlock(scope: !7, file: !1, line: 16, column: 9)
+!17 = !{!18, !18, i64 0}
+!18 = !{!"bool", !19, i64 0}
+!19 = !{!"omnipotent char", !20, i64 0}
+!20 = !{!"Simple C++ TBAA"}
+!21 = !{i8 0, i8 2}
+!22 = !DILocation(line: 16, column: 9, scope: !7)
+!23 = !DILocation(line: 17, column: 7, scope: !16)
+!24 = !DILocation(line: 18, column: 1, scope: !7)
+!25 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)

llvm/test/DebugInfo/X86/basic-block-sections-debug-loc-const-value-2.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_const_value (7)
+; CHECK-NEXT: DW_AT_name  ("i")
+
+
+; void f1();
+; void test() {
+;   // constant value with a single location description
+;   // Shouldn't change with BB-sections
+;   int i = 7;
+;   f1();
+; }
+; $ clang++ -S -emit-llvm -g -O2 const_value_2.cc
+
+
+
+define dso_local void @_Z4testv() local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 7, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !14
+  ret void, !dbg !15
+}
+
+declare !dbg !16 dso_local void @_Z2f1v() local_unnamed_addr
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "const_value_2.cc", directory: "/code")
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)"}
+!7 = distinct !DISubprogram(name: "test", linkageName: "_Z4testv", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 8, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 9, column: 3, scope: !7)
+!15 = !DILocation(line: 10, column: 1, scope: !7)
+!16 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)

llvm/test/DebugInfo/X86/basic-block-sections-debug-loc-split-range.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+
+; CHECK:         DW_AT_location
+; CHECK-NEXT:    [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_constu 0x9d, DW_OP_stack_value
+; SECTIONS:      [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_constu 0x9d, DW_OP_stack_value
+; SECTIONS-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_constu 0x9d, DW_OP_stack_value
+; CHECK-NEXT:    [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_constu 0x9f, DW_OP_stack_value
+; CHECK-NEXT:    DW_AT_name ("buflen")
+
+; This IR is generated by copying basic-block-sections-debug-loc.ll and
+; manually adding one more dbg value in block 2 and modifying the value.
+; With just one dbg value a DW_AT_const_val would be emitted, so we add
+; one more dbg value with a different value to split the ranges.
+; The extra dbg value is added to split the range and to check if the
+; ranges are split correctly with sections.  With basic block sections,
+; the dbg value 157 (0x9d) gets split into one more range.
+
+define dso_local void @_ZL4ncatPcjz(i8* %0, i32 %1, ...) unnamed_addr  align 32 !dbg !22 {
+.critedge3:
+  call void @llvm.dbg.value(metadata i32 157, metadata !27, metadata !DIExpression()), !dbg !46
+  call void @llvm.va_start(i8* nonnull undef), !dbg !47
+  br label %2
+
+2:                                                ; preds = %2, %.critedge3
+  call void @llvm.dbg.value(metadata i32 159, metadata !27, metadata !DIExpression()), !dbg !46
+  br label %2
+}
+
+declare void @llvm.va_start(i8*)
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!20, !21}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, retainedTypes: !2)
+!1 = !DIFile(filename: "bug.cpp", directory: "/proc/self/cwd")
+!2 = !{!3, !6, !9, !10, !11, !13, !16, !17, !15}
+!3 = !DIDerivedType(tag: DW_TAG_typedef, name: "int32_t", file: !4, line: 38, baseType: !5)
+!4 = !DIFile(filename: "stdint.h", directory: "/proc/self/cwd")
+!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!6 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!7 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !8)
+!8 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_unsigned_char)
+!9 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !8, size: 64)
+!10 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: null, size: 64)
+!11 = !DIDerivedType(tag: DW_TAG_typedef, name: "uint32_t", file: !4, line: 51, baseType: !12)
+!12 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
+!13 = !DIDerivedType(tag: DW_TAG_typedef, name: "UChar", file: !14, line: 372, baseType: !15)
+!14 = !DIFile(filename: "umachine.h", directory: "/proc/self/cwd")
+!15 = !DIBasicType(name: "char16_t", size: 16, encoding: DW_ATE_UTF)
+!16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !3, size: 64)
+!17 = !DIDerivedType(tag: DW_TAG_typedef, name: "UBool", file: !14, line: 261, baseType: !18)
+!18 = !DIDerivedType(tag: DW_TAG_typedef, name: "int8_t", file: !4, line: 36, baseType: !19)
+!19 = !DIBasicType(name: "signed char", size: 8, encoding: DW_ATE_signed_char)
+!20 = !{i32 2, !"Debug Info Version", i32 3}
+!21 = !{i32 7, !"PIC Level", i32 2}
+!22 = distinct !DISubprogram(name: "ncat", linkageName: "_ZL4ncatPcjz", scope: !1, file: !1, line: 37, type: !23, scopeLine: 37, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !25)
+!23 = !DISubroutineType(types: !24)
+!24 = !{!3, !9, !11, null}
+!25 = !{!26, !27, !28, !41, !42, !43, !44}
+!26 = !DILocalVariable(name: "buffer", arg: 1, scope: !22, file: !1, line: 37, type: !9)
+!27 = !DILocalVariable(name: "buflen", arg: 2, scope: !22, file: !1, line: 37, type: !11)
+!28 = !DILocalVariable(name: "args", scope: !22, file: !1, line: 38, type: !29)
+!29 = !DIDerivedType(tag: DW_TAG_typedef, name: "va_list", file: !30, line: 14, baseType: !31)
+!30 = !DIFile(filename: "stdarg.h", directory: "/proc/self/cwd")
+!31 = !DIDerivedType(tag: DW_TAG_typedef, name: "__builtin_va_list", file: !1, line: 38, baseType: !32)
+!32 = !DICompositeType(tag: DW_TAG_array_type, baseType: !33, size: 192, elements: !39)
+!33 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "__va_list_tag", file: !1, line: 38, size: 192, flags: DIFlagTypePassByValue, elements: !34, identifier: "_ZTS13__va_list_tag")
+!34 = !{!35, !36, !37, !38}
+!35 = !DIDerivedType(tag: DW_TAG_member, name: "gp_offset", scope: !33, file: !1, line: 38, baseType: !12, size: 32)
+!36 = !DIDerivedType(tag: DW_TAG_member, name: "fp_offset", scope: !33, file: !1, line: 38, baseType: !12, size: 32, offset: 32)
+!37 = !DIDerivedType(tag: DW_TAG_member, name: "overflow_arg_area", scope: !33, file: !1, line: 38, baseType: !10, size: 64, offset: 64)
+!38 = !DIDerivedType(tag: DW_TAG_member, name: "reg_save_area", scope: !33, file: !1, line: 38, baseType: !10, size: 64, offset: 128)
+!39 = !{!40}
+!40 = !DISubrange(count: 1)
+!41 = !DILocalVariable(name: "str", scope: !22, file: !1, line: 39, type: !9)
+!42 = !DILocalVariable(name: "p", scope: !22, file: !1, line: 40, type: !9)
+!43 = !DILocalVariable(name: "e", scope: !22, file: !1, line: 41, type: !6)
+!44 = !DILocalVariable(name: "c", scope: !45, file: !1, line: 49, type: !8)
+!45 = distinct !DILexicalBlock(scope: !22, file: !1, line: 48, column: 45)
+!46 = !DILocation(line: 0, scope: !22)
+!47 = !DILocation(line: 47, column: 3, scope: !22)

llvm/test/DebugInfo/X86/basic-block-sections-debug-loc.ll

 ;; The dbg value for buflen in the non-entry basic block spans the entire
 ;; function and is emitted as DW_AT_const_value.  Even with basic block
 ;; sections, this can be done as the entire function is represented as ranges.
-;; FIXME:  Basic block sections should have the same behavior as the default.
 
 ; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 ; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
-; RUN: llvm-dwarfdump %t | FileCheck --check-prefix=MISSING %s
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
 
 ; CHECK:      DW_AT_const_value (157)
 ; CHECK-NEXT: DW_AT_name ("buflen")
-; MISSING-NOT:    DW_AT_const_value (157)
 
-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-grtev4-linux-gnu"
+;; We do not have the source to reproduce this as this was IR was obtained
+;; using a reducer from a failing compile.
 
 define dso_local void @_ZL4ncatPcjz(i8* %0, i32 %1, ...) unnamed_addr  align 32 !dbg !22 {
 .critedge3:
   call void @llvm.dbg.value(metadata i32 157, metadata !27, metadata !DIExpression()), !dbg !46
   call void @llvm.va_start(i8* nonnull undef), !dbg !47
   br label %2
 
 2:                                                ; preds = %2, %.critedge3
   br label %2
 }
 
-; Function Attrs: nounwind
-declare void @llvm.va_start(i8*) #1
-
-; Function Attrs: nounwind readnone speculatable willreturn
-declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+declare void @llvm.va_start(i8*)
 
-attributes #1 = { nounwind }
-attributes #2 = { nounwind readnone speculatable willreturn }
+declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!20, !21}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, retainedTypes: !2)
 !1 = !DIFile(filename: "bug.cpp", directory: "/proc/self/cwd")
 !2 = !{!3, !6, !9, !10, !11, !13, !16, !17, !15}
 !3 = !DIDerivedType(tag: DW_TAG_typedef, name: "int32_t", file: !4, line: 38, baseType: !5)

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-1.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_location 
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +9, DW_OP_stack_value
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; CHECK-NEXT: DW_AT_name  ("i")
+
+; Source to generate the IR below:
+; void f1();
+; int f2(int);
+; extern bool b;
+; extern int x;
+; void test() {
+;     // Value is either 7 or 9 so DW_AT_const_value cannot be used and 3 loc
+;     // list entries have to be generated.
+;     int i = 7;
+;     f1();
+;     if (b) {
+;       i += 2;
+;       f2(i);
+;     }
+; }
+; $ clang++ -S -emit-llvm -g -O2 loclist_1.cc
+;
+
+@b = external dso_local local_unnamed_addr global i8, align 1
+
+define dso_local void @_Z4testv() local_unnamed_addr  !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 7, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !14
+  %0 = load i8, i8* @b, align 1, !dbg !15, !tbaa !17, !range !21
+  %tobool.not = icmp eq i8 %0, 0, !dbg !15
+  br i1 %tobool.not, label %if.end, label %if.then, !dbg !22
+
+if.then:                                          ; preds = %entry
+  call void @llvm.dbg.value(metadata i32 9, metadata !11, metadata !DIExpression()), !dbg !13
+  %call = tail call i32 @_Z2f2i(i32 9), !dbg !23
+  br label %if.end, !dbg !25
+
+if.end:                                           ; preds = %if.then, %entry
+  ret void, !dbg !26
+}
+
+declare !dbg !27 dso_local void @_Z2f1v() local_unnamed_addr
+
+declare !dbg !28 dso_local i32 @_Z2f2i(i32) local_unnamed_addr
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "loclist_1.cc", directory: "/code")
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)"}
+!7 = distinct !DISubprogram(name: "test", linkageName: "_Z4testv", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 14, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 15, column: 5, scope: !7)
+!15 = !DILocation(line: 16, column: 9, scope: !16)
+!16 = distinct !DILexicalBlock(scope: !7, file: !1, line: 16, column: 9)
+!17 = !{!18, !18, i64 0}
+!18 = !{!"bool", !19, i64 0}
+!19 = !{!"omnipotent char", !20, i64 0}
+!20 = !{!"Simple C++ TBAA"}
+!21 = !{i8 0, i8 2}
+!22 = !DILocation(line: 16, column: 9, scope: !7)
+!23 = !DILocation(line: 18, column: 7, scope: !24)
+!24 = distinct !DILexicalBlock(scope: !16, file: !1, line: 16, column: 12)
+!25 = !DILocation(line: 19, column: 5, scope: !24)
+!26 = !DILocation(line: 20, column: 1, scope: !7)
+!27 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!28 = !DISubprogram(name: "f2", linkageName: "_Z2f2i", scope: !1, file: !1, line: 2, type: !29, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!29 = !DISubroutineType(types: !30)
+!30 = !{!12, !12}

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-2.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+
+; CHECK:         DW_TAG_variable
+; CHECK-NEXT:    DW_AT_location
+; CHECK-NEXT:    [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; SECTIONS-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; CHECK-NEXT:    [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +9, DW_OP_stack_value
+; CHECK-NEXT:    [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; CHECK-NEXT:    DW_AT_name ("i")
+
+; Source to generate the IR below:
+; void f1();
+; int f2(int);
+; extern bool b;
+; extern int x;
+; void test() {
+;     // i's value is 7 for the first call in in the if block.  With basic
+;     // block sections, this would split the range across sections and would
+;     // result in an extra entry than without sections.
+;     int i = 7;
+;     f1();
+;     if (b) {
+;       f2(i);
+;       i += 2;
+;       f2(i);
+;     }
+; }
+; $ clang++ -S -emit-llvm -g -O2 loclist_2.cc
+;
+
+@b = external dso_local local_unnamed_addr global i8, align 1
+
+define dso_local void @_Z4testv() local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 7, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !14
+  %0 = load i8, i8* @b, align 1, !dbg !15, !tbaa !17, !range !21
+  %tobool.not = icmp eq i8 %0, 0, !dbg !15
+  br i1 %tobool.not, label %if.end, label %if.then, !dbg !22
+
+if.then:                                          ; preds = %entry
+  %call = tail call i32 @_Z2f2i(i32 7), !dbg !23
+  call void @llvm.dbg.value(metadata i32 9, metadata !11, metadata !DIExpression()), !dbg !13
+  %call1 = tail call i32 @_Z2f2i(i32 9), !dbg !25
+  br label %if.end, !dbg !26
+
+if.end:                                           ; preds = %if.then, %entry
+  ret void, !dbg !27
+}
+
+declare !dbg !28 dso_local void @_Z2f1v() local_unnamed_addr
+
+declare !dbg !29 dso_local i32 @_Z2f2i(i32) local_unnamed_addr
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #2
+
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "loclist_2.cc", directory: "/code")
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)"}
+!7 = distinct !DISubprogram(name: "test", linkageName: "_Z4testv", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 14, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 15, column: 5, scope: !7)
+!15 = !DILocation(line: 16, column: 9, scope: !16)
+!16 = distinct !DILexicalBlock(scope: !7, file: !1, line: 16, column: 9)
+!17 = !{!18, !18, i64 0}
+!18 = !{!"bool", !19, i64 0}
+!19 = !{!"omnipotent char", !20, i64 0}
+!20 = !{!"Simple C++ TBAA"}
+!21 = !{i8 0, i8 2}
+!22 = !DILocation(line: 16, column: 9, scope: !7)
+!23 = !DILocation(line: 17, column: 7, scope: !24)
+!24 = distinct !DILexicalBlock(scope: !16, file: !1, line: 16, column: 12)
+!25 = !DILocation(line: 19, column: 7, scope: !24)
+!26 = !DILocation(line: 20, column: 5, scope: !24)
+!27 = !DILocation(line: 21, column: 1, scope: !7)
+!28 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!29 = !DISubprogram(name: "f2", linkageName: "_Z2f2i", scope: !1, file: !1, line: 2, type: !30, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!30 = !DISubroutineType(types: !31)
+!31 = !{!12, !12}

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-3.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_location
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_reg3
+; CHECK-NEXT: DW_AT_name  ("i")
+
+; Source to generate the IR below:
+; void f1();
+; int f2();
+; extern int x;
+; void test() {
+;   int tmp = f2();
+;   // non-constant value with a single location description
+;   // Shouldn't change with BB-sections
+;   int i = tmp;
+;   f1();
+;   x = i;
+; }
+; $ clang++ -S -emit-llvm -g -O2 loclist_2.cc
+
+
+@x = external dso_local local_unnamed_addr global i32, align 4
+
+define dso_local void @_Z4testv() local_unnamed_addr !dbg !7 {
+entry:
+  %call = tail call i32 @_Z2f2v(), !dbg !14
+  call void @llvm.dbg.value(metadata i32 %call, metadata !11, metadata !DIExpression()), !dbg !15
+  call void @llvm.dbg.value(metadata i32 %call, metadata !13, metadata !DIExpression()), !dbg !15
+  tail call void @_Z2f1v(), !dbg !16
+  store i32 %call, i32* @x, align 4, !dbg !17, !tbaa !18
+  ret void, !dbg !22
+}
+
+declare !dbg !23 dso_local i32 @_Z2f2v() local_unnamed_addr
+
+declare !dbg !26 dso_local void @_Z2f1v() local_unnamed_addr
+
+declare void @llvm.dbg.value(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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "loclist_3.cc", directory: "/code")
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)"}
+!7 = distinct !DISubprogram(name: "test", linkageName: "_Z4testv", 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, !13}
+!11 = !DILocalVariable(name: "tmp", scope: !7, file: !1, line: 5, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 8, type: !12)
+!14 = !DILocation(line: 5, column: 13, scope: !7)
+!15 = !DILocation(line: 0, scope: !7)
+!16 = !DILocation(line: 9, column: 3, scope: !7)
+!17 = !DILocation(line: 10, column: 5, scope: !7)
+!18 = !{!19, !19, i64 0}
+!19 = !{!"int", !20, i64 0}
+!20 = !{!"omnipotent char", !21, i64 0}
+!21 = !{!"Simple C++ TBAA"}
+!22 = !DILocation(line: 11, column: 1, scope: !7)
+!23 = !DISubprogram(name: "f2", linkageName: "_Z2f2v", scope: !1, file: !1, line: 2, type: !24, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!24 = !DISubroutineType(types: !25)
+!25 = !{!12}
+!26 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-4.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_location
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value)
+; CHECK-NEXT: DW_AT_name  ("i")
+
+; Source to generate the IR below:
+; void f1();
+; int f2();
+; void test() {
+;   // constant value through partial scope, no BB boundary
+;   // Shouldn't change with BB-sections
+;   int i = 7;
+;   f1();
+;   i = f2();
+;   f1();
+; }
+;
+; $ clang++ -S -emit-llvm -g -O2 loclist_4.cc
+
+define dso_local void @_Z4testv() local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 7, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !14
+  %call = tail call i32 @_Z2f2v(), !dbg !15
+  call void @llvm.dbg.value(metadata i32 %call, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !16
+  ret void, !dbg !17
+}
+
+declare !dbg !18 dso_local void @_Z2f1v() local_unnamed_addr
+
+declare !dbg !19 dso_local i32 @_Z2f2v() local_unnamed_addr
+
+declare void @llvm.dbg.value(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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "loclist_4.cc", directory: "/code")
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)"}
+!7 = distinct !DISubprogram(name: "test", linkageName: "_Z4testv", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 6, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 7, column: 3, scope: !7)
+!15 = !DILocation(line: 8, column: 7, scope: !7)
+!16 = !DILocation(line: 9, column: 3, scope: !7)
+!17 = !DILocation(line: 10, column: 1, scope: !7)
+!18 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!19 = !DISubprogram(name: "f2", linkageName: "_Z2f2v", scope: !1, file: !1, line: 2, type: !20, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!20 = !DISubroutineType(types: !21)
+!21 = !{!12}

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-5.ll

+; RUN: llc %s --dwarf-version=4 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=4 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=none -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llc %s --dwarf-version=5 --basic-block-sections=all -filetype=obj -o %t
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+
+; CHECK:      DW_TAG_variable
+; CHECK-NEXT: DW_AT_location
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; SECTIONS-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; SECTIONS-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; CHECK-NEXT: DW_AT_name  ("i")
+
+; In the test below, i's constant value of 7 is only valud partially as is redefined at
+; the end.  This forces the use of a loclist with basic block sections.  Without basic
+; block sections, a single entry location list would be used to mark the entire scope
+; in which value of i is 7.
+
+; Source to generate the IR below:
+
+; void f1();
+; int f2();
+; extern bool b;
+; extern int x;
+; void test() {
+;   int i = 7;
+;   f1();
+;   if (b)
+;     f1();
+;   i = f2();
+;   f1();
+; }
+;
+; $ clang++ -S -emit-llvm -g -O2 loclist_4.cc
+
+
+@b = external dso_local local_unnamed_addr global i8, align 1
+
+define dso_local void @_Z4testv() local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 7, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !14
+  %0 = load i8, i8* @b, align 1, !dbg !15, !tbaa !17, !range !21
+  %tobool.not = icmp eq i8 %0, 0, !dbg !15
+  br i1 %tobool.not, label %if.end, label %if.then, !dbg !22
+
+if.then:                                          ; preds = %entry
+  tail call void @_Z2f1v(), !dbg !23
+  br label %if.end, !dbg !23
+
+if.end:                                           ; preds = %if.then, %entry
+  %call = tail call i32 @_Z2f2v(), !dbg !24
+  call void @llvm.dbg.value(metadata i32 %call, metadata !11, metadata !DIExpression()), !dbg !13
+  tail call void @_Z2f1v(), !dbg !25
+  ret void, !dbg !26
+}
+
+declare !dbg !27 dso_local void @_Z2f1v() local_unnamed_addr
+
+declare !dbg !28 dso_local i32 @_Z2f2v() local_unnamed_addr
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "loclist_5.cc", directory: "/code")
+!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 13.0.0 ([e-mail]:llvm/llvm-project.git 593cb4655097552ac6d81ce18a2851ae0feb8d3c)"}
+!7 = distinct !DISubprogram(name: "test", linkageName: "_Z4testv", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !10)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !{!11}
+!11 = !DILocalVariable(name: "i", scope: !7, file: !1, line: 9, type: !12)
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 10, column: 3, scope: !7)
+!15 = !DILocation(line: 11, column: 7, scope: !16)
+!16 = distinct !DILexicalBlock(scope: !7, file: !1, line: 11, column: 7)
+!17 = !{!18, !18, i64 0}
+!18 = !{!"bool", !19, i64 0}
+!19 = !{!"omnipotent char", !20, i64 0}
+!20 = !{!"Simple C++ TBAA"}
+!21 = !{i8 0, i8 2}
+!22 = !DILocation(line: 11, column: 7, scope: !7)
+!23 = !DILocation(line: 12, column: 5, scope: !16)
+!24 = !DILocation(line: 13, column: 7, scope: !7)
+!25 = !DILocation(line: 14, column: 3, scope: !7)
+!26 = !DILocation(line: 15, column: 1, scope: !7)
+!27 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!28 = !DISubprogram(name: "f2", linkageName: "_Z2f2v", scope: !1, file: !1, line: 2, type: !29, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!29 = !DISubroutineType(types: !30)
+!30 = !{!12}

llvm/test/DebugInfo/X86/basic-block-sections_1.ll

 ; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
 ; BB-SECTIONS-ASM-NEXT: .loc 1 2 9 prologue_end
 ; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
 ; BB-SECTIONS-ASM-NEXT: .loc 1 2 7 is_stmt
 ; BB-SECTIONS-ASM: _Z3fooi.__part.1:
 ; BB-SECTIONS-ASM: .LBB_END0_{{[0-9]+}}:
 ; BB-SECTIONS-ASM: .size  _Z3fooi.__part.1, .LBB_END0_{{[0-9]+}}-_Z3fooi.__part.1
 ; BB-SECTIONS-ASM: _Z3fooi.__part.2:
-; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
-; BB-SECTIONS-ASM-NEXT: .LBB_END0_{{[0-9]+}}:
+; BB-SECTIONS-ASM: .LBB_END0_{{[0-9]+}}:
 ; BB-SECTIONS-ASM: .size  _Z3fooi.__part.2, .LBB_END0_{{[0-9]+}}-_Z3fooi.__part.2
 ; BB-SECTIONS-ASM: _Z3fooi.__part.3:
-; BB-SECTIONS-ASM: .Ltmp{{[0-9]+}}:
-; BB-SECTIONS-ASM-NEXT: .LBB_END0_{{[0-9]+}}:
+; BB-SECTIONS-ASM: .LBB_END0_{{[0-9]+}}:
 ; BB-SECTIONS-ASM: .size  _Z3fooi.__part.3, .LBB_END0_{{[0-9]+}}-_Z3fooi.__part.3
 ; BB-SECTIONS-ASM: .Lfunc_end0:
 ; BB-SECTIONS-ASM: .Ldebug_ranges0:
 ; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.__part.1
 ; BB-SECTIONS-ASM-NEXT: .quad .LBB_END0_{{[0-9]+}}
 ; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.__part.2
 ; BB-SECTIONS-ASM-NEXT: .quad .LBB_END0_{{[0-9]+}}
 ; BB-SECTIONS-ASM-NEXT: .quad _Z3fooi.__part.3