[Clang] Add options -fprofile-filter-files and -fprofile-exclude-files to filter the files to instrument with gcov

[calixte]

Summary

These options are taking regex separated by colons to filter files.

• if both are empty then all files are instrumented
• if -fprofile-filter-files is empty then all the filenames matching any of the regex from exclude are not instrumented
• if -fprofile-exclude-files is empty then all the filenames matching any of the regex from filter are instrumented
• if both aren't empty then all the filenames which match any of the regex in filter and which don't match all the regex in filter are instrumented
• this patch is a follow-up of https://reviews.llvm.org/D52033

[vsk]

Please document the filter behavior (see docs/UsersManual.rst).

include/clang/Driver/CC1Options.td

236

Have you checked whether gcc supports similar options? If so, it would be great if we could match their name & behavior.

[calixte]

include/clang/Driver/CC1Options.td

236

The only one I found -finstrument-functions-exclude-file-list (https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html).
But no regex and no way to include one file only.
I took the names from gcovr: https://manpages.debian.org/jessie/gcovr/gcovr.1.en.html

[marco-c]

include/clang/Driver/CC1Options.td

236

We could file a bug in GCC's Bugzilla and agree with them about the options.

[vsk]

test/CodeGen/code-coverage-filter.c

4

Could you use more descriptive check prefixes here, like 'NO-HEADERS'? Also, if it's possible to use fewer '\' escape tokens by wrapping the regex list in single-quotes, that would make things easier to read.

32

1. This test will break on bots which use 16-bit ints. For simplicity, consider sticking to void and getting rid of unnecessary control flow.
2. Is there any need to check '#0'?

[vsk]

include/clang/Driver/CC1Options.td

236

+ 1, I think it's a great idea to loop in some gcc developers.

[calixte]

Fix tests

[calixte]

I reported a bug for gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87442
@vsk I'd like to add documentation in Docs/UsersManual.rst, but I've no idea on what's a good place for this (I look for option -coverage-no-function-names-in-data, but I didn't get anything). So could you give a me a clue please ?

[calixte]

@vsk, gcc guys are ok for -fprofile-filter-files and -fprofile-exclude-files, are you ok with that ?
Should these options prefixed by -Xclang or not ?

[vsk]

In D52034#1268277, @calixte wrote:

@vsk, gcc guys are ok for -fprofile-filter-files and -fprofile-exclude-files, are you ok with that ?

That sounds fine to me.

Should these options prefixed by -Xclang or not ?

I don't think they should be. These options should be easy to surface to users.

[vsk]

In D52034#1246379, @calixte wrote:

I reported a bug for gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87442

Thank you!

@vsk I'd like to add documentation in Docs/UsersManual.rst, but I've no idea on what's a good place for this (I look for option -coverage-no-function-names-in-data, but I didn't get anything). So could you give a me a clue please ?

That's the right file to edit. Please create a section for gcov-based profiling. I won't ask that you describe the entire gcov pipeline, but it would really help to have a description of the driver flags you're adding & some examples of how to use them.

[calixte]

Change options names to -fprofile-exclude-files & -fprofile-filter-files and add some doc in UserManual.

[calixte]

Fix plural form of regex and just use ';' as separator.

[calixte]

Update doc.

[sylvestre.ledru]

Can be done in a new commit but I think this should be mentioned in the clang release notes.

[calixte]

Update ReleaseNotes

[calixte]

Forgot the ellipsis in the release notes.

include/clang/Driver/CC1Options.td

 def coverage_notes_file : Separate<["-"], "coverage-notes-file">,
   HelpText<"Emit coverage notes to this filename.">;
 def coverage_notes_file_EQ : Joined<["-"], "coverage-notes-file=">,
   Alias<coverage_notes_file>;
 def coverage_cfg_checksum : Flag<["-"], "coverage-cfg-checksum">,
   HelpText<"Emit CFG checksum for functions in .gcno files.">;
 def coverage_no_function_names_in_data : Flag<["-"], "coverage-no-function-names-in-data">,
   HelpText<"Emit function names in .gcda files.">;
