Prevent line 0 instructions from dividing a lexical block into ranges

[ykhatav]

Summary

Certain instructions with line 0 source correlation create discontiguous/split address ranges in lexical blocks. This affects Visual Studio's ability to print variables reliably because Codeview debug format used on Windows does not support describing a lexical block with multiple address ranges. As a result, LLVM compiler's Codeview emission code evaporates these lexical blocks and pushes variables to the enclosing routine scope, causing gaps in their location ranges and potential confusion with similarly named variables in the debugger. While this issue is also visible on Linux, the Dwarf debugging format can handle it without impacting debugging.

To prevent the line 0 instructions from breaking up a lexical block we fold the line zero machine instructions into the range when the switch "UnknownLocations" is not Enabled. This essentially removes the split address ranges and allows the lexical block to be treated as a contiguous range of instructions.

[ykhatav]

Nit:test-fix

[ykhatav]

Fix metadata numbering

[ykhatav]

ping

[probinson]

It seems strange to define the enum in a header for a module that uses it only once, and externalize it in a module that uses it several times.

I'd always thought this DefaultOnOff business should be generalized... Hmm I see boolOrDefault in CommandLine.h. Maybe we could convert UnknownLocations to use that, remove static from the definition, and then LexicalScopes.cpp can reference it as an extern.

(Converting the rest of the DwarfDebug.cpp options from DefaultOnOff to boolOrDefault should not be part of your task. But maybe add a FIXME on the enum definition.)

[ykhatav]

In D144337#4167827, @probinson wrote:

It seems strange to define the enum in a header for a module that uses it only once, and externalize it in a module that uses it several times.

I'd always thought this DefaultOnOff business should be generalized... Hmm I see boolOrDefault in CommandLine.h. Maybe we could convert UnknownLocations to use that, remove static from the definition, and then LexicalScopes.cpp can reference it as an extern.
I agree with you that UnknownLocations may be better defined with boolorDefault instead of DefaultOnOff. I can change that.

However, the reason I moved the definition of UnknownLocations to LexicalScopes.cpp was to avoid a link-time error. Defining UnknownLocations as extern in LexicalScopes.cpp gives a link-time error despite removing the "static" keyword from its definition in DwarfDebug.cpp. I see that the two object files are in different directories and while building the LexicalScopes.cpp file it is unable to find the definition of UnknownLocations. I am aware that it may not be the optimal approach so I would appreciate any feedback or consider alternative methods.

(Converting the rest of the DwarfDebug.cpp options from DefaultOnOff to boolOrDefault should not be part of your task. But maybe add a FIXME on the enum definition.)

[probinson]

Defining UnknownLocations as extern in LexicalScopes.cpp gives a link-time error despite removing the "static" keyword from its definition in DwarfDebug.cpp.

Ah, the layering is in the other direction than I thought (AsmPrinter depends on CodeGen, not vice versa). Okay, it has to be defined in LexicalScopes and made extern from DwarfDebug.

Please do change over to boolOrDefault for this one flag, which means you can leave the DefaultOnOff enum in DwarfDebug.cpp.

[dblaikie]

Does this need a flag? The patch describes doing this for CodeView? Could/should it be done unconditionally for CV?

Though I'll mention that there's a risk of messing up profiles with this - those zero line instructions do have scopes and other things attached to them, if they were of the appropriate scope, even with a zero line, then it wouldn't be fragmenting the scope. So it's because the location isn't attributed to the inline scope that it's causing fragmentation - but that means the instruction doesn't necessarily come from that scope, and so a sample based profile might incorrectly conclude something about reachability if it is instead attributed to this scope... maybe?

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

68

We shouldn't introduce declarations of foreign entities into .cpp files like this (there's a risk of the decl/def getting out of date/inconsistent with each other) - there should be some common header to declare this in. Perhaps that means it goes up in LexicalScopes.h?

[ykhatav]

In D144337#4172962, @dblaikie wrote:

Does this need a flag? The patch describes doing this for CodeView? Could/should it be done unconditionally for CV?

