Set a debugger "target" to guide DWARF choices

[probinson]

Summary

Debuggers have different preferences regarding various bits of DWARF.
Invent a debugger "target" to clarify the choices, and also simplify testing.
A follow-up patch will plumb this through from Clang.

[aprantl]

It's unfortunate that this is necessary, but it is definitely preferable over having platform-specific behavior.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

245

This should probably be IsDebuggerLLDB() instead of IsDarwin.

[probinson]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

214

Should this set LLDB for Darwin? I wasn't sure.

245

OK.

[aprantl]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

214

Yes, recent versions of Darwin ship with LLDB as the system debugger.

[ygao]

Do these debuggers preserve their peculiar behaviors from version to version? Do we need to identify the version of the debugger too? For example, gdb 7.2 versus gdb 7.9.

[probinson]

Update per Adrian's feedback.

[probinson]

In D8506#145780, @ygao wrote:

Do these debuggers preserve their peculiar behaviors from version to version? Do we need to identify the version of the debugger too? For example, gdb 7.2 versus gdb 7.9.

I think mostly debuggers are pretty consistent about things from one version to the next. I haven't run into anything that would suggest knowing about debugger versions was really necessary.

[probinson]

Ping.

[aprantl]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

211

Should we rename DebuggerKind::Any to TargetDefault or just Default?

[probinson]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

211

"Default" works for me. I originally had some vague notion about a generic target, so "Any," but getting that to work right is surely more trouble than it's worth. "Default" better expresses that it will actually turn into something specific.

[probinson]

include/llvm/CodeGen/CommandFlags.h

236

Maybe this should be "debugger-tune" instead of "target" so that it implies smaller kinds of differences. It's certainly a lot less radical than most uses of "target" within LLVM.

[aprantl]

Agreed. Target should be reserved for something on the scale of DWARF versus PDB.

[aprantl]

I have one more request: This should come with a guideline or at least some examples for what kind of changes constitute "tuning". Our primary goal should still be to emit standards-compliant DWARF. Or maybe the primary goal is to support existing debuggers and following the standard is second, but we probably should discuss this.

[probinson]

In D8506#163418, @aprantl wrote:

I have one more request: This should come with a guideline or at least some examples for what kind of changes constitute "tuning". Our primary goal should still be to emit standards-compliant DWARF. Or maybe the primary goal is to support existing debuggers and following the standard is second, but we probably should discuss this.

That should happen on the dev lists, and obviously I should kick it off... I think with a new topic, as the previous one had "target" in the subject and we're agreed not to use that term for what this is about.
It's also not really obvious to me where such a guideline ought to be placed. But we can debate that on-list as well.

Something odd is going on with clang right now, I'll refresh this patch tomorrow and start that discussion.

[probinson]

Update to describe this as "tuning" rather than a "target."

[echristo]

Inline comments.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

211–219

I might have lost this part of the discussion but I thought the default was "no tuning"?

At least not in the backend.

235

This should be simplified to tuneDebugForGDB().

247

I don't think this is a tuning option, and that's the problem. This is a correctness issue in that it just won't work rather than being inefficient or superfluous.

test/DebugInfo/X86/dwarf-public-names.ll

7–10

I think I'd like this split out into a different test file.

[probinson]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

211–219

That did come up, and it was not clear what it should mean, so I fell back on preserving the prior behavior, which effectively defaults to GDB except for Darwin and PS4.

So, what would no-tuning mean? "No non-standard things" seems reasonably clear, but should it include all the optional-but-standard things that LLVM knows how to do? Which I guess would be pubnames + aranges + type units (are there more?).
It would smoke out all the tests that have been relying on the triple to get the right effect, though, which could be viewed as a Good Thing.

Presumably you'd want Clang to tell LLVM what tuning to use, though? Having Clang default to "no tuning" seems user-hostile.

225

Should this become tuneDebugForLLDB()?

235

Okay. Not being Darwin-aware or an LLDB user, I was a bit reluctant to convert all the Darwin decision-making right away.

247

Yeah, trying to work around a GDB bug. GDB can't tolerate the standard opcode; SCE can't tolerate the GNU opcode; I don't know what LLDB thinks, but Adrian liked having the standard opcode.
Do you have an alternate suggestion? Leaving it target-based seems worse, except for the historical consistency.

