[DWARF] Force a linkage_name on an inlined subprogram's abstract origin

[probinson]

Summary

When we suppress linkage names, for a non-inlined subprogram the name
can still be found in the object-file symbol table, because we have
the code address of the subprogram. This is not the case for an
inlined subprogram, so we still want to emit the linkage name in the
DWARF. Put this on the abstract-origin DIE because it's common to all
inlined instances.

[dblaikie]

Got data on how much this grows the size of output (optimized clang selfhost, perhaps?)

I've had a few conversations about where linkage names should and should not appear, and have yet to understand/hear a coherent position about what consumers want to use them for. Perhaps you could outline your use case, so we can at least think about how that applies across LLVM?

test/DebugInfo/Generic/linkage-name-abstract.ll

11–17

If you're demonstrating inlining, I find this to be the simplest option:

void f1();
__attribute__((always_inline)) void f2() {
  f1();
}
void f3() {
  f2();
}

That way there's no confusion about whether the return values are relevant, if the operations (like addition) are relevant, if an optimization could constant propagate/fold away the value, etc. The call to f1 is unoptimizable, can't be coalesced with anything, etc.

[dblaikie]

Also meant to ask whether there was a way to avoid passing in a constant
from the two callers and then conditionalizing later. It'd be nice to just
bubble up the behavior and do it in the place that needs it and not do it
in the place that doesn't.

Not sure if that's possible/practical (I see it overlaps with the 'minimal'
flag, which makes it trickier) - but I'll give it some more thought.

[probinson]

The abstract instances are really no different from other subprogram declarations, which is why most of how they get handled is no different from other subprogram declarations. I'm not keen on passing the flag down through several layers either, but I don't see else to figure out we really want the linkage name after all, at the point where we actually add it. When I conditionalized linkage-name in the first place, Eric wanted the caller not to have to think too hard, and let addLinkageName itself do all the deciding.

Use case has to do with sample-based PGO, we want to be able to attribute data for an inlined instance to that function and not its caller. The collected data uses the mangled name as the key, or something; I'm not directly involved in that work.

I'll look at redoing the test case using your model, thanks for the tip!

No size data yet, a self-host clang with extra options is befuddling me.

[probinson]

Re not passing constants down: It looks like applySubprogramDefinitionAttributes could figure out if the SP is abstract with something like this?

bool Abstract = DU->getAbstractSPDies().lookup(SP);

I can't do that in addLinkageName because it has only the DIE, not the DISubprogram. But then I wouldn't have to fuss with all those other APIs.

[probinson]

Less invasive implementation. Revise test per suggestion.

[probinson]

Built Clang with Clang 3 times: linkage names Enabled, linkage names Disabled but with the patch, linkage names Disabled without the patch (aka: all names, some names, no names).
'all names' and 'no names' are the options we have today; this patch replaces 'no names' with 'some names.'

Total ELF size of 'all names' is 11.2% larger than 'no names'; sum of all .debug_* sections is 11.9% larger.
Total ELF size of 'some names' is 0.6% larger than 'no names'; sum of all .debug_* sections is 0.6% larger.
The bulk of the difference obviously in .debug_str, with some in .debug_info and .debug_abbrev.

(Debug info turns out to be about 95% of the total ELF size, without LTO or .debug_types or any other deduplication; hence the ELF and .debug_* percentages are naturally very similar.)

A size cost of <1% seems pretty reasonable here.

[dblaikie]

Oh, and if you're interested in mangled names, you might be interested in
some old patches I came across yesterday related to them. I haven't double
checked the behavior, but according to my patch descriptions it sounds like
it might be describing some holes/inconsistencies in our frontend handling
of mangled names that may impact your scenarios.

• names.diff3 KBDownload

[probinson]

In D18706#391801, @probinson wrote:

Built Clang with Clang 3 times: linkage names Enabled, linkage names Disabled but with the patch, linkage names Disabled without the patch (aka: all names, some names, no names).
'all names' and 'no names' are the options we have today; this patch replaces 'no names' with 'some names.'

dblaikie wrote (in email):

Which option(s) are you referring to here ^ (do we have a flag or somesuch that
allows enabling/disabling linkage names?)

Yes, DwarfDebug.cpp has -dwarf-linkage-names={Enable,Disable} which is disabled by default when tuning for SCE, otherwise enabled by default. This is what DD->useLinkageNames() is referring to, in addLinkageName(), giving us the all/none options.
My patch obviously substitutes 'some' for 'none'.

[dblaikie]

Seems this makes the flag (dwarf-linkage-names=*) a bit erroneous, no?
Would it be better to trigger this directly off the debugger tuning flag
now & drop the specific named flag?

