Command-line options to set debugger "target"

[probinson]

Summary

The Clang side of the debugger "target" patches. Slightly repurpose -ggdb and
add -glldb and -gsce to set GDB, LLDB, or PS4 as the "debugger target."
This is thematically consistent with GCC options such as -ggdb and -gvms.
No Clang functionality depends on this yet, although conditionally importing
anonymous namespaces (in review) could use this instead of a triple test.

The LLVM part is available at http://reviews.llvm.org/D8506

I'll whip up the obvious -### driver test but thought I'd put this out now.

[probinson]

Reposting the initial comment as I hit "save" before setting reviewers/subscribers...

The Clang side of the debugger "target" patches. Slightly repurpose -ggdb and
add -glldb and -gsce to set GDB, LLDB, or PS4 as the "debugger target."
This is thematically consistent with GCC options such as -ggdb and -gvms.
No Clang functionality depends on this yet, although conditionally importing
anonymous namespaces (in review) could use this instead of a triple test.

The LLVM part is available at http://reviews.llvm.org/D8506

I'll whip up the obvious -### driver test but thought I'd put this out now.

[dblaikie]

include/clang/Driver/Options.td

1051

Is SCE usually pronounced with each letter separately, or as a word ("ski" or similar)? (wondering whether "an SCE target" or "a SCE target" is correct)

include/clang/Frontend/CodeGenOptions.def

159

I take it that GDB is the default here? But ignored in the frontend or driver in favor of platform-specific defaults?

lib/Frontend/CompilerInvocation.cpp

408

Should this handling be up in the driver? Then it should be easy to write tests for the defaults.

[probinson]

include/clang/Driver/Options.td

1051

SCE = ess see ee (Sony Computer Entertainment)
There is a European division, SCEE, which I have heard pronounced as "ski."

include/clang/Frontend/CodeGenOptions.def

159

Well, it seems to be customary to put a default here, and then initialize the field explicitly elsewhere anyway without relying on the default value. I didn't exhaustively check every field, but eyeballing a handful it was certainly the pattern.
The most entertaining case was DwarfVersion.

lib/Frontend/CompilerInvocation.cpp

408

No, it should be here, so we can specify a debugger target for -cc1 tests.
There aren't any use-cases for that yet, but Katya's import-anonymous-namespace patch could use it, once it goes in.

[echristo]

You could handle some of the DW_AT_APPLE foo things that way?

-eric

[dblaikie]

lib/Frontend/CompilerInvocation.cpp

408

Sorry - I mean specifically the cases a few lines down that test isOSDarwin and isPS4CPU - I imagine those should be handled in the driver (sorry, I looked at this block of code & assumed it all dealt with defaults, etc) - and this code should then be simpler and just set the debugger based on which debugger flag is passed down (& possibly rely on the default if no debugger is specified)

[probinson]

In D8599#147004, @echristo wrote:

You could handle some of the DW_AT_APPLE foo things that way?

-eric

That would be on the LLVM side, and somebody would have to decide whether debugger-target or a triple check is the more appropriate condition. But, yeah.

[probinson]

lib/Frontend/CompilerInvocation.cpp

408

Oh, I see. Yes, that would make sense.

[probinson]

Update the debug-options.c test to include the debugger target.
Move target-specific defaulting decisions into the driver.
Update how options are handled in the driver (yay tests!).

[dblaikie]

test/Driver/debug-options.c

32 ↗

