Implement an "I'm dtrace, please retain all debug types" option.

[aprantl]

Summary

As noted in the review thread for http://reviews.llvm.org/D18477 on llvm-commits, DWARF consumers such as dtrace's ctfconvert expect debug info for types to survive even if the underlying code that references those types has been optimized away.
This patch moves this logic from the backend, where it used to be unconditionally executed, into clang. For more info on this functionality check out DwarfDebug::collectDeadVariables(), added in r107027.

This code in this patch listens to the driver option -gfull, and lowers it to the new cc1 option -debug-retain-types (1).
When -debug-retain-types is present, CGDebugInfo will retain every(2) type it creates.

Implementation notes:

1. I decided not use -fno-eliminate-unused-debug-symbols for consistency with our other cc1 debug options.
2. I’m minimizing the set of retained types by only retaining top-level types.

[aprantl]

Meanwhile I made an experiment and compiled XNU with D18477 and compared the debug info from before and after and found no missing types at all. It is plausible that r107027 was added to work around the fact that six years ago LLVM was a lot worse at preserving debug info for local variables. It is also possible that the call graph of the kernel changed in the mean time or a combination of both.

[dblaikie]

Okey dokey - I know one of the things we did (& I don't know when it
happened compared to this change) is emit a hard list of variables onto any
subprogram for an optimized (non -O0) function. So we never lose variables
due to optimizations, or at least that's the intent.

As for D18477, I'm not sure why collectDeadVariables became dead with your
change - I imagine we still want to stuff dead variables into the
subprograms we did create (the ones that weren't /entirely/ optimized away
(ones with remaining inlined instances, etc)) - but maybe we do that
elsewhere?

include/clang/Driver/CC1Options.td

 // CodeGen Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
 def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">;
 def dwarf_version_EQ : Joined<["-"], "dwarf-version=">;
 def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">;
+def debug_info_retain_types : Flag<["-"], "debug-info-retain-types">,
+  HelpText<"Retain debug info for types that were optimized away">;
 def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">,
   HelpText<"The compilation directory to embed in the debug info.">;
 def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">,
   HelpText<"The string to embed in the Dwarf debug flags record.">;
 def mno_exec_stack : Flag<["-"], "mnoexecstack">,
   HelpText<"Mark the file as not needing an executable stack">;
 def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
   HelpText<"Make assembler warnings fatal">;

include/clang/Frontend/CodeGenOptions.def

 
 CODEGENOPT(DebugTypeExtRefs, 1, 0) ///< Whether or not debug info should contain
                                    ///< external references to a PCH or module.
 
 CODEGENOPT(DebugExplicitImport, 1, 0)  ///< Whether or not debug info should 
                                        ///< contain explicit imports for 
                                        ///< anonymous namespaces
 
+CODEGENOPT(RetainAllDebugTypes, 1, 0) ///< Whether to keep debug types for
+                                      ///< code that is optimized away.
+
 CODEGENOPT(EmitLLVMUseLists, 1, 0) ///< Control whether to serialize use-lists.
 
 CODEGENOPT(WholeProgramVTables, 1, 0) ///< Whether to apply whole-program
                                       ///  vtable optimization.
 
 /// The user specified number of registers to be used for integral arguments,
 /// or 0 if unspecified.
 VALUE_CODEGENOPT(NumRegisterParameters, 32, 0)

lib/CodeGen/CGDebugInfo.h

 /// responsible for emitting to llvm globals or pass directly to the
 /// backend.
 class CGDebugInfo {
   friend class ApplyDebugLocation;
   friend class SaveAndRestoreLocation;
   CodeGenModule &CGM;
   const codegenoptions::DebugInfoKind DebugKind;
   bool DebugTypeExtRefs;
+  bool RetainAllDebugTypes;
   llvm::DIBuilder DBuilder;
   llvm::DICompileUnit *TheCU = nullptr;
   ModuleMap *ClangModuleMap = nullptr;
   ExternalASTSource::ASTSourceDescriptor PCHDescriptor;
   SourceLocation CurLoc;
   llvm::DIType *VTablePtrType = nullptr;
   llvm::DIType *ClassTy = nullptr;
   llvm::DICompositeType *ObjTy = nullptr;
private:
 
   /// Get the file debug info descriptor for the input location.
   llvm::DIFile *getOrCreateFile(SourceLocation Loc);
 
   /// Get the file info for main compile unit.
   llvm::DIFile *getOrCreateMainFile();
 
   /// Get the type from the cache or create a new type if necessary.
-  llvm::DIType *getOrCreateType(QualType Ty, llvm::DIFile *Fg);
+  /// If Retain is true, the type will be added to the list of
+  /// retained types if it isn't already cached.
+  llvm::DIType *getOrCreateType(QualType Ty, llvm::DIFile *Fg,
+                                bool Retain = false);
 
   /// Get a reference to a clang module.  If \p CreateSkeletonCU is true,
   /// this also creates a split dwarf skeleton compile unit.
   llvm::DIModule *
   getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod,
                        bool CreateSkeletonCU);
 
   /// DebugTypeExtRefs: If \p D originated in a clang module, return it.