test/DebugInfo/X86/dwarf-public-names.ll

7–10

Ironically, this is one of the tests that would break if LLVM defaulted to no-tuning; the triples would need to be replaced by tuning options. And if tuning isn't premised on the triple, then the non-default triple/tuning combos wouldn't need testing, and the new RUN lines would just go away.

[emaste]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

213

Note that on FreeBSD as on Darwin we set -fstandalone-debug by default.

[probinson]

Refresh and address specific review comments:

• pubsections based on tuning for GDB (this is correct only if "no tuning" isn't an option)
• revert TLS opcode choice to platform-based instead of tuning-based; Eric and Adrian need to work that one out, right now I'm following the most recent expressed wish of the code owner even though I agree with Adrian
• move test to a separate file
• setting the default tuning remains triple-based; changing the defaults for other targets can wait for follow-up patches

I did experiment with "default to no tuning." While tests basically
worked, it exposed one minor flaw in dwarf-public-names.ll (diff
included here although it really ought to be committed separately).
However, a no-tuning default would be a distinct functional change,
not backward compatible, as pointed out by David Blaikie; so I didn't
do that in the patch.

We might still want to have a more Target-based way to specify a
default tuning, rather than using the triple, but that could be a
followup patch. Note that people associated with FreeBSD and with
Hexagon have both expressed a desire to default to LLDB.

[probinson]

Add long-ago promised guidance commentary to DwarfDebug.h.
I've had time to make it shorter. ;-)

[probinson]

Ping.

[probinson]

Ping.

[aprantl]

I believe that FreeBSD should also default to LLDB (cf. https://wiki.freebsd.org/GdbRetirement).

Otherwise this is good from my point of view; I'll defer to Eric for his comments.

[probinson]

FreeBSD now defaults to LLDB tuning.

@Eric, can we finish this off? (I'm on vacation next week.)

[dblaikie]

Looks plausible. Though the command line flag should really only be used for testing, I think - you'll want another way to specify it for actual exposure through clang, etc, if you want/need to expose it.

include/llvm/CodeGen/CommandFlags.h

236

What's the command line argument for? I mean convenience of testing LLVM, a bit, but in general we don't want to use backend options like this when actually interacting with LLVM from Clang and other frontends. This should probably end up as a part of the CU debug info metadata? Or a module-level debug info metadata flag? (ala DWARF version)

test/DebugInfo/X86/dwarf-public-names.ll

42

what happened to these two checks in this test?

[probinson]

include/llvm/CodeGen/CommandFlags.h

236

The command line option is precisely for testing; it is not how Clang communicates to LLVM.
CommandFlags.h exists to define command-line options for the tools (llc, opt etc) only. It does not define a command-line option that is accessible to Clang.
Clang will set the TargetOptions field directly.

test/DebugInfo/X86/dwarf-public-names.ll

42

As originally written, this check does not fail if there is actually a debug_pubnames section, because it didn't insist that the empty line was immediately following the "debug_pubnames" header line. Instead it would match the empty line at the end of the debug_pubnames dump, and pass.
I made the same change on the LINUX path just for consistency.

This test update could actually be committed independently if you'd rather, as it's fixing a bug in the test rather than actually testing something I did in the rest of the patch.

[probinson]

include/llvm/CodeGen/CommandFlags.h

236

David pointed out in email that using a TargetOptions field, it is hard to test that Clang got it right, and might not play nicely with LTO. I'll look at doing it with module-level metadata.

test/DebugInfo/X86/dwarf-public-names.ll

42

Committed separately as r240679.

[echristo]

Some inline comments.

-eric

include/llvm/CodeGen/CommandFlags.h

236

Module level metadata is a possibility if we think it's something that we'll need to make sure stays consistent at LTO time etc. You'll need to define a way for the metadata to merge, etc. I don't necessarily like encoding the data this way, but without a later LTO codegen pass we can pass options to it's your best bet.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

222–223

Feel free to update this comment separately.

245

I don't like the use of TT.isPS4CPU() here on first look, can you explain a bit?

[probinson]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

222–223

Hm? The comment update reflects the code change for setting HasDwarfPubSections (line 235). Did you have something else in mind?

245

IsPS4 had been a bool field in the class, but as it was never used outside the constructor that seemed unnecessary so I removed it.
I capture the triple once (line 212) as it's not all that cheap, and lets me decide about PS4 as well as FreeBSD (see lines 214 and 216).
I could capture IsPS4 as a local bool if you'd prefer, as I do make that test twice, but isPS4CPU() is relatively cheap so it didn't seem worthwhile.

[probinson]

Move the tuning parameter out of TargetOptions, it's private to DwarfDebug now.
If you don't mind I'd prefer to do the metadata thing in a separate follow-up patch.

[probinson]

Ping

[echristo]

Replied inline. Some of this probably feels a bit vague, let me know if you've got any questions :)

-eric

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

222–223

Yeah, anything you're changing under the default (or triple) mode should go into a separate patch I'd think?

222–230

I've actually come around to thoughts of a triple based set of defaults. I.e. go ahead and use the triple to default behaviors like this and use the tuning parameter otherwise. i.e. feature based on the default debugger for the platform. It'll involve splitting this patch up a bit (see previous comment) but that seems reasonable yes?

225

For now yes. Post-dwarf5 it'll be more interesting.

245

Yeah. I agree with Adrian here. Let's use "isDebuggerLLDB()".

247

Yeah, let's put it with tuning with a what you just said as a comment (if you have a gdb bug to point at that'd be good).

lib/CodeGen/AsmPrinter/DwarfDebug.h

563–580

This could all go with the enum.

581–583

Possibly rename without using Debug. We're in the debug code already.

[aprantl]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

247

https://llvm.org/bugs/show_bug.cgi?id=18423
points to
Bug 11616 - DW_OP_form_tls_address is unimplemented
(https://sourceware.org/bugzilla/show_bug.cgi?id=11616)

[probinson]

Sorry, I couldn't really work out which things you wanted directly from triples and which would be from tuning. I'm not 100% sure phab is lining up the inline comments with the right source lines. I think I got everything else you wanted. New patch coming directly.

[probinson]

Updated patch. Because the TLS opcode is based on tuning now, and FreeBSD defaults to LLDB, I had to tweak one more test.

[echristo]

I'm a bit unhappy with the TLS op tuning, but I don't have any better ideas. It's less tuning and more correctness, but...

Anyhow, an inline comment about one of your FIXMEs, otherwise LGTM.

Thanks for all of the iterations here.

-eric

test/DebugInfo/X86/debugger-tune.ll

5

Are you using the same accelerator tables?

[probinson]

test/DebugInfo/X86/debugger-tune.ll

5

No we're not. Originally the accelerator tables were still "for Darwin" not "for LLDB" but having changed that, I can use that to take care of this FIXME. Thanks!

include/llvm/CodeGen/CommandFlags.h

JTableType("jump-table-type",
               clEnumValN(JumpTable::Arity, "arity",
                          "Create one table per number of parameters."),
               clEnumValN(JumpTable::Simplified, "simplified",
                          "Create one table per simplified function type."),
               clEnumValN(JumpTable::Full, "full",
                          "Create one table per unique function type."),
               clEnumValEnd));
 
+cl::opt<DebuggerKind>
+DebuggerTuning("debugger-tune",
+               cl::desc("Tune debug info for a particular debugger"),
+               cl::init(DebuggerKind::Default),
+               cl::values(
+                   clEnumValN(DebuggerKind::GDB, "gdb", "gdb"),
+                   clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"),
+                   clEnumValN(DebuggerKind::SCE, "sce",
+                              "SCE targets (e.g. PS4)"),
+                   clEnumValEnd));
+
 // Common utility function tightly tied to the options listed here. Initializes
 // a TargetOptions object with CodeGen flags and returns it.
 static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   TargetOptions Options;
   Options.LessPreciseFPMADOption = EnableFPMAD;
   Options.AllowFPOpFusion = FuseFPOps;
   Options.Reciprocals = TargetRecip(ReciprocalOps);
   Options.UnsafeFPMath = EnableUnsafeFPMath;
static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.PositionIndependentExecutable = EnablePIE;
   Options.UseInitArray = !UseCtors;
   Options.DataSections = DataSections;
   Options.FunctionSections = FunctionSections;
   Options.UniqueSectionNames = UniqueSectionNames;
 
   Options.MCOptions = InitMCTargetOptionsFromFlags();
   Options.JTType = JTableType;
+  Options.DebuggerTuning = DebuggerTuning;
 
   Options.ThreadModel = TMModel;
 
   return Options;
 }
 
 static inline std::string getCPUStr() {
   // If user asked for the 'native' CPU, autodetect here. If autodection fails,

include/llvm/Target/TargetOptions.h

namespace llvm {
 
   namespace ThreadModel {
     enum Model {
       POSIX,  // POSIX Threads
       Single  // Single Threaded Environment
     };
   }
 
+  enum class DebuggerKind {
+    Default,  // No specific tuning.
+    GDB,      // Tune debug info for gdb.
+    LLDB,     // Tune debug info for lldb.
+    SCE       // Tune debug info for SCE targets (e.g. PS4).
+  };
+
   class TargetOptions {
   public:
     TargetOptions()
         : PrintMachineCode(false),
           LessPreciseFPMADOption(false), UnsafeFPMath(false),
           NoInfsFPMath(false), NoNaNsFPMath(false),
           HonorSignDependentRoundingFPMathOption(false),
           NoZerosInBSS(false),
           GuaranteedTailCallOpt(false),
           StackAlignmentOverride(0),
           EnableFastISel(false), PositionIndependentExecutable(false),
           UseInitArray(false), DisableIntegratedAS(false),
           CompressDebugSections(false), FunctionSections(false),
           DataSections(false), UniqueSectionNames(true), TrapUnreachable(false),
           TrapFuncName(), FloatABIType(FloatABI::Default),
           AllowFPOpFusion(FPOpFusion::Standard), Reciprocals(TargetRecip()),
           JTType(JumpTable::Single),
-          ThreadModel(ThreadModel::POSIX) {}
+          ThreadModel(ThreadModel::POSIX),
+          DebuggerTuning(DebuggerKind::Default) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
     /// output from the code generator.
     unsigned PrintMachineCode : 1;
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
public:
     /// JTType - This flag specifies the type of jump-instruction table to
     /// create for functions that have the jumptable attribute.
     JumpTable::JumpTableType JTType;
 
     /// ThreadModel - This flag specifies the type of threading model to assume
     /// for things like atomics
     ThreadModel::Model ThreadModel;
 
+    /// Which debugger are we expecting to consume the debug info?
+    DebuggerKind DebuggerTuning;
+
     /// Machine level options.
     MCTargetOptions MCOptions;
   };
 
 // Comparison operators:
 
 
 inline bool operator==(const TargetOptions &LHS,

lib/CodeGen/AsmPrinter/DwarfDebug.h

 #include "llvm/CodeGen/DIE.h"
 #include "llvm/CodeGen/LexicalScopes.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MachineLocation.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
 #include <memory>
 
 namespace llvm {
 
 class AsmPrinter;
 class ByteStreamer;
 class ConstantInt;
 class ConstantFP;
class DwarfDebug : public AsmPrinterHandler {
   // FIXME: replace this with a map from comp_dir to table so that we can emit
   // multiple tables during LTO each of which uses directory 0, referencing the
   // comp_dir of all the type units that use it.
   MCDwarfDwoLineTable SplitTypeUnitFileTable;
 
   // True iff there are multiple CUs in this module.
   bool SingleCU;
   bool IsDarwin;
-  bool IsPS4;
 
   AddressPool AddrPool;
 
   DwarfAccelTable AccelNames;
   DwarfAccelTable AccelObjC;
   DwarfAccelTable AccelNamespace;
   DwarfAccelTable AccelTypes;
 
public:
   void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
     SymSize[Sym] = Size;
   }
 
   /// \brief 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; }
 
+  // The "debugger tuning" concept allows us to present a more intuitive
+  // interface that unpacks into different sets of defaults for the various
+  // individual feature-flag settings, that suit the preferences of the
+  // various debuggers.  However, it's worth remembering that debuggers are
+  // not the only consumers of debug info, and some variations in DWARF might
+  // better be treated as target/platform issues. Fundamentally,
+  // o if the feature is useful (or not) to a particular debugger, regardless
+  //   of the target, that's a tuning decision;
+  // o if the feature is useful (or not) on a particular platform, regardless
+  //   of the debugger, that's a target decision.
+  // It's not impossible to see both factors in some specific case.
+  //
+  /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger.
+  ///
+  /// The "tuning" predicates should be used to set defaults for individual
+  /// feature flags in DwarfDebug; if a given feature has a more specific
+  /// command-line option, that option should take precedence over the tuning.
+  /// @{
+  bool tuneDebugForGDB() const {
+    return Asm->TM.Options.DebuggerTuning == DebuggerKind::GDB;
+  }
+  bool tuneDebugForLLDB() const {
+    return Asm->TM.Options.DebuggerTuning == DebuggerKind::LLDB;
+  }
+  bool tuneDebugForSCE() const {
+    return Asm->TM.Options.DebuggerTuning == DebuggerKind::SCE;
+  }
+  /// @}
+
   // Experimental DWARF5 features.
 
   /// \brief Returns whether or not to emit tables that dwarf consumers can
   /// use to accelerate lookup.
   bool useDwarfAccelTables() const { return HasDwarfAccelTables; }
 
   /// \brief Returns whether or not to change the current debug info for the
   /// split dwarf proposal support.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
     DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
 
 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
     : Asm(A), MMI(Asm->MMI), DebugLocs(A->OutStreamer->isVerboseAsm()),
       PrevLabel(nullptr), InfoHolder(A, "info_string", DIEValueAllocator),
       UsedNonDefaultText(false),
       SkeletonHolder(A, "skel_string", DIEValueAllocator),
       IsDarwin(Triple(A->getTargetTriple()).isOSDarwin()),
-      IsPS4(Triple(A->getTargetTriple()).isPS4()),
       AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
                                        dwarf::DW_FORM_data4)),
       AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
                                       dwarf::DW_FORM_data4)),
       AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
                                            dwarf::DW_FORM_data4)),
       AccelTypes(TypeAtoms) {
 
   CurFn = nullptr;
   CurMI = nullptr;
 
+  // Make sure we know our "debugger tuning."
+  Triple TT(Asm->getTargetTriple());
+  if (Asm->TM.Options.DebuggerTuning == DebuggerKind::Default) {
+    if (IsDarwin || TT.isOSFreeBSD())
+      Asm->TM.Options.DebuggerTuning = DebuggerKind::LLDB;
+    else if (TT.isPS4CPU())
+      Asm->TM.Options.DebuggerTuning = DebuggerKind::SCE;
+    else
+      Asm->TM.Options.DebuggerTuning = DebuggerKind::GDB;
+  }
+
   // Turn on accelerator tables for Darwin by default, pubnames by
-  // default for non-Darwin/PS4, and handle split dwarf.
+  // default for GDB, and handle split dwarf.
   if (DwarfAccelTables == Default)
     HasDwarfAccelTables = IsDarwin;
   else
     HasDwarfAccelTables = DwarfAccelTables == Enable;
 
   if (SplitDwarf == Default)
     HasSplitDwarf = false;
   else
     HasSplitDwarf = SplitDwarf == Enable;
 
   if (DwarfPubSections == Default)
-    HasDwarfPubSections = !IsDarwin && !IsPS4;
+    HasDwarfPubSections = tuneDebugForGDB();
   else
     HasDwarfPubSections = DwarfPubSections == Enable;
 
   unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
   DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
                                     : MMI->getModule()->getDwarfVersion();
 
   // Darwin and PS4 use the standard TLS opcode (defined in DWARF 3).
   // Everybody else uses GNU's.
-  UseGNUTLSOpcode = !(IsDarwin || IsPS4) || DwarfVersion < 3;
+  UseGNUTLSOpcode = !(IsDarwin || TT.isPS4CPU()) || DwarfVersion < 3;
 
   Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
 
   {
     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
     beginModule();
   }
 }
 
 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.