[probinson]

In D18706#393310, @dblaikie wrote:

Seems this makes the flag (dwarf-linkage-names=*) a bit erroneous, no?

That's true, it doesn't completely disable linkage names any more. Make that a 3-way flag? -dwarf-linkage-names={All,Abstract,None}. The more complicated decision-making can be buried inside useLinkageNames() which would now take a bool saying whether the DIE is abstract.

Would it be better to trigger this directly off the debugger tuning flag
now & drop the specific named flag?

No. The original discussion over "tuning" specifically concluded that tuning should expand to defaults for feature-specific flags, and never be a controlling condition on its own. It should always be possible to override a tuning with specific flags.

[probinson]

Make linkage-name policy a proper 3-way choice.

[probinson]

In D18706#393327, @probinson wrote:

In D18706#393310, @dblaikie wrote:

Would it be better to trigger this directly off the debugger tuning flag
now & drop the specific named flag?

No. The original discussion over "tuning" specifically concluded that tuning should expand to defaults for feature-specific flags, and never be a controlling condition on its own. It should always be possible to override a tuning with specific flags.

This policy is documented in include/llvm/Target/TargetOptions.h, see the definition of enum DebuggerKind.

[probinson]

Remove the "none" option per request from David Blaikie. The choices are "All" or "Abstract" (subprograms).

[dblaikie]

In D18706#391247, @probinson wrote:

Re not passing constants down: It looks like applySubprogramDefinitionAttributes could figure out if the SP is abstract with something like this?

What I was thinking of was more raising the addition of the linkage name up into the callers - so that we don't turn a static property at the call site into a dynamic property of the caller if we can avoid it without complicating things.

But I suppose pushing up/duplicating the logic for getting the decl linkage name, testing !Minimal, etc, isn't really any good...

I'm fine with either way, then.

Also - depending on how far you want to go, you could probably skip the mangled name for abstract subprograms that have a concrete definition (it'd mean having to search through the DWARF to find the concrete subprogram, then looking at its high/low pc to find the symbol in the symbol table with the mangled name there)

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

108–112

Why did this need to become a 3 state when it was a boolean before? (when it's still only about 2 states, I think - before it was all-or-nothing, and now it's all-or-abstract)

[probinson]

In D18706#400222, @dblaikie wrote:

Also - depending on how far you want to go, you could probably skip the mangled name for abstract subprograms that have a concrete definition (it'd mean having to search through the DWARF to find the concrete subprogram, then looking at its high/low pc to find the symbol in the symbol table with the mangled name there)

If the concrete out-of-line instance gets LTO'd away, that won't work.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

108–112

This is about the command-line option, which used to be the 3-state DefaultOnOff and is now this new enum because the choices aren't really On and Off anymore. The DwarfDebug flag is still a bool.

[probinson]

In D18706#400250, @probinson wrote:

In D18706#400222, @dblaikie wrote:

Also - depending on how far you want to go, you could probably skip the mangled name for abstract subprograms that have a concrete definition (it'd mean having to search through the DWARF to find the concrete subprogram, then looking at its high/low pc to find the symbol in the symbol table with the mangled name there)

If the concrete out-of-line instance gets LTO'd away, that won't work.

Sorry, senior moment. If it gets dead-stripped by the linker, that won't work.

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

667–668

Actually, one thing - could you pull the useLinkageName/abstract part out into the caller, perhaps?

What I'm thinking is that if it's sufficiently re-structured, the AbstractSPDies lookup shouldn't be necessary except when this option is enabled.

[probinson]

Try to do fewer lookups.

[probinson]

In D18706#400343, @probinson wrote:

Try to do fewer lookups.

This means every call to addLinkageName has to be guarded. When I did the option originally (as an on/off), Eric was not a fan of guarding the calls, which is why it ended up inside the method. But now the condition is different in the two places that call the method, so maybe that's okay?

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

1172–1177

Just roll these conditions into the previous 'if', perhaps?

[probinson]

Combine two 'if's into one.

[probinson]

Ping. @dblaikie, you had accepted this but then had further comments so I'm not 100% sure it still applies.

[dblaikie]

Sorry for any ambiguity - like I said in my last message, whichever way you
want to go with it out of the two choices (in both design issues mentioned

• in terms of number of lookups and whether to pass a flag around or do a

lookup) is fine. Commit whichever you're most comfortable with.

lib/CodeGen/AsmPrinter/DwarfDebug.h

SmallVector<
       TypeUnitsUnderConstruction;
 
   /// Whether to emit the pubnames/pubtypes sections.
   bool HasDwarfPubSections;
 
   /// Whether to use the GNU TLS opcode (instead of the standard opcode).
   bool UseGNUTLSOpcode;
 
-  /// Whether to emit DW_AT_[MIPS_]linkage_name.
-  bool UseLinkageNames;
+  /// Whether to emit all linkage names, or just abstract subprograms.
+  bool UseAllLinkageNames;
 
   /// Version of dwarf we're emitting.
   unsigned DwarfVersion;
 
   /// Maps from a type identifier to the actual MDNode.
   DITypeIdentifierMap TypeIdentifierMap;
 
   /// DWARF5 Experimental Options
public:
   void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); }
 
   /// For symbols that have a size designated (e.g. common symbols),
   /// this tracks that size.
   void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
     SymSize[Sym] = Size;
   }
 