lib/CodeGen/CGDebugInfo.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 using namespace clang;
 using namespace clang::CodeGen;
 
 CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
     : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
       DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
+      RetainAllDebugTypes(CGM.getCodeGenOpts().RetainAllDebugTypes),
       DBuilder(CGM.getModule()) {
   for (const auto &KV : CGM.getCodeGenOpts().DebugPrefixMap)
     DebugPrefixMap[KV.first] = KV.second;
   CreateCompileUnit();
 }
 
 CGDebugInfo::~CGDebugInfo() {
   assert(LexicalBlockStack.empty() &&
llvm::DIType *VPTR = DBuilder.createMemberType(
       Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
       llvm::DINode::FlagArtificial, getOrCreateVTablePtrType(Unit));
   EltTys.push_back(VPTR);
 }
 
 llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
                                                  SourceLocation Loc) {
   assert(DebugKind >= codegenoptions::LimitedDebugInfo);
-  llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
-  return T;
+  return getOrCreateType(RTy, getOrCreateFile(Loc));
 }
 
 llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
                                                     SourceLocation Loc) {
   return getOrCreateStandaloneType(D, Loc);
 }
 
 llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
if (DebugKind <= codegenoptions::DebugLineTablesOnly)
     return;
 
   completeClassData(&SD);
   // In case this type has no member function definitions being emitted, ensure
   // it is retained
   RetainedTypes.push_back(CGM.getContext().getRecordType(&SD).getAsOpaquePtr());
 }
 
-llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
+llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit,
+                                           bool Retain) {
   if (Ty.isNull())
     return nullptr;
 
   // Unwrap the type as needed for debug information.
   Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
 
   if (auto *T = getTypeOrNull(Ty))
     return T;
 
   llvm::DIType *Res = CreateTypeNode(Ty, Unit);
   void* TyPtr = Ty.getAsOpaquePtr();
 
   // And update the type cache.
   TypeCache[TyPtr].reset(Res);
 
+  if (Retain)
+    RetainedTypes.push_back(TyPtr);
+
   return Res;
 }
 
 llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) {
   // A forward declaration inside a module header does not belong to the module.
   if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->getDefinition())
     return nullptr;
   if (DebugTypeExtRefs && D->isFromASTFile()) {
void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, SourceLocation Loc,
   if (!HasDecl || D->isImplicit()) {
     Flags |= llvm::DINode::FlagArtificial;
     // Artificial functions without a location should not silently reuse CurLoc.
     if (Loc.isInvalid())
       CurLoc = SourceLocation();
   }
   unsigned LineNo = getLineNumber(Loc);
   unsigned ScopeLine = getLineNumber(ScopeLoc);
+  auto *FnTy = getOrCreateFunctionType(D, FnType, Unit);
+  if (RetainAllDebugTypes)
+    DBuilder.retainType(FnTy);
 
   // FIXME: The function declaration we're constructing here is mostly reusing
   // declarations from CXXMethodDecl and not constructing new ones for arbitrary
   // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
   // all subprograms instead of the actual context since subprogram definitions
   // are emitted as CU level entities by the backend.
-  llvm::DISubprogram *SP = DBuilder.createFunction(
-      FDContext, Name, LinkageName, Unit, LineNo,
-      getOrCreateFunctionType(D, FnType, Unit), Fn->hasInternalLinkage(),
-      true /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize,
+  llvm::DISubprogram *SP =
+      DBuilder.createFunction(FDContext, Name, LinkageName, Unit, LineNo, FnTy,
+                              Fn->hasInternalLinkage(), true /*definition*/,
+                              ScopeLine, Flags, CGM.getLangOpts().Optimize,
                               TParamsArray.get(), getFunctionDeclaration(D));
   Fn->setSubprogram(SP);
   // We might get here with a VarDecl in the case we're generating
   // code for the initialization of globals. Do not record these decls
   // as they will overwrite the actual VarDecl Decl in the cache.
   if (HasDecl && isa<FunctionDecl>(D))
     DeclCache[D->getCanonicalDecl()].reset(static_cast<llvm::Metadata *>(SP));
 
   // Push the function onto the lexical block stack.
void CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::Value *Storage,
   llvm::DIFile *Unit = nullptr;
   if (!Unwritten)
     Unit = getOrCreateFile(VD->getLocation());
   llvm::DIType *Ty;
   uint64_t XOffset = 0;
   if (VD->hasAttr<BlocksAttr>())
     Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
   else
-    Ty = getOrCreateType(VD->getType(), Unit);
+    Ty = getOrCreateType(VD->getType(), Unit, RetainAllDebugTypes);
 
   // If there is no debug info for this type then do not emit debug info
   // for this variable.
   if (!Ty)
     return;
 
   // Get location information.
   unsigned Line = 0;
void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
   bool isByRef = VD->hasAttr<BlocksAttr>();
 
   uint64_t XOffset = 0;
   llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
   llvm::DIType *Ty;
   if (isByRef)
     Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
   else
-    Ty = getOrCreateType(VD->getType(), Unit);
+    Ty = getOrCreateType(VD->getType(), Unit, RetainAllDebugTypes);
 
   // Self is passed along as an implicit non-arg variable in a
   // block. Mark it as the object pointer.
   if (isa<ImplicitParamDecl>(VD) && VD->getName() == "self")
     Ty = CreateSelfType(VD->getType(), Ty);
 
   // Get location information.
   unsigned Line = getLineNumber(VD->getLocation());
void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
   // to find the name of any field in the union.
   if (T->isUnionType() && DeclName.empty()) {
     const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
     assert(RD->isAnonymousStructOrUnion() &&
            "unnamed non-anonymous struct or union?");
     GV = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
   } else {
     GV = DBuilder.createGlobalVariable(
-        DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
+        DContext, DeclName, LinkageName, Unit, LineNo,
+        getOrCreateType(T, Unit, RetainAllDebugTypes),
         Var->hasInternalLinkage(), Var,
         getOrCreateStaticDataMemberDeclarationOrNull(D));
   }
   DeclCache[D->getCanonicalDecl()].reset(static_cast<llvm::Metadata *>(GV));
 }
 
 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD,
                                      llvm::Constant *Init) {

lib/Driver/Tools.cpp

return llvm::StringSwitch<unsigned>(ArgValue)
       .Case("-gdwarf-4", 4)
       .Case("-gdwarf-5", 5)
       .Default(0);
 }
 
 static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
                                     codegenoptions::DebugInfoKind DebugInfoKind,
                                     unsigned DwarfVersion,
