[CodeGen] Add an option to suppress output of llvm.ident

[miyuki]

Summary

By default Clang outputs its version (including git commit hash, in
case of trunk builds) into object and assembly files. It might be
useful to have an option to disable this, especially for debugging
purposes.
This patch implements new command line flags -Qn and -Qy (the names
are chosen for compatibility with GCC). -Qn disables output of
the 'llvm.ident' metadata string and the 'producer' debug info. -Qy
(enabled by default) does the opposite.

[miyuki]

ping

[aprantl]

What's your use-case for this?

test/CodeGen/no-ident-version.c

5

You'll also want to check for something positive, otherwise this test will succeed even if clang is symlinked to /bin/true :-)

[miyuki]

Updated the test case

[miyuki]

One use case for this is debugging: this flag makes it easier to find out which revisions of LLVM introduce changes in codegen and/or debug information without having to filter out .ident/producer metadata manually. Some users can also use this flag (or an equivalent, -fno-ident) to reduce code size: https://github.com/niXman/mingw-builds/issues/412 (.ident strings are embedded into each object file and don't get merged during linking, so the difference can be noticeable).

[rogfer01]

There is a flag -fno-ident that has the same effect in GCC https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#index-fno-ident although it involves also ignoring the #ident.

A quick look seems to suggest that #ident is just ignored in the usual PP callbacks used by the parser so in practice -fno-ident would be the same as -Qn

[miyuki]

ping

[JDevlieghere]

test/CodeGen/no-ident-version.c

2

Please test both -Qy and -Qn as well as the default case.

[aprantl]

Does gcc's Qy/Qn option also affect the generated debug information? Clang is embedding the version number also into the DICompileUnit's producer string; I wonder if that should be affected by this option, too.

[miyuki]

In D45255#1072200, @aprantl wrote:

Does gcc's Qy/Qn option also affect the generated debug information?

No, it does not. Do you think it would be better to leave debug information unchanged as well?

[aprantl]

I'm not sure. Compatibility with GCC and getting identical output for debugging purposes seem to be at odds here. I personally lean slightly towards stripping it from the debug info as well.

[miyuki]

Updated the test

[JDevlieghere]

I’m happy with the test, thanks!

In D45255#1072335, @aprantl wrote:

I'm not sure. Compatibility with GCC and getting identical output for debugging purposes seem to be at odds here. I personally lean slightly towards stripping it from the debug info as well.

If it were the other way around I’d agree with you, but given that -Qn becomes the default, I think we should not strip it from the debug info.

[miyuki]

In D45255#1073703, @JDevlieghere wrote:

If it were the other way around I’d agree with you, but given that -Qn becomes the default, I think we should not strip it from the debug info.

No, the default is -Qy

[JDevlieghere]

In D45255#1073710, @miyuki wrote:

In D45255#1073703, @JDevlieghere wrote:

If it were the other way around I’d agree with you, but given that -Qn becomes the default, I think we should not strip it from the debug info.

No, the default is -Qy

Ah, right, I was confused by the CHECK-NONE prefix, I would have merged it with the default case. In that case I agree with Adrian. :-)

include/clang/Driver/Options.td

def ObjCXX : Flag<["-"], "ObjC++">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C++ inputs">;
 def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C inputs">;
 def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>;
 def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["2"]>;
 def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>;
 def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
   HelpText<"Disable linemarker output in -E mode">;
-def Qn : Flag<["-"], "Qn">, IgnoredGCCCompat;
+def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>,
+  HelpText<"Emit metadata containing compiler name and version">;
+def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>,
+  HelpText<"Do not emit metadata containing compiler name and version">;
 def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption, CoreOption]>,
   HelpText<"Don't emit warning for unused driver arguments">;
 def Q : Flag<["-"], "Q">, IgnoredGCCCompat;
 def Rpass_EQ : Joined<["-"], "Rpass=">, Group<R_value_Group>, Flags<[CC1Option]>,
   HelpText<"Report transformations performed by optimization passes whose "
            "name matches the given POSIX regular expression">;
 def Rpass_missed_EQ : Joined<["-"], "Rpass-missed=">, Group<R_value_Group>,
   Flags<[CC1Option]>,

include/clang/Frontend/CodeGenOptions.def

 CODEGENOPT(DisableRedZone    , 1, 0) ///< Set when -mno-red-zone is enabled.
 CODEGENOPT(DisableTailCalls  , 1, 0) ///< Do not emit tail calls.
 CODEGENOPT(NoEscapingBlockTailCalls, 1, 0) ///< Do not emit tail calls from
                                            ///< escaping blocks.
 CODEGENOPT(EmitDeclMetadata  , 1, 0) ///< Emit special metadata indicating what
                                      ///< Decl* various IR entities came from.
                                      ///< Only useful when running CodeGen as a
                                      ///< subroutine.