test/DebugInfo/X86/debugger-tune.ll

+; Verify target-based defaults for "debugger tuning," and the ability to
+; override defaults.
+; We use existence of the .debug_pubnames section to distinguish the GDB case.
+; FIXME: Find something to distinguish LLDB from SCE.
+
+; RUN: llc -mtriple=x86_64-scei-ps4 -filetype=obj < %s | llvm-dwarfdump -debug-dump=pubnames - | FileCheck --check-prefix=NOPUB %s
+; RUN: llc -mtriple=x86_64-scei-ps4 -filetype=obj -debugger-tune=gdb < %s | llvm-dwarfdump -debug-dump=pubnames - | FileCheck --check-prefix=YESPUB %s
+; RUN: llc -mtriple=x86_64-apple-darwin12 -filetype=obj < %s | llvm-dwarfdump -debug-dump=pubnames - | FileCheck --check-prefix=NOPUB %s
+; RUN: llc -mtriple=x86_64-apple-darwin12 -filetype=obj -debugger-tune=gdb < %s | llvm-dwarfdump -debug-dump=pubnames - | FileCheck --check-prefix=YESPUB %s
+; RUN: llc -mtriple=x86_64-pc-linux -filetype=obj < %s | llvm-dwarfdump -debug-dump=pubnames - | FileCheck --check-prefix=YESPUB %s
+; RUN: llc -mtriple=x86_64-pc-linux -filetype=obj -debugger-tune=lldb < %s | llvm-dwarfdump -debug-dump=pubnames - | FileCheck --check-prefix=NOPUB %s
+; RUN: llc -mtriple=x86_64-pc-freebsd -filetype=obj < %s | llvm-dwarfdump -debug-dump=pubnames - | FileCheck --check-prefix=NOPUB %s
+
+; NOPUB: debug_pubnames
+; NOPUB-NEXT: {{^$}}
+
+; YESPUB: debug_pubnames
+; YESPUB-NEXT: length
+
+@globalvar = global i32 0, align 4
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!6, !7}
+!llvm.ident = !{!8}
+
+!0 = !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.7.0 (trunk 238808)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !2, globals: !3, imports: !2)
+!1 = !DIFile(filename: "debug-tune-nondefault.cpp", directory: "/home/probinson/projects/scratch")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIGlobalVariable(name: "globalvar", scope: !0, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, variable: i32* @globalvar)
+!5 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!6 = !{i32 2, !"Dwarf Version", i32 4}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{!"clang version 3.7.0 (trunk 238808)"}