-                                    llvm::DebuggerKind DebuggerTuning) {
+                                    llvm::DebuggerKind DebuggerTuning,
+                                    bool RetainAllDebugTypes) {
   switch (DebugInfoKind) {
   case codegenoptions::DebugLineTablesOnly:
     CmdArgs.push_back("-debug-info-kind=line-tables-only");
     break;
   case codegenoptions::LimitedDebugInfo:
     CmdArgs.push_back("-debug-info-kind=limited");
     break;
   case codegenoptions::FullDebugInfo:
case llvm::DebuggerKind::LLDB:
     CmdArgs.push_back("-debugger-tuning=lldb");
     break;
   case llvm::DebuggerKind::SCE:
     CmdArgs.push_back("-debugger-tuning=sce");
     break;
   default:
     break;
   }
+  if (RetainAllDebugTypes)
+    CmdArgs.push_back(Args.MakeArgString("-debug-info-retain-types"));
 }
 
 static void CollectArgsForIntegratedAssembler(Compilation &C,
                                               const ArgList &Args,
                                               ArgStringList &CmdArgs,
                                               const Driver &D) {
   if (UseRelaxAll(C, Args))
     CmdArgs.push_back("-mrelax-all");
for (StringRef Value : A->getValues()) {
       } else if (Value.startswith("-gdwarf-")) {
         // "-gdwarf-N" options are not cc1as options.
         unsigned DwarfVersion = DwarfVersionNum(Value);
         if (DwarfVersion == 0) { // Send it onward, and let cc1as complain.
           CmdArgs.push_back(Value.data());
         } else {
           RenderDebugEnablingArgs(Args, CmdArgs,
                                   codegenoptions::LimitedDebugInfo,
-                                  DwarfVersion, llvm::DebuggerKind::Default);
+                                  DwarfVersion, llvm::DebuggerKind::Default,
+                                  /*retain types*/ false);
         }
       } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
                  Value.startswith("-mhwdiv") || Value.startswith("-march")) {
         // Do nothing, we'll validate it later.
       } else {
         D.Diag(diag::err_drv_unsupported_option_argument)
             << A->getOption().getName() << Value;
       }
#endif
   // splitting and extraction.
   // FIXME: Currently only works on Linux.
   if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {
     DebugInfoKind = codegenoptions::LimitedDebugInfo;
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-split-dwarf=Enable");
   }
 
+  bool RetainTypes =
+      !Args.hasFlag(options::OPT_feliminate_unused_debug_symbols,
+                    options::OPT_fno_eliminate_unused_debug_symbols, true);
+
   // After we've dealt with all combinations of things that could
   // make DebugInfoKind be other than None or DebugLineTablesOnly,
   // figure out if we need to "upgrade" it to standalone debug info.
   // We parse these two '-f' options whether or not they will be used,
   // to claim them even if you wrote "-fstandalone-debug -gline-tables-only"
   bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
                                     options::OPT_fno_standalone_debug,
                                     getToolChain().GetDefaultStandaloneDebug());
   if (DebugInfoKind == codegenoptions::LimitedDebugInfo && NeedFullDebug)
     DebugInfoKind = codegenoptions::FullDebugInfo;
   RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
-                          DebuggerTuning);
+                          DebuggerTuning, RetainTypes);
 
   // -ggnu-pubnames turns on gnu style pubnames in the backend.
   if (Args.hasArg(options::OPT_ggnu_pubnames)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
   }
 
   // -gdwarf-aranges turns on the emission of the aranges section in the
if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
       if (WantDebug)
         DwarfVersion = DwarfVersionNum(A->getSpelling());
     }
     if (DwarfVersion == 0)
       DwarfVersion = getToolChain().GetDefaultDwarfVersion();
     RenderDebugEnablingArgs(Args, CmdArgs,
                             (WantDebug ? codegenoptions::LimitedDebugInfo
                                        : codegenoptions::NoDebugInfo),
-                            DwarfVersion, llvm::DebuggerKind::Default);
+                            DwarfVersion, llvm::DebuggerKind::Default,
+                            /*retain types*/ false);
 
     // Add the -fdebug-compilation-dir flag if needed.
     addDebugCompDirArg(Args, CmdArgs);
 
     // Set the AT_producer to the clang version when using the integrated
     // assembler on assembly source files.
     CmdArgs.push_back("-dwarf-debug-producer");
     CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
   Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
   Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
   Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
   Opts.WholeProgramVTablesBlacklistFiles =
       Args.getAllArgValues(OPT_fwhole_program_vtables_blacklist_EQ);
   Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
   Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