+CODEGENOPT(EmitVersionIdentMetadata , 1, 1) ///< Emit compiler version metadata.
 CODEGENOPT(EmitGcovArcs      , 1, 0) ///< Emit coverage data files, aka. GCDA.
 CODEGENOPT(EmitGcovNotes     , 1, 0) ///< Emit coverage "notes" files, aka GCNO.
 CODEGENOPT(EmitOpenCLArgMetadata , 1, 0) ///< Emit OpenCL kernel arg metadata.
 CODEGENOPT(EmulatedTLS       , 1, 0) ///< Set by default or -f[no-]emulated-tls.
 CODEGENOPT(ExplicitEmulatedTLS , 1, 0) ///< Set if -f[no-]emulated-tls is used.
 /// \brief Embed Bitcode mode (off/all/bitcode/marker).
 ENUM_CODEGENOPT(EmbedBitcode, EmbedBitcodeKind, 2, Embed_Off)
 CODEGENOPT(ForbidGuardVariables , 1, 0) ///< Issue errors if C++ guard variables

lib/CodeGen/CGDebugInfo.cpp

void CGDebugInfo::CreateCompileUnit() {
   // FIXME - Eliminate TheCU.
   auto &CGOpts = CGM.getCodeGenOpts();
   TheCU = DBuilder.createCompileUnit(
       LangTag,
       DBuilder.createFile(remapDIPath(MainFileName),
                           remapDIPath(getCurrentDirname()),
                           CSInfo,
                           getSource(SM, SM.getMainFileID())),
-      Producer, LO.Optimize || CGOpts.PrepareForLTO || CGOpts.EmitSummaryIndex,
+      CGOpts.EmitVersionIdentMetadata ? Producer : "",
+      LO.Optimize || CGOpts.PrepareForLTO || CGOpts.EmitSummaryIndex,
       CGOpts.DwarfDebugFlags, RuntimeVers,
       CGOpts.EnableSplitDwarf ? "" : CGOpts.SplitDwarfFile, EmissionKind,
       0 /* DWOid */, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
       CGOpts.GnuPubnames);
 }
 
 llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
   llvm::dwarf::TypeKind Encoding;

lib/CodeGen/CodeGenModule.cpp

if (getCodeGenOpts().EmitDeclMetadata)
     EmitDeclMetadata();
 
   if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
     EmitCoverageFile();
 
   if (DebugInfo)
     DebugInfo->finalize();
 
+  if (getCodeGenOpts().EmitVersionIdentMetadata)
     EmitVersionIdentMetadata();
 
   EmitTargetMetadata();
 }
 
 void CodeGenModule::EmitOpenCLMetadata() {
   // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
   // opencl.ocl.version named metadata node.
   llvm::Metadata *OCLVerElts[] = {

lib/Driver/ToolChains/Clang.cpp

if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
     }
   } else if (RawTriple.isOSDarwin()) {
     if (!SkipMaxTypeAlign) {
       std::string MaxTypeAlignStr = "-fmax-type-align=16";
       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
     }
   }
 
+  if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn, true))
+    CmdArgs.push_back("-Qn");
+
   // -fcommon is the default unless compiling kernel code or the target says so
   bool NoCommonDefault = KernelOrKext || isNoCommonDefault(RawTriple);
   if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
                     !NoCommonDefault))
     CmdArgs.push_back("-fno-common");
 
   // -fsigned-bitfields is default, and clang doesn't yet support
   // -funsigned-bitfields.

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.CudaGpuBinaryFileName =
       Args.getLastArgValue(OPT_fcuda_include_gpubinary);
 
   Opts.Backchain = Args.hasArg(OPT_mbackchain);
 
   Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
       Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
 
+  Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);
+
   return Success;
 }
 
 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
                                       ArgList &Args) {
   Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
   Opts.Targets = Args.getAllArgValues(OPT_MT);
   Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);

test/CodeGen/no-ident-version.c

+// RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -o - %s \
+// RUN:   | FileCheck --check-prefix=CHECK-NONE %s
+// RUN: %clang_cc1 -Qn -emit-llvm -debug-info-kind=limited -o - %s \
+// RUN:   | FileCheck --check-prefix=CHECK-QN %s
+// RUN: %clang_cc1 -Qy -emit-llvm -debug-info-kind=limited -o - %s \
+// RUN:   | FileCheck --check-prefix=CHECK-QY %s
+
+// CHECK-NONE: define i32 @main()
+// CHECK-NONE: llvm.ident
+// CHECK-NONE: producer:
+
+// CHECK-QN: define i32 @main()
+// CHECK-QN-NOT: llvm.ident
+// CHECK-QN-NOT: producer:
+
+// CHECK-QY: define i32 @main()
+// CHECK-QY: llvm.ident
+// CHECK-QY: producer:
+int main(void) {}