test/DebugInfo/X86/dwarf-public-names.ll

 ; RUN: llc -mtriple=x86_64-pc-linux-gnu -filetype=obj -o %t.o < %s
 ; RUN: llvm-dwarfdump -debug-dump=pubnames %t.o | FileCheck --check-prefix=LINUX %s
 ; RUN: llc -mtriple=x86_64-apple-darwin12 -filetype=obj -o %t.o < %s
 ; RUN: llvm-dwarfdump -debug-dump=pubnames %t.o | FileCheck --check-prefix=NOPUB %s
 ; RUN: llc -mtriple=x86_64-scei-ps4 -filetype=obj -o %t.o < %s
 ; RUN: llvm-dwarfdump -debug-dump=pubnames %t.o | FileCheck --check-prefix=NOPUB %s
 ; ModuleID = 'dwarf-public-names.cpp'
 ;
 ; Generated from:
 ;
 ; struct C {
 ;   void member_function();
 ;   static int static_member_function();
 ;   static int static_member_variable;
 ; };
 ;
 ; int C::static_member_variable = 0;
 ;

 ;   void global_namespace_function() {
 ;     global_variable.member_function();
 ;   }
 ;   int global_namespace_variable = 1;
 ; }
 
 ; Darwin and PS4 shouldn't be generating the section by default
 ; NOPUB: debug_pubnames
-; NOPUB: {{^$}}
+; NOPUB-NEXT: {{^$}}
 
 ; Skip the output to the header of the pubnames section.
 ; LINUX: debug_pubnames
-; LINUX: unit_size = 0x00000128
+; LINUX-NEXT: unit_size = 0x00000128
 
 ; Check for each name in the output.
 ; LINUX-DAG: "ns"
 ; LINUX-DAG: "C::static_member_function"
 ; LINUX-DAG: "global_variable"
 ; LINUX-DAG: "ns::global_namespace_variable"
 ; LINUX-DAG: "ns::global_namespace_function"
 ; LINUX-DAG: "global_function"