+  Opts.RetainAllDebugTypes = Args.hasArg(OPT_debug_info_retain_types);
   Opts.DebugExplicitImport = Triple.isPS4CPU(); 
 
   for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
     Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
 
   if (const Arg *A =
           Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
     Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;

test/CodeGen/debug-info-retain-types.c

+// RUN: %clang_cc1 -fblocks -emit-llvm -o - %s \
+// RUN:   -debug-info-kind=standalone -debug-info-retain-types | FileCheck %s
+// RUN: %clang_cc1 -fblocks -emit-llvm -o - %s \
+// RUN:   -debug-info-kind=standalone -debug-info-retain-types \
+// RUN:     | FileCheck %s --check-prefix=CHECK-MIN
+// RUN: %clang_cc1 -fblocks -emit-llvm -o - %s \
+// RUN:   -debug-info-kind=standalone | FileCheck %s --check-prefix=NORETAIN
+// NORETAIN-NOT: !DICompileUnit{{.*}}retainedTypes
+
+// CHECK-DAG: !DICompileUnit({{.*}}retainedTypes: ![[RETAINED:[0-9]+]]
+
+// Function type.
+// CHECK-DAG: !DISubprogram(name: "foo", {{.*}}type: ![[FNTY:[0-9]+]]
+static int foo(int i) { return i; }
+
+// Global variable.
+// CHECK-DAG: !DIGlobalVariable(name: "g", {{.*}}type: ![[GLOBTY:[0-9]+]]
+
+// Block capture.
+// CHECK-DAG: !DILocalVariable(name: "d", {{.*}}type: ![[BLOCKTY:[0-9]+]]
+
+// Local variable.
+// CHECK-DAG: !DILocalVariable(name: "xyz", {{.*}}type: ![[VARTY:[0-9]+]]
+static void bar() {
+  struct X { int a; int b; } xyz;
+}
+
+float g;
+int g1;
+
+void baz() {
+  double d;
+  void (^blockptr)(void) = ^(void) {
+    foo(0);
+    bar();
+  };
+}
+
+// CHECK-DAG: ![[RETAINED]] = {{.*}}![[FNTY]],{{.*}}![[BLOCKTY]],{{.*}}![[GLOBTY]],{{.*}}![[VARTY]]
+
+
+// CHECK-MIN: !DICompileUnit({{.*}}retainedTypes: ![[RETAINED:[0-9]+]]
+// CHECK-MIN: ![[RETAINED]] = !{![[A:.*]], ![[B:.*]], ![[C:.*]], ![[D:.*]], ![[E:.*]],
+// CHECK-MIN-NOT: ![[A]] = !DIBasicType(name: "int"
+// CHECK-MIN-NOT: ![[B]] = !DIBasicType(name: "int"
+// CHECK-MIN-NOT: ![[C]] = !DIBasicType(name: "int"
+// CHECK-MIN-NOT: ![[D]] = !DIBasicType(name: "int"
+// CHECK-MIN-NOT: ![[E]] = !DIBasicType(name: "int"

test/Driver/debug-options.c

 // RUN:        | FileCheck -check-prefix=NOCI %s
 //
 // RUN: %clang -### -g -target x86_64-unknown-unknown %s 2>&1 \
 //             | FileCheck -check-prefix=CI %s
 //
 // RUN: %clang -### -gmodules %s 2>&1 \
 // RUN:        | FileCheck -check-prefix=GEXTREFS %s
 //
+// RUN: %clang -### -S %s -gfull 2>&1 \
+// RUN:             | FileCheck --check-prefix=RETAIN %s
+//
+// RUN: %clang -### -S %s -g 2>&1 \
+// RUN:             | FileCheck --check-prefix=NO_RETAIN %s
+//
 // G: "-cc1"
 // G: "-debug-info-kind=limited"
 //
 // G_DARWIN: "-cc1"
 // G_DARWIN: "-dwarf-version=2"
 //
 // NOG_PS4: "-cc1"
 // NOG_PS4-NOT "-dwarf-version=

 //
 // NOFDTS-NOT: "-backend-option" "-generate-type-units"
 //
 // CI: "-dwarf-column-info"
 //
 // NOCI-NOT: "-dwarf-column-info"
 //
 // GEXTREFS: "-dwarf-ext-refs" "-fmodule-format=obj" "-debug-info-kind={{standalone|limited}}"
-
+// RETAIN: "-debug-info-retain-types"
+// NO_RETAIN-NOT: "-debug-info-retain-types"
 // RUN: not %clang -cc1 -debug-info-kind=watkind 2>&1 | FileCheck -check-prefix=BADSTRING1 %s
 // BADSTRING1: error: invalid value 'watkind' in '-debug-info-kind=watkind'
 // RUN: not %clang -cc1 -debugger-tuning=gmodal 2>&1 | FileCheck -check-prefix=BADSTRING2 %s
 // BADSTRING2: error: invalid value 'gmodal' in '-debugger-tuning=gmodal'