+def coverage_filter : Separate<["-"], "coverage-filter">,
+  HelpText<"Instrument only functions from files where names match any regex separate by a colon">;
+def coverage_filter_EQ : Joined<["-"], "coverage-filter=">,
+  Alias<coverage_filter>;
+def coverage_exclude : Separate<["-"], "coverage-exclude">,
+  HelpText<"Instrument only functions from files where names don't match all the regex separate by a colon">;
+def coverage_exclude_EQ : Joined<["-"], "coverage-exclude=">,
+  Alias<coverage_exclude>;
 def coverage_exit_block_before_body : Flag<["-"], "coverage-exit-block-before-body">,
   HelpText<"Emit the exit block before the body blocks in .gcno files.">;
 def coverage_version_EQ : Joined<["-"], "coverage-version=">,
   HelpText<"Four-byte version string for gcov files.">;
 def test_coverage : Flag<["-"], "test-coverage">,
   HelpText<"Do not generate coverage files or remove coverage changes from IR">;
 def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">,
   HelpText<"Dump the coverage mapping records, for testing">;

include/clang/Frontend/CodeGenOptions.h

public:
   /// The filename with path we use for coverage data files. The runtime
   /// allows further manipulation with the GCOV_PREFIX and GCOV_PREFIX_STRIP
   /// environment variables.
   std::string CoverageDataFile;
 
   /// The filename with path we use for coverage notes files.
   std::string CoverageNotesFile;
 
+  /// Regex separated by a colon to filter the files to instrument.
+  std::string CoverageFilter;
+
+  /// Regex separated by a colon to filter the files to not instrument.
+  std::string CoverageExclude;
+
   /// The version string to put into coverage files.
   char CoverageVersion[4];
 
   /// Enable additional debugging information.
   std::string DebugPass;
 
   /// The string to embed in debug information as the current working directory.
   std::string DebugCompilationDir;

lib/CodeGen/BackendUtil.cpp

static Optional<GCOVOptions> getGCOVOptions(const CodeGenOptions &CodeGenOpts) {
   // LLVM's -default-gcov-version flag is set to something invalid.
   GCOVOptions Options;
   Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
   Options.EmitData = CodeGenOpts.EmitGcovArcs;
   llvm::copy(CodeGenOpts.CoverageVersion, std::begin(Options.Version));
   Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
   Options.NoRedZone = CodeGenOpts.DisableRedZone;
   Options.FunctionNamesInData = !CodeGenOpts.CoverageNoFunctionNamesInData;
+  Options.Filter = CodeGenOpts.CoverageFilter;
+  Options.Exclude = CodeGenOpts.CoverageExclude;
   Options.ExitBlockBeforeBody = CodeGenOpts.CoverageExitBlockBeforeBody;
   return Options;
 }
 
 void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM,
                                       legacy::FunctionPassManager &FPM) {
   // Handle disabling of all LLVM passes, where we want to preserve the
   // internal module before any optimization.

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
   Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
   if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
     Opts.CoverageDataFile = Args.getLastArgValue(OPT_coverage_data_file);
     Opts.CoverageNotesFile = Args.getLastArgValue(OPT_coverage_notes_file);
     Opts.CoverageExtraChecksum = Args.hasArg(OPT_coverage_cfg_checksum);
     Opts.CoverageNoFunctionNamesInData =
         Args.hasArg(OPT_coverage_no_function_names_in_data);
+    Opts.CoverageFilter = Args.getLastArgValue(OPT_coverage_filter);
+    Opts.CoverageExclude = Args.getLastArgValue(OPT_coverage_exclude);
     Opts.CoverageExitBlockBeforeBody =
         Args.hasArg(OPT_coverage_exit_block_before_body);
     if (Args.hasArg(OPT_coverage_version_EQ)) {
       StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
       if (CoverageVersion.size() != 4) {
         Diags.Report(diag::err_drv_invalid_value)
             << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
             << CoverageVersion;

test/CodeGen/Inputs/code-coverage-filter1.h

+int test1(int x) {
+    if (x >= 1) {
+        return x + 1;
+    }
+    return x;
+}

test/CodeGen/Inputs/code-coverage-filter2.h

+int test2(int x) {
+    if (x >= 1) {
+        return x + 1;
+    }
+    return x;
+}

test/CodeGen/code-coverage-filter.c

+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data %s -o - \
+// RUN:    | FileCheck -check-prefix=ALL %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-exclude=.*\\.h %s -o - \
+// RUN:    | FileCheck -check-prefix=NOH %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-filter=.*\\.c %s -o - \
+// RUN:    | FileCheck -check-prefix=NOH %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-filter=.*\\.c %s -o - \
+// RUN:    | FileCheck -check-prefix=NOH %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-filter=.*\\.c:.*1\\.h %s -o - \
+// RUN:    | FileCheck -check-prefix=NOH2 %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-exclude=.*2\\.h:.*1\\.h %s -o - \
+// RUN:    | FileCheck -check-prefix=C %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-exclude=.*code\\-coverage\\-filter\\.c %s -o - \
+// RUN:    | FileCheck -check-prefix=H %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-filter=.*\\.c -coverage-exclude=.*\\.c %s -o - \
+// RUN:    | FileCheck -check-prefix=NONE %s
+// RUN: %clang_cc1 -emit-llvm -femit-coverage-data -coverage-filter=.*\\.c -coverage-exclude=.*\\.h %s -o - \
+// RUN:    | FileCheck -check-prefix=C %s
+
+#include "Inputs/code-coverage-filter1.h"
+#include "Inputs/code-coverage-filter2.h"
+
+int test(int a) {
+    int x = 0;
+    if (a == 1) {
+        x = test1(a) + test2(a);
+    }
+
+    return x;
+}
+
+// ALL: define i32 @test1(i32 %x) #0 {{.*}}
+// ALL: {{.*}}__llvm_gcov_ctr{{.*}}
+// ALL: ret i32 {{.*}}
+// ALL: define i32 @test2(i32 %x) #0 {{.*}}
+// ALL: {{.*}}__llvm_gcov_ctr{{.*}}
+// ALL: ret i32 {{.*}}
+// ALL: define i32 @test(i32 %a) #0 {{.*}}
+// ALL: {{.*}}__llvm_gcov_ctr{{.*}}
+// ALL: ret i32 {{.*}}
+
+// NOH: define i32 @test1(i32 %x) #0 {{.*}}
+// NOH-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// NOH: ret i32 {{.*}}
+// NOH: define i32 @test2(i32 %x) #0 {{.*}}
+// NOH-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// NOH: ret i32 {{.*}}
+// NOH: define i32 @test(i32 %a) #0 {{.*}}
+// NOH: {{.*}}__llvm_gcov_ctr{{.*}}
+// NOH: ret i32 {{.*}}
+
+// NOH2: define i32 @test1(i32 %x) #0 {{.*}}
+// NOH2: {{.*}}__llvm_gcov_ctr{{.*}}
+// NOH2: ret i32 {{.*}}
+// NOH2: define i32 @test2(i32 %x) #0 {{.*}}
+// NOH2-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// NOH2: ret i32 {{.*}}
+// NOH2: define i32 @test(i32 %a) #0 {{.*}}
+// NOH2: {{.*}}__llvm_gcov_ctr{{.*}}
+// NOH2: ret i32 {{.*}}
+
+// C: define i32 @test1(i32 %x) #0 {{.*}}
+// C-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// C: ret i32 {{.*}}
+// C: define i32 @test2(i32 %x) #0 {{.*}}
+// C-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// C: ret i32 {{.*}}
+// C: define i32 @test(i32 %a) #0 {{.*}}
+// C: {{.*}}__llvm_gcov_ctr{{.*}}
+// C: ret i32 {{.*}}
+
+// H: define i32 @test1(i32 %x) #0 {{.*}}
+// H: {{.*}}__llvm_gcov_ctr{{.*}}
+// H: ret i32 {{.*}}
+// H: define i32 @test2(i32 %x) #0 {{.*}}
+// H: {{.*}}__llvm_gcov_ctr{{.*}}
+// H: ret i32 {{.*}}
+// H: define i32 @test(i32 %a) #0 {{.*}}
+// H-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// H: ret i32 {{.*}}
+
+// NONE: define i32 @test1(i32 %x) #0 {{.*}}
+// NONE-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// NONE: ret i32 {{.*}}
+// NONE: define i32 @test2(i32 %x) #0 {{.*}}
+// NONE-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// NONE: ret i32 {{.*}}
+// NONE: define i32 @test(i32 %a) #0 {{.*}}
+// NONE-NOT: {{.*}}__llvm_gcov_ctr{{.*}}
+// NONE: ret i32 {{.*}}