-  /// Returns whether to emit DW_AT_[MIPS_]linkage_name.
-  bool useLinkageNames() const { return UseLinkageNames; }
+  /// Returns whether to emit this DW_AT_[MIPS_]linkage_name.
+  bool useLinkageName(bool Abstract) const {
+    return UseAllLinkageNames || Abstract;
+  }
 
   /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the
   /// standard DW_OP_form_tls_address opcode
   bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; }
 
   /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger.
   ///
   /// Returns whether we are "tuning" for a given debugger.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 static cl::opt<DefaultOnOff>
 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
                  cl::desc("Generate DWARF pubnames and pubtypes sections"),
                  cl::values(clEnumVal(Default, "Default for platform"),
                             clEnumVal(Enable, "Enabled"),
                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
                  cl::init(Default));
 
-static cl::opt<DefaultOnOff>
+enum LinkageNameOption {
+  DefaultLinkageNames,
+  AllLinkageNames,
+  AbstractLinkageNames
+};
+static cl::opt<LinkageNameOption>
     DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
-                  cl::desc("Emit DWARF linkage-name attributes."),
-                  cl::values(clEnumVal(Default, "Default for platform"),
-                             clEnumVal(Enable, "Enabled"),
-                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
-                  cl::init(Default));
+                      cl::desc("Which DWARF linkage-name attributes to emit."),
+                      cl::values(clEnumValN(DefaultLinkageNames, "Default",
+                                            "Default for platform"),
+                                 clEnumValN(AllLinkageNames, "All", "All"),
+                                 clEnumValN(AbstractLinkageNames, "Abstract",
+                                            "Abstract subprograms"),
+                                 clEnumValEnd),
+                      cl::init(DefaultLinkageNames));
 
 static const char *const DWARFGroupName = "DWARF Emission";
 static const char *const DbgTimerName = "DWARF Debug Writer";
 
 void DebugLocDwarfExpression::EmitOp(uint8_t Op, const char *Comment) {
   BS.EmitInt8(
       Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
                   : dwarf::OperationEncodingString(Op));
else
     HasSplitDwarf = SplitDwarf == Enable;
 
   // Pubnames/pubtypes on by default for GDB.
   if (DwarfPubSections == Default)
     HasDwarfPubSections = tuneForGDB();
   else
     HasDwarfPubSections = DwarfPubSections == Enable;
 
-  // SCE does not use linkage names.
-  if (DwarfLinkageNames == Default)
-    UseLinkageNames = !tuneForSCE();
+  // SCE defaults to linkage names only for abstract subprograms.
+  if (DwarfLinkageNames == DefaultLinkageNames)
+    UseAllLinkageNames = !tuneForSCE();
   else
-    UseLinkageNames = DwarfLinkageNames == Enable;
+    UseAllLinkageNames = DwarfLinkageNames == AllLinkageNames;
 
   unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
   DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
                                     : MMI->getModule()->getDwarfVersion();
   // Use dwarf 4 by default if nothing is requested.
   DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
 
   // Work around a GDB bug. GDB doesn't support the standard opcode;

lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
   void addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty);
   void addConstantValue(DIE &Die, const APInt &Val, bool Unsigned);
   void addConstantValue(DIE &Die, bool Unsigned, uint64_t Val);
 
   /// Add constant value entry in variable DIE.
   void addConstantFPValue(DIE &Die, const MachineOperand &MO);
   void addConstantFPValue(DIE &Die, const ConstantFP *CFP);
 
-  /// Add a linkage name, if it isn't empty.
-  void addLinkageName(DIE &Die, StringRef LinkageName);
+  /// Add a linkage name, if it isn't empty and we're doing linkage names.
+  void addLinkageName(DIE &Die, StringRef LinkageName, bool Abstract = false);
 
   /// Add template parameters in buffer.
   void addTemplateParams(DIE &Buffer, DINodeArray TParams);
 
   /// Add register operand.
   /// \returns false if the register does not exist, e.g., because it was never
   /// materialized.
   bool addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