(On Diff #22692)

Given that -g<debugger> and -g<debug level> are orthogonal (they are, right? Judging by your change they look orthogonal) we don't need to test all the combinations of them. I'd either just test them separately (g1, g2, g3, ggdb, glldb, gsce) or if want to really try to minimize the number of test cases, test them in ad-hoc pairs (g1+ggdb, g2+glldb, etc.) - though that can make things a bit harder to maintain later on (trying to decide if the pairing is significant or not, etc).

[aprantl]

The new options should probably also be mentioned in the man page (docs/tools/clang.pod).

[probinson]

Split into separate CC1 and Driver parts for easier reviewing.

include/clang/Driver/Options.td

def g_Flag : Flag<["-"], "g">, Group<g_Group>,
   HelpText<"Generate source-level debug information">, Flags<[CC1Option,CC1AsOption]>;
 def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<g_Group>,
   HelpText<"Emit debug line number tables only">, Flags<[CC1Option]>;
 def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
 def g0 : Flag<["-"], "g0">, Group<g_Group>;
 def g1 : Flag<["-"], "g1">, Group<g_Group>;
 def g2 : Flag<["-"], "g2">, Group<g_Group>;
 def g3 : Flag<["-"], "g3">, Group<g_Group>;
-def ggdb : Flag<["-"], "ggdb">, Group<g_Group>;
+def ggdb : Flag<["-"], "ggdb">, Group<g_Group>,
+  HelpText<"Tune debug info for gdb">, Flags<[CC1Option]>;
 def ggdb0 : Flag<["-"], "ggdb0">, Group<g_Group>;
 def ggdb1 : Flag<["-"], "ggdb1">, Group<g_Group>;
 def ggdb2 : Flag<["-"], "ggdb2">, Group<g_Group>;
 def ggdb3 : Flag<["-"], "ggdb3">, Group<g_Group>;
+def glldb : Flag<["-"], "glldb">, Group<g_flags_Group>,
+  HelpText<"Tune debug info for lldb">, Flags<[CC1Option]>;
+def gsce : Flag<["-"], "gsce">, Group<g_flags_Group>,
+  HelpText<"Tune debug info for an SCE target (e.g. PS4)">, Flags<[CC1Option]>;
 def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>,
   HelpText<"Generate source-level debug information with dwarf version 2">, Flags<[CC1Option,CC1AsOption]>;
 def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>,
   HelpText<"Generate source-level debug information with dwarf version 3">, Flags<[CC1Option,CC1AsOption]>;
 def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>,
   HelpText<"Generate source-level debug information with dwarf version 4">, Flags<[CC1Option,CC1AsOption]>;
 def gfull : Flag<["-"], "gfull">, Group<g_Group>;
 def gused : Flag<["-"], "gused">, Group<g_Group>;

include/clang/Frontend/CodeGenOptions.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_FRONTEND_CODEGENOPTIONS_H
 #define LLVM_CLANG_FRONTEND_CODEGENOPTIONS_H
 
 #include "clang/Basic/Sanitizers.h"
 #include "llvm/Support/Regex.h"
+#include "llvm/Target/TargetOptions.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 
 /// \brief Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure
 /// that this large collection of bitfields is a trivial class type.

include/clang/Frontend/CodeGenOptions.def

 VALUE_CODEGENOPT(NumRegisterParameters, 32, 0)
 
 /// The lower bound for a buffer to be considered for stack protection.
 VALUE_CODEGENOPT(SSPBufferSize, 32, 0)
 
 /// The kind of generated debug info.
 ENUM_CODEGENOPT(DebugInfo, DebugInfoKind, 3, NoDebugInfo)
 
+/// Which debugger we are targeting.
+ENUM_CODEGENOPT(Debugger, llvm::DebuggerKind, 2, llvm::DebuggerKind::GDB)
+
 /// Dwarf version.
 VALUE_CODEGENOPT(DwarfVersion, 3, 0)
 
 /// The kind of inlining to perform.
 ENUM_CODEGENOPT(Inlining, InliningMethod, 2, NoInlining)
 
 // Vector functions library to use.
 ENUM_CODEGENOPT(VecLib, VectorLibrary, 1, NoLibrary)
 
 /// The default TLS model to use.
 ENUM_CODEGENOPT(DefaultTLSModel, TLSModel, 2, GeneralDynamicTLSModel)
 
 #undef CODEGENOPT
 #undef ENUM_CODEGENOPT
 #undef VALUE_CODEGENOPT
 

lib/CodeGen/BackendUtil.cpp

TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
   Options.UseSoftFloat = CodeGenOpts.SoftFloat;
   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
   Options.DisableTailCalls = CodeGenOpts.DisableTailCalls;
   Options.TrapFuncName = CodeGenOpts.TrapFuncName;
   Options.PositionIndependentExecutable = LangOpts.PIELevel != 0;
   Options.FunctionSections = CodeGenOpts.FunctionSections;
   Options.DataSections = CodeGenOpts.DataSections;
   Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
+  Options.Debugger = CodeGenOpts.getDebugger();
 
   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
   Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
   Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
   Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
   Options.MCOptions.ABIName = TargetOpts.ABI;

lib/Driver/Tools.cpp

else if (!A->getOption().matches(options::OPT_g0) &&
       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
           Triple.getOS() == llvm::Triple::FreeBSD ||
           Triple.getOS() == llvm::Triple::Solaris)
         CmdArgs.push_back("-gdwarf-2");
       else
         CmdArgs.push_back("-g");
     }
   }
+  // Pass along the debugger target, if specified.
+  // FIXME: Write a 3-arg version of AddLastArg instead?
+  if (Arg *A = Args.getLastArg(options::OPT_ggdb, options::OPT_glldb,
+                               options::OPT_gsce))
+    CmdArgs.push_back(Args.MakeArgString(A->getSpelling()));
 
   // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
   Args.ClaimAllArgs(options::OPT_g_flags_Group);
   if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
                    /*Default*/ true))
     CmdArgs.push_back("-dwarf-column-info");
 
   // FIXME: Move backend command line options to the module.

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   else if (Args.hasArg(OPT_gdwarf_3))
     Opts.DwarfVersion = 3;
   else if (Args.hasArg(OPT_gdwarf_4))
     Opts.DwarfVersion = 4;
   else if (Opts.getDebugInfo() != CodeGenOptions::NoDebugInfo)
     // Default Dwarf version is 4 if we are generating debug information.
     Opts.DwarfVersion = 4;
 
+  if (Args.hasArg(OPT_ggdb))
+    Opts.setDebugger(llvm::DebuggerKind::GDB);
+  else if (Args.hasArg(OPT_glldb))
+    Opts.setDebugger(llvm::DebuggerKind::LLDB);
+  else if (Args.hasArg(OPT_gsce))
+    Opts.setDebugger(llvm::DebuggerKind::SCE);
+  else if (llvm::Triple(TargetOpts.Triple).isOSDarwin())
+    Opts.setDebugger(llvm::DebuggerKind::LLDB);
+  else if (llvm::Triple(TargetOpts.Triple).isPS4CPU())
+    Opts.setDebugger(llvm::DebuggerKind::SCE);
+  else
+    Opts.setDebugger(llvm::DebuggerKind::GDB);
+
   Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
   Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
   Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
   Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
     OPT_fuse_register_sized_bitfield_access);
   Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
   Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);