When UnknownLocations is left at default, the line table includes line 0 entries, and the lexical scopes utilize them while computing the ranges. However, if the unknown locations are disabled, the line table already ignores line 0 entries. This patch modifies the lexical scope behavior to ignore line 0 entries when UnknownLocations is not enabled. If this change is applied unconditionally, the line table entries and lexical scope will not match, causing inconsistencies
Although the DWARF format has the ability to describe the split address ranges, it is possible that the lexical blocks with split address ranges can result in buggy behavior on Linux as well.

[ykhatav]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

68

Unfortunately, declaring it in LexicalScopes.h does not work due to dependency issue between AsmPrinter and Codegen.

[ykhatav]

Change UnknownLocations to use boolorDefault

[dblaikie]

Could you describe why this relates to/depends on the "UnknownLocations" flag? I'm not following from the description - we could still describe these locations as being at line zero, while including them in lexical scopes to avoid fragmented ranges, I think?

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

68

Could you describe the dependency issue in more detail? I think it's important that we figure out the layering & where things should be declared - not introduce multiple independent declarations of the same entity.

[ykhatav]

In D144337#4183551, @dblaikie wrote:

Could you describe why this relates to/depends on the "UnknownLocations" flag? I'm not following from the description - we could still describe these locations as being at line zero, while including them in lexical scopes to avoid fragmented ranges, I think?

The reason why we want to check for “UnknownLocations” flag is that this flag is used to check if we want to add line 0 entries in the line table (in DwarfDebug.cpp) and thereby controlling whether or not line zero instructions are represented in the debug information. If we don’t check for this flag and skip the line 0 entries while extracting lexical scopes there will be a mismatch in the line table entries and lexical scopes.

[ykhatav]

Move UnknownLocations declaration to LexicalScopes.h

[ykhatav]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

68

Sorry, I misunderstood what you said.. I was able to move "UnknownLocations" to LexicalScope.h

[dblaikie]

In D144337#4185295, @ykhatav wrote:

In D144337#4183551, @dblaikie wrote:

Could you describe why this relates to/depends on the "UnknownLocations" flag? I'm not following from the description - we could still describe these locations as being at line zero, while including them in lexical scopes to avoid fragmented ranges, I think?

The reason why we want to check for “UnknownLocations” flag is that this flag is used to check if we want to add line 0 entries in the line table (in DwarfDebug.cpp) and thereby controlling whether or not line zero instructions are represented in the debug information. If we don’t check for this flag and skip the line 0 entries while extracting lexical scopes there will be a mismatch in the line table entries and lexical scopes.

Sorry, still not quite following. Could you walk me through an example of the bug you're trying to address with this patch? And an example of the bug you're trying to avoid introducing/that causes you to need this extra UnknownLocations checking?

[ykhatav]

In D144337#4190626, @dblaikie wrote:

In D144337#4185295, @ykhatav wrote:

In D144337#4183551, @dblaikie wrote:

Could you describe why this relates to/depends on the "UnknownLocations" flag? I'm not following from the description - we could still describe these locations as being at line zero, while including them in lexical scopes to avoid fragmented ranges, I think?

The reason why we want to check for “UnknownLocations” flag is that this flag is used to check if we want to add line 0 entries in the line table (in DwarfDebug.cpp) and thereby controlling whether or not line zero instructions are represented in the debug information. If we don’t check for this flag and skip the line 0 entries while extracting lexical scopes there will be a mismatch in the line table entries and lexical scopes.

Sorry, still not quite following. Could you walk me through an example of the bug you're trying to address with this patch? And an example of the bug you're trying to avoid introducing/that causes you to need this extra UnknownLocations checking?

If you consider the attached test case (llvm/test/DebugInfo/X86/contiguous-lexical-block.ll) you can see that the lexical block is fragmented into ranges due to the presence of an instruction having line number 0. This I believe is a bug and If the same test case is run on windows, Visual Studio' can't reliably print variable "i" because CodeView does not provide a mechanism for describing a lexical block with more than one address ranges. In order to prevent the line 0 instructions from breaking up a lexical block, in this patch, we fold the line zero machine instructions into the range.
I don't have a test case that demonstrates whether using or not using UnknownLocations could lead to a bug. It is an internal flag and is suitable for controlling whether or not line zero instructions are represented in the debug information and so, in my opinion, can be used to control the scope tree as well.. Do you have any other flags in mind that can be used instead of "UnknownLocations"?