for (int i = 0; i < NumBytes; i++) {
     else
       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
     addUInt(*Block, dwarf::DW_FORM_data1, c);
   }
 
   addBlock(Die, dwarf::DW_AT_const_value, Block);
 }
 
-void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
-  if (!LinkageName.empty() && DD->useLinkageNames())
+void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName, bool Abstract) {
+  if (!LinkageName.empty() && DD->useLinkageName(Abstract))
     addString(Die,
               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
                                          : dwarf::DW_AT_MIPS_linkage_name,
               GlobalValue::getRealLinkageName(LinkageName));
 }
 
 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
   // Add template parameters.
bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
   // Add function template parameters.
   addTemplateParams(SPDie, SP->getTemplateParams());
 
   // Add the linkage name if we have one and it isn't in the Decl.
   StringRef LinkageName = SP->getLinkageName();
   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
           LinkageName == DeclLinkageName) &&
          "decl has a linkage name and it is different");
-  if (DeclLinkageName.empty())
-    addLinkageName(SPDie, LinkageName);
+  if (DeclLinkageName.empty()) {
+    // Whether to emit this can depend on whether it's abstract.
+    bool Abstract = DU->getAbstractSPDies().lookup(SP);
+    addLinkageName(SPDie, LinkageName, Abstract);
+  }
 
   if (!DeclDie)
     return false;
 
   // Refer to the function declaration where all the other attributes will be
   // found.
   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
   return true;
 }

test/DebugInfo/Generic/PR20038.ll

 ; REQUIRES: object-emission
 
 ; For some reason, the output when targetting sparc is not quite as expected.
 ; XFAIL: sparc
 
-; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=Enable < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 ; IR generated from clang -O0 with:
 ; struct C {
 ;   ~C();
 ; };
 ; extern bool b;
 ; void fun4() { b && (C(), 1); }
 ; __attribute__((always_inline)) C::~C() { }

test/DebugInfo/Generic/cross-cu-inlining.ll

 ; REQUIRES: object-emission
 
-; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=Enable < %s | llvm-dwarfdump -debug-dump=info - | FileCheck -implicit-check-not=DW_TAG %s
-; RUN: %llc_dwarf -dwarf-accel-tables=Enable -dwarf-linkage-names=Enable -O0 -filetype=obj < %s | llvm-dwarfdump - | FileCheck --check-prefix=CHECK-ACCEL --check-prefix=CHECK %s
+; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -debug-dump=info - | FileCheck -implicit-check-not=DW_TAG %s
+; RUN: %llc_dwarf -dwarf-accel-tables=Enable -dwarf-linkage-names=All -O0 -filetype=obj < %s | llvm-dwarfdump - | FileCheck --check-prefix=CHECK-ACCEL --check-prefix=CHECK %s
 
 ; Build from source:
 ; $ clang++ a.cpp b.cpp -g -c -emit-llvm
 ; $ llvm-link a.bc b.bc -o ab.bc
 ; $ opt -inline ab.bc -o ab-opt.bc
 ; $ cat a.cpp
 ; extern int i;
 ; int func(int);

test/DebugInfo/Generic/enum-types.ll

 ; REQUIRES: object-emission
 ;
-; RUN: %llc_dwarf -filetype=obj -O0 -dwarf-linkage-names=Enable < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: %llc_dwarf -filetype=obj -O0 -dwarf-linkage-names=All < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 ; Make sure we can handle enums with the same identifier but in enum types of
 ; different compile units.
 ; rdar://17628609
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: 0x[[ENUM:.*]]: DW_TAG_enumeration_type
 ; CHECK-NEXT:   DW_AT_name {{.*}} "EA"

test/DebugInfo/Generic/linkage-name-abstract.ll

+; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=Abstract < %s | llvm-dwarfdump -debug-dump=info - > %t
+; RUN: FileCheck %s -check-prefix=ONENAME < %t
+; RUN: FileCheck %s -check-prefix=REF < %t 
+; Verify tuning for SCE gets us Abstract only.
+; RUN: %llc_dwarf -O0 -filetype=obj -debugger-tune=sce < %s | llvm-dwarfdump -debug-dump=info - > %t
+; RUN: FileCheck %s -check-prefix=ONENAME < %t
+; RUN: FileCheck %s -check-prefix=REF < %t 
+; REQUIRES: object-emission
+
+; Verify that the only linkage-name present is the abstract origin of the
+; inlined subprogram.
+
+; IR generated from clang -O0 with:
+; void f1();
+; __attribute__((always_inline)) void f2() { 
+;   f1();
+; }
+; void f3() {
+;   f2();
+; }
+
+; Show that there's only one linkage_name.
+; ONENAME:     {{DW_AT(_MIPS)?_linkage_name}}
+; ONENAME-NOT: {{DW_AT(_MIPS)?_linkage_name}}
+
+; Locate the subprogram DIE with the linkage name.
+; Show that the inlined_subroutine refers to it.
+; REF:     DW_TAG_subprogram
+; REF:     [[FOO:0x.*]]: DW_TAG_subprogram
+; REF-NOT: {{DW_TAG|NULL}}
+; REF:     {{DW_AT(_MIPS)?_linkage_name}}
+; REF:     DW_TAG_inlined_subroutine
+; REF-NOT: {{DW_TAG|NULL}}
+; REF:     DW_AT_abstract_origin {{.*}} {[[FOO]]}
+
+; Function Attrs: alwaysinline uwtable
+define void @_Z2f2v() #0 !dbg !4 {
+entry:
+  call void @_Z2f1v(), !dbg !11
+  ret void, !dbg !12
+}
+
+declare void @_Z2f1v()
+
+; Function Attrs: uwtable
+define void @_Z2f3v() #2 !dbg !7 {
+entry:
+  call void @_Z2f1v(), !dbg !13
+  ret void, !dbg !15
+}
+
+attributes #0 = { alwaysinline uwtable }
+attributes #2 = { uwtable }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!8, !9}
+!llvm.ident = !{!10}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 (trunk 265282)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, subprograms: !3)
+!1 = !DIFile(filename: "linkage-name-abstract.cpp", directory: "/home/probinson/projects/scratch")
+!2 = !{}
+!3 = !{!4, !7}
+!4 = distinct !DISubprogram(name: "f2", linkageName: "_Z2f2v", scope: !1, file: !1, line: 2, type: !5, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{null}
+!7 = distinct !DISubprogram(name: "f3", linkageName: "_Z2f3v", scope: !1, file: !1, line: 5, type: !5, isLocal: false, isDefinition: true, scopeLine: 5, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{!"clang version 3.9.0 (trunk 265282)"}
+!11 = !DILocation(line: 3, column: 3, scope: !4)
+!12 = !DILocation(line: 4, column: 1, scope: !4)
+!13 = !DILocation(line: 3, column: 3, scope: !4, inlinedAt: !14)
+!14 = distinct !DILocation(line: 6, column: 3, scope: !7)
+!15 = !DILocation(line: 7, column: 1, scope: !7)

test/DebugInfo/Generic/namespace.ll

 ; REQUIRES: object-emission
 
-; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=Enable < %s | llvm-dwarfdump - | FileCheck %s
+; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump - | FileCheck %s
 ; CHECK: debug_info contents
 ; CHECK: [[NS1:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK-NEXT: DW_AT_name{{.*}} = "A"
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F1:".*debug-info-namespace.cpp"]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(5)
 ; CHECK-NOT: NULL
 ; CHECK: [[NS2:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK-NEXT: DW_AT_name{{.*}} = "B"

test/DebugInfo/Generic/namespace_function_definition.ll

 ; REQUIRES: object-emission
 
-; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=Enable < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 ; Generated from clang with the following source:
 ; namespace ns {
 ; void func() {
 ; }
 ; }
 
 ; CHECK: DW_TAG_namespace

test/DebugInfo/Generic/namespace_inline_function_definition.ll

 ; REQUIRES: object-emission
 
-; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=Enable < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 ; Generate from clang with the following source. Note that the definition of
 ; the inline function follows its use to workaround another bug that should be
 ; fixed soon.
 ; namespace ns {
 ; int func(int i);
 ; }
 ; extern int x;

test/Linker/type-unique-odr-a.ll

 ; REQUIRES: default_triple, object-emission
 ;
-; RUN: llvm-link %s %p/type-unique-odr-b.ll -S -o - | %llc_dwarf -dwarf-linkage-names=Enable -filetype=obj -O0 | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: llvm-link %s %p/type-unique-odr-b.ll -S -o - | %llc_dwarf -dwarf-linkage-names=All -filetype=obj -O0 | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ;
 ; Test ODR-based type uniquing for C++ class members.
 ; rdar://problem/15851313.
 ;
 ; $ cat -n type-unique-odr-a.cpp
 ;     1 class A {
 ;     2   int data;
 ;     3 protected: