[PGO] clang cc1 option change to enable IR level instrumenation

[xur]

Summary

This patch expands cc1 option -fprofile-instrument= with three new values:
(1) -fprofile-instrument=llvm
This enables IR PGO instrumentation.
(2) -fprofile-instrument=llvm-use
This enables PGO use compilation using IR level profiles. The profile is specified by -fprofile-instrument-path= (cc1) option.
(3) -fprofile-instrument=clang-use
This enables PGO use compilation using clang profiles. This replaces current cc1 option -fprofile-instr-use=. The profile is specified by -fprofile-instrument-path= (cc1) option.

Some tests are modified due to the -fprofile-instr-use= option change.
A new test is added to test IR profile compilation.
test/CodeGen/pgo-instrumentation.c

Original discussion is in http://reviews.llvm.org/D15829.

[silvas]

Thanks for splitting this out.

I think the -fprofile-instrument=llvm is straightforward and uncontroversial. Let's focus this review on that and split the others into a separate review.

But a quick preview of my thoughs about -fprofile-instrument={llvm,clang}-use:
I think that fully decoupling the cc1 options from the driver options like you are doing here is a good cleanup, but we need a more refined approach. For example, the current patch has "use" modes as mutually exclusive with the "gen" modes, which doesn't make sense. In fact, we have already seen a situation where we may want to have "use" and "gen" in the same clang invocation: for profile guided MST instr. And I don't see a reason to artificially prohibit FE "use" to annotate MD_prof metadata and then use that metadata for profile guided MST instr (however, it would be a strange workflow for users...).
Perhaps something like -fprofile-instrument-use={llvm,clang} which sets a CodeGenOpt ProfileUse which is either {None, Clang, LLVM}. We can use a common PGOInstrumentor enum for both, since there is a 1:1 mapping between the instrumentor and its corresponding "use" logic.
In the long run I imagine we will want two mirror options -fpgo-gen={none,llvm,clang} and -fpgo-use={none,llvm,clang}, but the details of renaming to the final state can wait until we clearly see the right design (this is cc1 so it is easy to refactor as needed later).

[xur]

Sean, Thanks for the review and suggestions.

Here is the patch that only adds -fprofile-instrument=llvm.

I'll have another patch using your suggestion on cc1 options for profile use compilation.

[silvas]

Thanks. LGTM.

cfe/trunk/include/clang/Driver/CC1Options.td

: Flag<["-"], "fsanitize-coverage-trace-cmp">,
       HelpText<"Enable cmp instruction tracing in sanitizer coverage">;
 def fsanitize_coverage_8bit_counters
     : Flag<["-"], "fsanitize-coverage-8bit-counters">,
       HelpText<"Enable frequency counters in sanitizer coverage">;
 def fsanitize_coverage_trace_pc
     : Flag<["-"], "fsanitize-coverage-trace-pc">,
       HelpText<"Enable PC tracing in sanitizer coverage">;
 def fprofile_instrument_EQ : Joined<["-"], "fprofile-instrument=">,
-    HelpText<"Enable PGO instrumentation. The accepted values is clang or "
-             "none">;
+    HelpText<"Enable PGO instrumentation. The accepted value is clang, llvm, "
+             "or none">;
 def fprofile_instrument_path_EQ : Joined<["-"], "fprofile-instrument-path=">,
     HelpText<"Generate instrumented code to collect execution counts into "
              "<file> (overridden by LLVM_PROFILE_FILE env var)">;
 
 //===----------------------------------------------------------------------===//
 // Dependency Output Options
 //===----------------------------------------------------------------------===//
 

cfe/trunk/include/clang/Frontend/CodeGenOptions.h

public:
 
   enum StructReturnConventionKind {
     SRCK_Default,  // No special option was passed.
     SRCK_OnStack,  // Small structs on the stack (-fpcc-struct-return).
     SRCK_InRegs    // Small structs in registers (-freg-struct-return).
   };
 
   enum ProfileInstrKind {
-    ProfileNoInstr,    // No instrumentation.
-    ProfileClangInstr  // Clang instrumentation to generate execution counts
+    ProfileNone,       // Profile instrumentation is turned off.
+    ProfileClangInstr, // Clang instrumentation to generate execution counts
                        // to use with PGO.
+    ProfileIRInstr,    // IR level PGO instrumentation in LLVM.
   };
 
   /// The code model to use (-mcmodel).
   std::string CodeModel;
 
   /// The filename with path we use for coverage files. The extension will be
   /// replaced.
   std::string CoverageFile;
#include "clang/Frontend/CodeGenOptions.def"
   const std::vector<std::string> &getNoBuiltinFuncs() const {
     return NoBuiltinFuncs;
   }
 
   /// \brief Check if Clang profile instrumenation is on.
   bool hasProfileClangInstr() const {
     return getProfileInstr() == ProfileClangInstr;
   }
+
+  /// \brief Check if IR level profile instrumentation is on.
+  bool hasProfileIRInstr() const {
+    return getProfileInstr() == ProfileIRInstr;
+  }
 };
 
 }  // end namespace clang
 
 #endif

cfe/trunk/include/clang/Frontend/CodeGenOptions.def

 /// \brief Method of Objective-C dispatch to use.
 ENUM_CODEGENOPT(ObjCDispatchMethod, ObjCDispatchMethodKind, 2, Legacy) 
 CODEGENOPT(OmitLeafFramePointer , 1, 0) ///< Set when -momit-leaf-frame-pointer is
                                         ///< enabled.
 VALUE_CODEGENOPT(OptimizationLevel, 2, 0) ///< The -O[0-3] option specified.
 VALUE_CODEGENOPT(OptimizeSize, 2, 0) ///< If -Os (==1) or -Oz (==2) is specified.
 
 /// \brief Choose profile instrumenation kind or no instrumentation.
-ENUM_CODEGENOPT(ProfileInstr, ProfileInstrKind, 2, ProfileNoInstr)
+ENUM_CODEGENOPT(ProfileInstr, ProfileInstrKind, 2, ProfileNone)
 CODEGENOPT(CoverageMapping , 1, 0) ///< Generate coverage mapping regions to
                                    ///< enable code coverage analysis.
 CODEGENOPT(DumpCoverageMapping , 1, 0) ///< Dump the generated coverage mapping
                                        ///< regions.
 
   /// If -fpcc-struct-return or -freg-struct-return is specified.
 ENUM_CODEGENOPT(StructReturnConvention, StructReturnConventionKind, 2, SRCK_Default)
 

cfe/trunk/lib/CodeGen/BackendUtil.cpp

void EmitAssemblyHelper::CreatePasses(FunctionInfoIndex *FunctionIndex) {
   }
 
   if (CodeGenOpts.hasProfileClangInstr()) {
     InstrProfOptions Options;
     Options.NoRedZone = CodeGenOpts.DisableRedZone;
     Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;
     MPM->add(createInstrProfilingPass(Options));
   }
+  if (CodeGenOpts.hasProfileIRInstr()) {
+    if (!CodeGenOpts.InstrProfileOutput.empty())
+      PMBuilder.PGOInstrGen = CodeGenOpts.InstrProfileOutput;
+    else
+      PMBuilder.PGOInstrGen = "default.profraw";
+  }
 
   if (!CodeGenOpts.SampleProfileFile.empty())
     MPM->add(createSampleProfileLoaderPass(CodeGenOpts.SampleProfileFile));
 
   PMBuilder.populateModulePassManager(*MPM);
 }
 
 TargetMachine *EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

Opts.UnrollLoops =
       Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
                    (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize));
   Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
 
   Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
   Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
   Opts.SampleProfileFile = Args.getLastArgValue(OPT_fprofile_sample_use_EQ);
 
-  enum PGOInstrumentor { Unknown, None, Clang };
+  enum PGOInstrumentor { Unknown, None, Clang, LLVM };
   if (Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ)) {
     StringRef Value = A->getValue();
     PGOInstrumentor Method = llvm::StringSwitch<PGOInstrumentor>(Value)
-                                 .Case("clang", Clang)
                                  .Case("none", None)
+                                 .Case("clang", Clang)
+                                 .Case("llvm", LLVM)
                                  .Default(Unknown);
     switch (Method) {
+    case LLVM:
+      Opts.setProfileInstr(CodeGenOptions::ProfileIRInstr);
+      break;
     case Clang:
       Opts.setProfileInstr(CodeGenOptions::ProfileClangInstr);
       break;
     case None:
+      // Null operation -- The default is ProfileNone.
       break;
     case Unknown:
       Diags.Report(diag::err_drv_invalid_pgo_instrumentor)
           << A->getAsString(Args) << Value;
       break;
     }
   }
 

cfe/trunk/test/CodeGen/pgo-instrumentation.c

+// Test if PGO instrumentation and use pass are invoked.
+//
+// Ensure Pass PGOInstrumentationGenPass is invoked.
+// RUN: %clang_cc1 -O2 -fprofile-instrument=llvm %s -mllvm -debug-pass=Structure -emit-llvm -o - 2>&1 | FileCheck %s -check-prefix=CHECK-PGOGENPASS-INVOKED-INSTR-GEN
+// CHECK-PGOGENPASS-INVOKED-INSTR-GEN: PGOInstrumentationGenPass
+//
+// Ensure Pass PGOInstrumentationGenPass is not invoked.
+// RUN: %clang_cc1 -O2 -fprofile-instrument=clang %s -mllvm -debug-pass=Structure -emit-llvm -o - 2>&1 | FileCheck %s -check-prefix=CHECK-PGOGENPASS-INVOKED-INSTR-GEN-CLANG
+// CHECK-PGOGENPASS-INVOKED-INSTR-GEN-CLANG-NOT: PGOInstrumentationGenPass