[dblaikie]

If you consider the attached test case (llvm/test/DebugInfo/X86/contiguous-lexical-block.ll) you can see that the lexical block is fragmented into ranges due to the presence of an instruction having line number 0. This I believe is a bug and If the same test case is run on windows, Visual Studio' can't reliably print variable "i" because CodeView does not provide a mechanism for describing a lexical block with more than one address ranges. In order to prevent the line 0 instructions from breaking up a lexical block, in this patch, we fold the line zero machine instructions into the range.

Sure, I'm on-board there. I'll take your word for it that CV can't represent discontiguous scopes and making scopes contiguous is the better tradeoff than omitting them entirely.

I don't have a test case that demonstrates whether using or not using UnknownLocations could lead to a bug. It is an internal flag and is suitable for controlling whether or not line zero instructions are represented in the debug information and so, in my opinion, can be used to control the scope tree as well.. Do you have any other flags in mind that can be used instead of "UnknownLocations"?

I don't understand this bit - there can be zero locations for other reasons, apart from UnknownLocations - you could just check for the zero locations, without needing to check UnknownLocations too, right?

But maybe you're using UnknownLocations as a proxy for CV/MSVC debug info emission? That seems unfortunate/not suitable, and this behavior should be gated on/more directly test for CV output, I think?

@hans maybe you've got thoughts on this stuff

[hans]

In D144337#4194463, @dblaikie wrote:

@hans maybe you've got thoughts on this stuff

Sorry, I don't know much about Codeview. @zequanwu knows more.

[ykhatav]

In D144337#4194463, @dblaikie wrote:

If you consider the attached test case (llvm/test/DebugInfo/X86/contiguous-lexical-block.ll) you can see that the lexical block is fragmented into ranges due to the presence of an instruction having line number 0. This I believe is a bug and If the same test case is run on windows, Visual Studio' can't reliably print variable "i" because CodeView does not provide a mechanism for describing a lexical block with more than one address ranges. In order to prevent the line 0 instructions from breaking up a lexical block, in this patch, we fold the line zero machine instructions into the range.

Sure, I'm on-board there. I'll take your word for it that CV can't represent discontiguous scopes and making scopes contiguous is the better tradeoff than omitting them entirely.

I don't have a test case that demonstrates whether using or not using UnknownLocations could lead to a bug. It is an internal flag and is suitable for controlling whether or not line zero instructions are represented in the debug information and so, in my opinion, can be used to control the scope tree as well.. Do you have any other flags in mind that can be used instead of "UnknownLocations"?

I don't understand this bit - there can be zero locations for other reasons, apart from UnknownLocations - you could just check for the zero locations, without needing to check UnknownLocations too, right?

But maybe you're using UnknownLocations as a proxy for CV/MSVC debug info emission? That seems unfortunate/not suitable, and this behavior should be gated on/more directly test for CV output, I think?

No, my intent was not to use UnknownLocations as a proxy for CV, but I think it is safe not to fold line 0 instructions into a scope range when UnknownLocations is enabled. AFAIK, when UnknownLocations is enabled line 0 entries are emitted in the debug information. In my opinion, Folding these instructions when the switch is enabled could break stuff.

@hans maybe you've got thoughts on this stuff

[dblaikie]

No, my intent was not to use UnknownLocations as a proxy for CV, but I think it is safe not to fold line 0 instructions into a scope range when UnknownLocations is enabled. AFAIK, when UnknownLocations is enabled line 0 entries are emitted in the debug information. In my opinion, Folding these instructions when the switch is enabled could break stuff.

Yeah, I'm still really not following this. UnknownLocations isn't the only source of zero lines (I think the most obvious/easy example is, if I recall correctly, line zero is used for merged function calls). And even if it was, I don't understand why it would need to be tested in LexicalScopes.cpp where the line can be tested for zero directly, right? So why do we need to test anything else other than that it's line zero?

[probinson]

(I think the most obvious/easy example is, if I recall correctly, line zero is used for merged function calls)

Actually, any merged instructions not originally from the same source location. (Because we don't have a way to represent multiple source locations for a single instruction.)

I agree with @dblaikie, for CV you can just eliminate the line-zero records without reference to UnknownLocations.

[ykhatav]

I will open a design discussion to discuss what an appropriate flag will be to control this behavior.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 #include <string>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "dwarfdebug"
 
 STATISTIC(NumCSParams, "Number of dbg call site params created");
 
+extern cl::opt<cl::boolOrDefault> UnknownLocations;
+
 static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier(
     "use-dwarf-ranges-base-address-specifier", cl::Hidden,
     cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
 
 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
                                            cl::Hidden,
                                            cl::desc("Generate dwarf aranges"),
                                            cl::init(false));
 
 static cl::opt<bool>
     GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
                            cl::desc("Generate DWARF4 type units."),
                            cl::init(false));
 
 static cl::opt<bool> SplitDwarfCrossCuReferences(
     "split-dwarf-cross-cu-references", cl::Hidden,
     cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
 
+//FIXME:Generalize DefaultOnOff by replacing it with boolOrDefault
 enum DefaultOnOff { Default, Enable, Disable };
 
-static cl::opt<DefaultOnOff> UnknownLocations(
-    "use-unknown-locations", cl::Hidden,
-    cl::desc("Make an absence of debug location information explicit."),
-    cl::values(clEnumVal(Default, "At top of block or after label"),
-               clEnumVal(Enable, "In all cases"), clEnumVal(Disable, "Never")),
-    cl::init(Default));
-
 static cl::opt<AccelTableKind> AccelTables(
     "accel-tables", cl::Hidden, cl::desc("Output dwarf accelerator tables."),
     cl::values(clEnumValN(AccelTableKind::Default, "Default",
                           "Default for platform"),
                clEnumValN(AccelTableKind::None, "Disable", "Disabled."),
                clEnumValN(AccelTableKind::Apple, "Apple", "Apple"),
                clEnumValN(AccelTableKind::Dwarf, "Dwarf", "DWARF")),
     cl::init(AccelTableKind::Default));
void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   }
 
   if (!DL) {
     // We have an unspecified location, which might want to be line 0.
     // If we have already emitted a line-0 record, don't repeat it.
     if (LastAsmLine == 0)
       return;
     // If user said Don't Do That, don't do that.
-    if (UnknownLocations == Disable)
+    if (UnknownLocations == cl::BOU_FALSE)
       return;
     // See if we have a reason to emit a line-0 record now.
     // Reasons to emit a line-0 record include:
     // - User asked for it (UnknownLocations).
     // - Instruction has a label, so it's referenced from somewhere else,
     //   possibly debug information; we want it to have a source location.
     // - Instruction is at the top of a block; we don't want to inherit the
     //   location from the physically previous (maybe unrelated) block.
-    if (UnknownLocations == Enable || PrevLabel ||
+    if (UnknownLocations == cl::BOU_TRUE || PrevLabel ||
         (PrevInstBB && PrevInstBB != MI->getParent())) {
       // Preserve the file and column numbers, if we can, to save space in
       // the encoded line table.
       // Do not update PrevInstLoc, it remembers the last non-0 line.
       const MDNode *Scope = nullptr;
       unsigned Column = 0;
       if (PrevInstLoc) {
         Scope = PrevInstLoc.getScope();

llvm/lib/CodeGen/LexicalScopes.cpp

 #include <string>
 #include <tuple>
 #include <utility>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "lexicalscopes"
 
+cl::opt<cl::boolOrDefault> UnknownLocations(
+    "use-unknown-locations", cl::Hidden,
+    cl::desc("Make an absence of debug location information explicit."),
+    cl::init(cl::BOU_UNSET));
+
 /// reset - Reset the instance so that it's prepared for another function.
 void LexicalScopes::reset() {
   MF = nullptr;
   CurrentFnLexicalScope = nullptr;
   LexicalScopeMap.clear();
   AbstractScopeMap.clear();
   InlinedLexicalScopeMap.clear();
   AbstractScopesList.clear();
for (const auto &MInsn : MBB) {
       }
 
       // If scope has not changed then skip this instruction.
       if (MIDL == PrevDL) {
         PrevMI = &MInsn;
         continue;
       }
 
-      if (RangeBeginMI) {
+      if (RangeBeginMI &&
+          (MIDL->getLine() != 0 || UnknownLocations == cl::BOU_TRUE)) {
         // If we have already seen a beginning of an instruction range and
         // current instruction scope does not match scope of first instruction
         // in this range then create a new instruction range.
         InsnRange R(RangeBeginMI, PrevMI);
         MI2ScopeMap[RangeBeginMI] = getOrCreateLexicalScope(PrevDL);
         MIRanges.push_back(R);
       }
 

llvm/test/CodeGen/X86/dbg-line-0-no-discriminator.ll

-; RUN: llc -filetype=obj -use-unknown-locations=Enable -mtriple=x86_64-unknown-linux %s -o %t
+; RUN: llc -filetype=obj -use-unknown-locations=true -mtriple=x86_64-unknown-linux %s -o %t
 ; RUN: llvm-dwarfdump -debug-line %t | FileCheck %s
 
 define void @_Z3bazv() !dbg !6 {
   call void @_Z3foov(), !dbg !9
   call void @_Z3foov() ; no !dbg, so will be marked as line 0
   ret void, !dbg !11
 }
 

llvm/test/CodeGen/X86/unknown-location.ll

-; RUN: llc < %s -asm-verbose=false -mtriple=x86_64-apple-darwin10 -use-unknown-locations=Enable | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -mtriple=x86_64-apple-darwin10 -use-unknown-locations=true | FileCheck %s
 
 ; The divide instruction does not have a debug location. CodeGen should
 ; represent this in the debug information. This is done by setting line to 0.
 
 ;      CHECK:         leal
 ; CHECK-NEXT:         .loc 1 0 3
 ;      CHECK:         cltd
 ; CHECK-NEXT:         idivl

llvm/test/DebugInfo/MIR/X86/no-cfi-loc.mir

 # Verify that a CFI instruction with no debug location
 # does not result in a line-0 location in the assembler.
-# RUN: %llc_dwarf -start-after=prologepilog -march=x86-64 -use-unknown-locations=Enable %s -o - | FileCheck %s
+# RUN: %llc_dwarf -start-after=prologepilog -march=x86-64 -use-unknown-locations=true %s -o - | FileCheck %s
 #
 # CHECK-NOT: .loc 1 0
 # CHECK:     .cfi_def_cfa_offset
 # UNSUPPORTED: target={{.*-(cygwin|windows-gnu|windows-msvc)}}
 
 --- |
   ; ModuleID = 'no-cfi-loc.ll'
   source_filename = "no-cfi-loc.ll"

llvm/test/DebugInfo/X86/contiguous-lexical-block.ll

+; This test verifies that the lexical block remains contiguous and is not split by runtime instructions with a line number of 0.
+
+; RUN: llc -filetype=obj --use-unknown-locations=true %s -o - \
+; RUN:   | llvm-dwarfdump --debug-info - \
+; RUN:   | FileCheck %s --check-prefixes=CHECK,ENABLE
+; RUN: llc -filetype=obj --use-unknown-locations=false %s -o - \
+; RUN:   | llvm-dwarfdump --debug-info - \
+; RUN:   | FileCheck %s --check-prefixes=CHECK,DISABLE
+
+; CHECK:       DW_TAG_subprogram
+; CHECK:         DW_AT_name      ("test")
+; CHECK-NOT:   NULL
+
+; CHECK:       DW_TAG_lexical_block
+; ENABLE:        DW_AT_ranges (0x{{[0-9a-f]+}}
+; ENABLE:          [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}})
+; ENABLE:          [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}})
+; ENABLE:          [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}})
+; ENABLE:          [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}))
+
+; DISABLE-NOT:   DW_AT_ranges
+; DISABLE:       DW_AT_low_pc  (0x{{[0-9a-f]+}})
+; DISABLE:       DW_AT_high_pc (0x{{[0-9a-f]+}})
+
+; ModuleID = 'contiguous-lexical-block.ll'
+source_filename = "test.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-pc-linux"
+
+; Function Attrs: convergent noinline nounwind optnone
+define i32 @test(i32 %0) #0 !dbg !5 {
+entry:
+  %1 = add nsw i32 %0, 1, !dbg !14
+  %2 = add nsw i32 %1, 1, !dbg !15
+  %3 = add nsw i32 %2, 1, !dbg !17
+  %4 = add nsw i32 %3, 1, !dbg !15
+  %5 = add nsw i32 %4, 1, !dbg !21
+  %6 = add nsw i32 %5, 1, !dbg !15
+  %7 = add nsw i32 %6, 1, !dbg !22
+  ret i32 %7
+}
+
+attributes #0 = { convergent noinline nounwind optnone }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.dbg.cu = !{!2}
+
+!0 = !{i32 7, !"Dwarf Version", i32 4}
+!1 = !{i32 2, !"Debug Info Version", i32 3}
+!2 = distinct !DICompileUnit(language: DW_LANG_C11, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4)
+!3 = !DIFile(filename: "test.c", directory: "/path/to")
+!4 = !{}
+!5 = distinct !DISubprogram(name: "test", scope: null, file: !3, line: 34, type: !6, scopeLine: 34, flags: DIFlagArtificial, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagMainSubprogram, unit: !2, templateParams: !4, retainedNodes: !8)
+!6 = !DISubroutineType(types: !7)
+!7 = !{null}
+!8 = !{!9}
+!9 = !DILocalVariable(name: "i", scope: !10, file: !3, line: 17, type: !13)
+!10 = distinct !DILexicalBlock(scope: !11, file: !3, line: 34, column: 1)
+!11 = distinct !DILexicalBlock(scope: !12, file: !3, line: 30, column: 3)
+!12 = distinct !DILexicalBlock(scope: !5, file: !3, line: 29, column: 1)
+!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!14 = !DILocation(line: 34, column: 1, scope: !10)
+!15 = !DILocation(line: 0, scope: !16)
+!16 = !DILexicalBlockFile(scope: !5, file: !3, discriminator: 0)
+!17 = !DILocation(line: 36, column: 21, scope: !18)
+!18 = distinct !DILexicalBlock(scope: !19, file: !3, line: 36, column: 7)
+!19 = distinct !DILexicalBlock(scope: !20, file: !3, line: 36, column: 7)
+!20 = distinct !DILexicalBlock(scope: !10, file: !3, line: 35, column: 5)
+!21 = !DILocation(line: 37, column: 23, scope: !18)
+!22 = !DILocation(line: 36, column: 27, scope: !18)

llvm/test/DebugInfo/X86/dwarf-no-source-loc.ll

 ; Verify "no source location" directives appear in appropriate places,
 ; but don't appear when we explicitly suppress them.
 ; RUN: llc < %s -o - | FileCheck %s
-; RUN: llc < %s -o - -use-unknown-locations=Disable | FileCheck %s --check-prefix=DISABLE
+; RUN: llc < %s -o - -use-unknown-locations=false | FileCheck %s --check-prefix=DISABLE
 
 ; Generated from this .cpp targeting linux using -g
 ; and then removed function attributes as clutter.
 ;
 ; void bar(int *);
 ; void baz(int *);
 ; # 5 "no-source-loc.cpp"
 ; void foo(int x) {

llvm/test/DebugInfo/X86/tail-merge.ll

-; RUN: llc %s -mtriple=x86_64-unknown-unknown -use-unknown-locations=Enable -o - | FileCheck %s
+; RUN: llc %s -mtriple=x86_64-unknown-unknown -use-unknown-locations=true -o - | FileCheck %s
 
 ; Generated with "clang -gline-tables-only -c -emit-llvm -o - | opt -passes=sroa -S"
 ; from source:
 ;
 ; extern int foo(int);
 ; extern int bar(int);
 ;
 ; int test(int a, int b) {