Add clang frontend flags for MIP

[ellis]

Summary

Add clang frontend flags for machine profiles.

• -fmachine-profile-generate
  • Produce an instrumented binary
• -fmachine-profile-function-coverage
  • Only profile function coverage
• -fmachine-profile-block-coverage
  • Profile basic block coverage
• -fmachine-profile-link-unit-name=
  • Specify a name to identify the current link unit
• -fno-machine-profile-runtime
  • Do not link the MIP runtime
• -fno-machine-profile-dump
  • Do not dump the raw profile data when the program exits
• -fmachine-profile-selected-function-group=, -fmachine-profile-function-group-count=
  • Only instrument group i of N total groups of functions
• -fmachine-profile-use=
  • Use the provided profile for optimization

[jhenderson]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

59 ↗

(On Diff #351326)

This doesn't look like it belongs as part of this commit?

[ellis]

Move llvm-strip logic into its own commit

[ellis]

MIP does not support windows

[ellis]

Correctly link the runtime symbol for Mach-O.

[ellis]

Add min instruction count frontend flag.

clang/include/clang/Driver/Options.td

 def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">,
     Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">,
     HelpText<"Use the remappings described in <file> to match the profile data against names in the program">,
     MarshallingInfoString<CodeGenOpts<"ProfileRemappingFile">>;
 defm coverage_mapping : BoolFOption<"coverage-mapping",
   CodeGenOpts<"CoverageMapping">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Generate coverage mapping to enable code coverage analysis">,
   NegFlag<SetFalse, [], "Disable code coverage analysis">, BothFlags<[CoreOption]>>;
+
+def fmachine_profile_generate : Flag<["-"], "fmachine-profile-generate">, Group<f_Group>, Flags<[CC1Option]>,
+    HelpText<"Generate MIP instrumented code.">;
+def fno_machine_profile_generate : Flag<["-"], "fno-machine-profile-generate">, Group<f_Group>, Flags<[CC1Option]>,
+    HelpText<"Disable MIP instrumented code.">;
+def fmachine_profile_function_coverage : Flag<["-"], "fmachine-profile-function-coverage">, Group<f_Group>,
+    Flags<[CC1Option]>, HelpText<"Enable MIP machine function coverage instrumentation.">;
+def fno_machine_profile_function_coverage : Flag<["-"], "fno-machine-profile-function-coverage">, Group<f_Group>,
+    Flags<[CC1Option]>, HelpText<"Disable MIP machine function coverage instrumentation.">;
+def fmachine_profile_block_coverage : Flag<["-"], "fmachine-profile-block-coverage">, Group<f_Group>,
+    Flags<[CC1Option]>, HelpText<"Enable MIP machine basic block coverage instrumentation.">;
+def fno_machine_profile_block_coverage : Flag<["-"], "fno-machine-profile-block-coverage">, Group<f_Group>,
+    Flags<[CC1Option]>, HelpText<"Disable MIP machine basic block coverage instrumentation.">;
+def fmachine_profile_call_graph : Flag<["-"], "fmachine-profile-call-graph">, Group<f_Group>, Flags<[CC1Option]>,
+    HelpText<"Enable full MIP instrumentation. Cannot be used with -fmachine-profile-function-coverage.">;
+def fno_machine_profile_call_graph : Flag<["-"], "fno-machine-profile-call-graph">, Group<f_Group>, Flags<[CC1Option]>,
+    HelpText<"Disable full MIP instrumentation.">;
+def fmachine_profile_runtime_buffer_EQ : Joined<["-"], "fmachine-profile-runtime-buffer=">, Group<f_Group>,
+    Flags<[CC1Option]>, MetaVarName<"<RuntimeBufferSize>">,
+    HelpText<"Allocate a buffer of <RuntimeBufferSize> bytes to hold machine function call samples.">;
+def fmachine_profile_link_unit_name_EQ : Joined<["-"], "fmachine-profile-link-unit-name=">,
+    Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<LinkUnitName>">,
+    HelpText<"Use <LinkUnitName> to identify this link unit.">;
+def fno_machine_profile_runtime : Flag<["-"], "fno-machine-profile-runtime">, Group<f_Group>, Flags<[CC1Option]>,
+    HelpText<"Do not link the machine profile runtime.">;
+def fno_machine_profile_dump : Flag<["-"], "fno-machine-profile-dump">, Group<f_Group>, Flags<[CC1Option]>,
+    HelpText<"Do not dump a raw machine profile when the program exits.">;
+def fmachine_profile_function_group_count_EQ : Joined<["-"], "fmachine-profile-function-group-count=">, Group<f_Group>,
+    Flags<[CC1Option]>, MetaVarName<"<N>">,
+    HelpText<"Partition the machine functions into <N> groups and instrument the group specified by -fmachine-profile-selected-function-group.">;
+def fmachine_profile_selected_function_group_EQ : Joined<["-"], "fmachine-profile-selected-function-group=">,
+    Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<i>">,
+    HelpText<"Instrument only group <i>. Must be in the range [0, -fmachine-profile-function-group-count).">;
+def fmachine_profile_use_EQ : Joined<["-"], "fmachine-profile-use=">,
+    Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<pathnames>">,
+    HelpText<"Use MIP profile data from <pathnames> for profile-guided optimization, where <pathnames> is a comma separated ordered list of .mip profiles.">;
+
 def fprofile_generate : Flag<["-"], "fprofile-generate">,
     Group<f_Group>, Flags<[CoreOption]>,
     HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
 def fprofile_generate_EQ : Joined<["-"], "fprofile-generate=">,
     Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<directory>">,
     HelpText<"Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
 def fcs_profile_generate : Flag<["-"], "fcs-profile-generate">,
     Group<f_Group>, Flags<[CoreOption]>,

clang/include/clang/Driver/ToolChain.h

public:
   std::string getArchSpecificLibPath() const;
 
   // Returns <OSname> part of above.
   virtual StringRef getOSLibName() const;
 
   /// needsProfileRT - returns true if instrumentation profile is on.
   static bool needsProfileRT(const llvm::opt::ArgList &Args);
 
+  /// Returns true if machine profile instrumentation is on.
+  static bool needsMachineProfileRT(const llvm::opt::ArgList &Args);
+
   /// Returns true if gcov instrumentation (-fprofile-arcs or --coverage) is on.
   static bool needsGCovInstrumentation(const llvm::opt::ArgList &Args);
 
   /// IsUnwindTablesDefault - Does this tool chain use -funwind-tables
   /// by default.
   virtual bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const;
 
   /// Test whether this toolchain supports outline atomics by default.
public:
   bool addFastMathRuntimeIfAvailable(
     const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const;
 
   /// addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass
   /// a suitable profile runtime library to the linker.
   virtual void addProfileRTLibs(const llvm::opt::ArgList &Args,
                                 llvm::opt::ArgStringList &CmdArgs) const;
 
+  /// addMachineProfileRTLibs - When -fmachine-profile-generate is specified,
+  /// try to pass a suitable profile runtime library to the linker.
+  virtual void addMachineProfileRTLibs(const llvm::opt::ArgList &Args,
+                                       llvm::opt::ArgStringList &CmdArgs) const;
+
   /// Add arguments to use system-specific CUDA includes.
   virtual void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                                   llvm::opt::ArgStringList &CC1Args) const;
 
   /// Add arguments to use system-specific HIP includes.
   virtual void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                                  llvm::opt::ArgStringList &CC1Args) const;
 

clang/lib/Driver/ToolChain.cpp

return Args.hasArg(options::OPT_fprofile_generate) ||
          Args.hasArg(options::OPT_fcs_profile_generate) ||
          Args.hasArg(options::OPT_fcs_profile_generate_EQ) ||
          Args.hasArg(options::OPT_fprofile_instr_generate) ||
          Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
          Args.hasArg(options::OPT_fcreate_profile) ||
          Args.hasArg(options::OPT_forder_file_instrumentation);
 }
 
+bool ToolChain::needsMachineProfileRT(const ArgList &Args) {
+  return Args.hasFlag(options::OPT_fmachine_profile_generate,
+                      options::OPT_fno_machine_profile_generate, false) &&
+         !Args.hasArg(options::OPT_fno_machine_profile_runtime);
+}
+
 bool ToolChain::needsGCovInstrumentation(const llvm::opt::ArgList &Args) {
   return Args.hasArg(options::OPT_coverage) ||
          Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
                       false);
 }
 
 Tool *ToolChain::SelectTool(const JobAction &JA) const {
   if (D.IsFlangMode() && getDriver().ShouldUseFlangCompiler(JA)) return getFlang();

 void ToolChain::addProfileRTLibs(const llvm::opt::ArgList &Args,
                                  llvm::opt::ArgStringList &CmdArgs) const {
   if (!needsProfileRT(Args) && !needsGCovInstrumentation(Args))
     return;
 
   CmdArgs.push_back(getCompilerRTArgString(Args, "profile"));
 }
 
+void ToolChain::addMachineProfileRTLibs(
+    const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const {
+  if (!needsMachineProfileRT(Args))
+    return;
+
+  CmdArgs.push_back(getCompilerRTArgString(Args, "mip"));
+}
+
 ToolChain::RuntimeLibType ToolChain::GetRuntimeLibType(
     const ArgList &Args) const {
   if (runtimeLibType)
     return *runtimeLibType;
 
   const Arg* A = Args.getLastArg(options::OPT_rtlib_EQ);
   StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_RTLIB;
 

clang/lib/Driver/ToolChains/AIX.cpp

void aix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   // Add directory to library search path.
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   ToolChain.AddFilePathLibArgs(Args, CmdArgs);
   ToolChain.addProfileRTLibs(Args, CmdArgs);
 
   if (getToolChain().ShouldLinkCXXStdlib(Args))
     getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
 
+  ToolChain.addMachineProfileRTLibs(Args, CmdArgs);
+
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
 
     // Support POSIX threads if "-pthreads" or "-pthread" is present.
     if (Args.hasArg(options::OPT_pthreads, options::OPT_pthread))
       CmdArgs.push_back("-lpthreads");
 
     if (D.CCCIsCXX())

clang/lib/Driver/ToolChains/Clang.cpp

if (EmitCovData) {
       }
       llvm::sys::path::replace_extension(CoverageFilename, "gcda");
       CmdArgs.push_back("-coverage-data-file");
       CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
     }
   }
 }
 
+static void addMachineProfileFlags(const Driver &D, const ArgList &Args,
+                                   ArgStringList &CmdArgs) {
+  // FIXME: Machine profile generation flags need to be added to linker args
+  //        when LTO is on.
+  if (!D.isUsingLTO()) {
+    bool HasMIPFlags = false;
+    if (Args.hasFlag(options::OPT_fmachine_profile_generate,
+                     options::OPT_fno_machine_profile_generate, false)) {
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-enable-machine-instrumentation");
+      // TODO: Add a tool to run `llvm-objcopy` and `llvm-mipdata` to fully
+      // extract and create an empty .mip file after the link step.
+      HasMIPFlags = true;
+    }
+
+    if (Arg *A = Args.getLastArg(options::OPT_fmachine_profile_use_EQ)) {
+      StringRef value = A->getValue();
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back(Args.MakeArgString("-machine-profile-use=" + value));
+      HasMIPFlags = true;
+    }
+
+    if (!HasMIPFlags)
+      return;
+
+    std::string LinkUnitName;
+    if (const Arg *A =
+            Args.getLastArg(options::OPT_fmachine_profile_link_unit_name_EQ)) {
+      LinkUnitName = A->getValue();
+    } else if (const Arg *A = Args.getLastArg(options::OPT_o)) {
+      LinkUnitName = A->getValue();
+    } else {
+      LinkUnitName = D.getDefaultImageName();
+    }
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back(Args.MakeArgString("-link-unit-name=" + LinkUnitName));
+
+    if (Args.hasFlag(options::OPT_fmachine_profile_function_coverage,
+                     options::OPT_fno_machine_profile_function_coverage,
+                     false)) {
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-enable-machine-function-coverage");
+    } else if (Args.hasFlag(options::OPT_fmachine_profile_call_graph,
+                            options::OPT_fno_machine_profile_call_graph,
+                            true)) {
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-enable-machine-call-graph");
+    }
+
+    if (Args.hasFlag(options::OPT_fmachine_profile_block_coverage,
+                     options::OPT_fno_machine_profile_block_coverage, false)) {
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-enable-machine-block-coverage");
+    }
+
+    if (const Arg *A =
+            Args.getLastArg(options::OPT_fmachine_profile_runtime_buffer_EQ)) {
+      StringRef S = A->getValue();
+      unsigned RuntimeBufferSize;
+      if (S.getAsInteger(0, RuntimeBufferSize))
+        D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back(Args.MakeArgString("-machine-profile-runtime-buffer=" +
+                                           Twine(RuntimeBufferSize)));
+    }
+
+    unsigned GroupCount = 1;
+    if (const Arg *A = Args.getLastArg(
+            options::OPT_fmachine_profile_function_group_count_EQ)) {
+      StringRef S = A->getValue();
+      if (S.getAsInteger(0, GroupCount) || GroupCount < 1)
+        D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
+      // TODO: Add these args in the linker if we are using LTO.
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back(Args.MakeArgString(
+          "-machine-profile-function-group-count=" + Twine(GroupCount)));
+    }
+
+    if (const Arg *A = Args.getLastArg(
+            options::OPT_fmachine_profile_selected_function_group_EQ)) {
+      unsigned SelectedGroup;
+      StringRef S = A->getValue();
+      if (S.getAsInteger(0, SelectedGroup) || SelectedGroup >= GroupCount)
+        D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back(Args.MakeArgString(
+          "-machine-profile-selected-function-group=" + Twine(SelectedGroup)));
+    }
+  }
+}
+
 /// Check whether the given input tree contains any compilation actions.
 static bool ContainsCompileAction(const Action *A) {
   if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
     return true;
 
   for (const auto &AI : A->inputs())
     if (ContainsCompileAction(AI))
       return true;
Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
                   options::OPT_finstrument_function_entry_bare);
 
   // NVPTX/AMDGCN doesn't support PGO or coverage. There's no runtime support
   // for sampling, overhead of call arc collection is way too high and there's
   // no way to collect the output.
   if (!Triple.isNVPTX() && !Triple.isAMDGCN())
     addPGOAndCoverageFlags(TC, C, D, Output, Args, CmdArgs);
 
+  addMachineProfileFlags(D, Args, CmdArgs);
+
   Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
 
   // Add runtime flag for PS4 when PGO, coverage, or sanitizers are enabled.
   if (RawTriple.isPS4CPU() &&
       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     PS4cpu::addProfileRTArgs(TC, Args, CmdArgs);
     PS4cpu::addSanitizerArgs(TC, CmdArgs);
   }

clang/lib/Driver/ToolChains/Darwin.h

public:
 
   /// Add any profiling runtime libraries that are needed. This is essentially a
   /// MachO specific version of addProfileRT in Tools.cpp.
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override {
     // There aren't any profiling libs for embedded targets currently.
   }
 
+  /// Add any profiling runtime libraries that are needed. This is essentially a
+  /// MachO specific version of addMachineProfileRT in Tools.cpp.
+  void
+  addMachineProfileRTLibs(const llvm::opt::ArgList &Args,
+                          llvm::opt::ArgStringList &CmdArgs) const override {
+    // There aren't any profiling libs for embedded targets currently.
+  }
+
   /// }
   /// @name ToolChain Implementation
   /// {
 
   types::ID LookupTypeForExtension(StringRef Ext) const override;
 
   bool HasNativeLLVMSupport() const override;
 
public:
   bool isKernelStatic() const override {
     return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) &&
             !isTargetWatchOS());
   }
 
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override;
 
+  void
+  addMachineProfileRTLibs(const llvm::opt::ArgList &Args,
+                          llvm::opt::ArgStringList &CmdArgs) const override;
+
 protected:
   /// }
   /// @name Darwin specific Toolchain functions
   /// {
 
   // FIXME: Eliminate these ...Target functions and derive separate tool chains
   // for these targets and put version in constructor.
   void setTarget(DarwinPlatformKind Platform, DarwinEnvironmentKind Environment,

clang/lib/Driver/ToolChains/Darwin.cpp

 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/MIP/MIP.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <cstdlib> // ::getenv
if (LinkingOutput) {
     CmdArgs.push_back("-final_output");
     CmdArgs.push_back(LinkingOutput);
   }
 
   if (Args.hasArg(options::OPT_fnested_functions))
     CmdArgs.push_back("-allow_stack_execute");
 
   getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
+  getMachOToolChain().addMachineProfileRTLibs(Args, CmdArgs);
 
   StringRef Parallelism = getLTOParallelism(Args, getToolChain().getDriver());
   if (!Parallelism.empty()) {
     CmdArgs.push_back("-mllvm");
     unsigned NumThreads =
         llvm::get_threadpool_strategy(Parallelism)->compute_thread_count();
     CmdArgs.push_back(Args.MakeArgString("-threads=" + Twine(NumThreads)));
   }
for (auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_data}) {
       addSectalignToPage(
           Args, CmdArgs, "__DATA",
           llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
                                         /*AddSegmentInfo=*/false));
     }
   }
 }
 
+void Darwin::addMachineProfileRTLibs(const ArgList &Args,
+                                     ArgStringList &CmdArgs) const {
+  if (!needsMachineProfileRT(Args))
+    return;
+
+  AddLinkRuntimeLib(Args, CmdArgs, "mip",
+                    RuntimeLinkOptions(RLO_AlwaysLink | RLO_FirstLink));
+
+  if (!Args.hasArg(options::OPT_fno_machine_profile_dump))
+    addExportedSymbol(CmdArgs, "_" MIP_RUNTIME_SYMBOL_NAME);
+}
+
 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
                                           ArgStringList &CmdArgs,
                                           StringRef Sanitizer,
                                           bool Shared) const {
   auto RLO = RuntimeLinkOptions(RLO_AlwaysLink | (Shared ? RLO_AddRPath : 0U));
   AddLinkRuntimeLib(Args, CmdArgs, Sanitizer, RLO, Shared);
 }
 

clang/lib/Driver/ToolChains/DragonFly.cpp

if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(
           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
   }
 
   getToolChain().addProfileRTLibs(Args, CmdArgs);
+  getToolChain().addMachineProfileRTLibs(Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(std::make_unique<Command>(JA, *this,
                                          ResponseFileSupport::AtFileCurCP(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.

clang/lib/Driver/ToolChains/FreeBSD.cpp

if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     if (Args.hasArg(options::OPT_shared) || IsPIE)
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
   }
 
   ToolChain.addProfileRTLibs(Args, CmdArgs);
+  ToolChain.addMachineProfileRTLibs(Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(std::make_unique<Command>(JA, *this,
                                          ResponseFileSupport::AtFileCurCP(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.

clang/lib/Driver/ToolChains/Fuchsia.h

std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
                                           types::ID InputType) const override;
 
   SanitizerMask getSupportedSanitizers() const override;
   SanitizerMask getDefaultSanitizers() const override;
 
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override;
 
+  void
+  addMachineProfileRTLibs(const llvm::opt::ArgList &Args,
+                          llvm::opt::ArgStringList &CmdArgs) const override;
+
   RuntimeLibType
   GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
   CXXStdlibType
   GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
 
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
                              Action::OffloadKind DeviceOffloadKind) const override;

clang/lib/Driver/ToolChains/Fuchsia.cpp

 //===--- Fuchsia.cpp - Fuchsia ToolChain Implementations --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Fuchsia.h"
 #include "CommonArgs.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
+#include "llvm/MIP/MIP.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
if (D.isUsingLTO()) {
     addLTOOptions(ToolChain, Args, CmdArgs, Output, Inputs[0],
                   D.getLTOMode() == LTOK_Thin);
   }
 
   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
   bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
   ToolChain.addProfileRTLibs(Args, CmdArgs);
+  ToolChain.addMachineProfileRTLibs(Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (Args.hasArg(options::OPT_static))
       CmdArgs.push_back("-Bdynamic");
 
     if (D.CCCIsCXX()) {
       if (ToolChain.ShouldLinkCXXStdlib(Args)) {
         bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
void Fuchsia::addProfileRTLibs(const llvm::opt::ArgList &Args,
                                llvm::opt::ArgStringList &CmdArgs) const {
   // Add linker option -u__llvm_profile_runtime to cause runtime
   // initialization module to be linked in.
   if (needsProfileRT(Args))
     CmdArgs.push_back(Args.MakeArgString(
         Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
   ToolChain::addProfileRTLibs(Args, CmdArgs);
 }
+
+void Fuchsia::addMachineProfileRTLibs(const llvm::opt::ArgList &Args,
+                                      llvm::opt::ArgStringList &CmdArgs) const {
+  // Add linker option -u__llvm_mip_runtime to cause runtime
+  // initialization module to be linked in.
+  if (needsMachineProfileRT(Args) &&
+      !Args.hasArg(options::OPT_fno_machine_profile_dump)) {
+    CmdArgs.push_back(Args.MakeArgString("-u" MIP_RUNTIME_SYMBOL_NAME));
+  }
+  ToolChain::addProfileRTLibs(Args, CmdArgs);
+}

clang/lib/Driver/ToolChains/Gnu.cpp

if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
     CmdArgs.push_back("--no-demangle");
 
   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
   bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
   addLinkerCompressDebugSectionsOption(ToolChain, Args, CmdArgs);
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
   // The profile runtime also needs access to system libraries.
   getToolChain().addProfileRTLibs(Args, CmdArgs);
+  getToolChain().addMachineProfileRTLibs(Args, CmdArgs);
 
   if (D.CCCIsCXX() &&
       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (ToolChain.ShouldLinkCXXStdlib(Args)) {
       bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
                                  !Args.hasArg(options::OPT_static);
       if (OnlyLibstdcxxStatic)
         CmdArgs.push_back("-Bstatic");

clang/lib/Driver/ToolChains/Linux.h

public:
   bool
   IsAArch64OutlineAtomicsDefault(const llvm::opt::ArgList &Args) const override;
   bool isPIEDefault() const override;
   bool isNoExecStackDefault() const override;
   bool IsMathErrnoDefault() const override;
   SanitizerMask getSupportedSanitizers() const override;
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override;
+  void
+  addMachineProfileRTLibs(const llvm::opt::ArgList &Args,
+                          llvm::opt::ArgStringList &CmdArgs) const override;
   std::string computeSysRoot() const override;
 
   std::string getDynamicLinker(const llvm::opt::ArgList &Args) const override;
 
   void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const override;
 
   std::vector<std::string> ExtraOpts;
 

clang/lib/Driver/ToolChains/Linux.cpp

 #include "Arch/PPC.h"
 #include "Arch/RISCV.h"
 #include "CommonArgs.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Distro.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
+#include "llvm/MIP/MIP.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <system_error>
 
 using namespace clang::driver;
void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
   // Add linker option -u__llvm_profile_runtime to cause runtime
   // initialization module to be linked in.
   if (needsProfileRT(Args))
     CmdArgs.push_back(Args.MakeArgString(
         Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
   ToolChain::addProfileRTLibs(Args, CmdArgs);
 }
 
+void Linux::addMachineProfileRTLibs(const llvm::opt::ArgList &Args,
+                                    llvm::opt::ArgStringList &CmdArgs) const {
+  // Add linker option -u__llvm_mip_runtime to cause runtime
+  // initialization module to be linked in.
+  if (needsMachineProfileRT(Args) &&
+      !Args.hasArg(options::OPT_fno_machine_profile_dump)) {
+    CmdArgs.push_back(Args.MakeArgString("-u" MIP_RUNTIME_SYMBOL_NAME));
+  }
+  ToolChain::addMachineProfileRTLibs(Args, CmdArgs);
+}
+
 llvm::DenormalMode
 Linux::getDefaultDenormalModeForType(const llvm::opt::ArgList &DriverArgs,
                                      const JobAction &JA,
                                      const llvm::fltSemantics *FPType) const {
   switch (getTriple().getArch()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64: {
     std::string Unused;

clang/lib/Driver/ToolChains/NetBSD.cpp

if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
           Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(
           Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
   }
 
   ToolChain.addProfileRTLibs(Args, CmdArgs);
+  ToolChain.addMachineProfileRTLibs(Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
   C.addCommand(std::make_unique<Command>(JA, *this,
                                          ResponseFileSupport::AtFileCurCP(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.

clang/lib/Driver/ToolChains/Solaris.cpp

void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     CmdArgs.push_back(
         Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
   }
   CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
 
   getToolChain().addProfileRTLibs(Args, CmdArgs);
+  getToolChain().addMachineProfileRTLibs(Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
 static StringRef getSolarisLibSuffix(const llvm::Triple &Triple) {
   switch (Triple.getArch()) {

clang/test/CMakeLists.txt

list(APPEND CLANG_TEST_DEPS
     llvm-cat
     llvm-cxxfilt
     llvm-dis
     llvm-dwarfdump
     llvm-ifs
     llvm-lto2
     llvm-modextract
     llvm-nm
+    llvm-mipdata
     llvm-objcopy
     llvm-objdump
     llvm-profdata
     llvm-rc
     llvm-readelf
     llvm-readobj
     llvm-strip
     llvm-symbolizer

clang/test/Driver/clang-mip-flags.c

+// REQUIRES: clang-driver
+// UNSUPPORTED: windows-msvc
+
+// RUN: %clang -### -fmachine-profile-use=/path/to/profile.mip %s 2>&1 | FileCheck %s --check-prefix USE
+// USE: "-cc1"
+// USE-SAME: "-mllvm" "-machine-profile-use=/path/to/profile.mip"
+// USE-SAME: "-mllvm" "-link-unit-name=a.out"
+
+// RUN: %clang -### -fmachine-profile-use=/path/to/profile.mip -o my-executable %s 2>&1 | FileCheck %s --check-prefix USE-OUTPUT
+// RUN: %clang -### -fmachine-profile-use=/path/to/profile.mip -fmachine-profile-link-unit-name=my-executable %s 2>&1 | FileCheck %s --check-prefix USE-OUTPUT
+// USE-OUTPUT: "-cc1"
+// USE-OUTPUT-SAME: "-mllvm" "-link-unit-name=my-executable"
+
+// RUN: %clang -### -fmachine-profile-generate %s 2>&1 | FileCheck %s --check-prefix GEN
+// RUN: %clang -### -fno-machine-profile-generate -fmachine-profile-generate %s 2>&1 | FileCheck %s --check-prefix GEN
+// GEN: "-cc1"
+// GEN-SAME: "-mllvm" "-enable-machine-instrumentation"
+// GEN-SAME: "-mllvm" "-link-unit-name=a.out"
+
+// RUN: %clang -### %s 2>&1 | FileCheck %s --check-prefix NOGEN
+// RUN: %clang -### -fno-machine-profile-generate %s 2>&1 | FileCheck %s --check-prefix NOGEN
+// RUN: %clang -### -fmachine-profile-generate -fno-machine-profile-generate %s 2>&1 | FileCheck %s --check-prefix NOGEN
+// NOGEN-NOT: "-enable-machine-instrumentation"
+
+// RUN: %clang -### -fmachine-profile-generate -fmachine-profile-function-coverage %s 2>&1 | FileCheck %s --check-prefix FUNCCOV
+// FUNCCOV: "-cc1"
+// FUNCCOV-SAME: "-mllvm" "-enable-machine-function-coverage"
+
+// RUN: %clang -### -fmachine-profile-generate -fmachine-profile-block-coverage %s 2>&1 | FileCheck %s --check-prefix BLOCKCOV
+// BLOCKCOV: "-cc1"
+// BLOCKCOV-SAME: "-mllvm" "-enable-machine-block-coverage"
+
+// RUN: %clang -### -fmachine-profile-generate %s 2>&1 | FileCheck %s --check-prefix FULL
+// RUN: %clang -### -fmachine-profile-generate -fmachine-profile-call-graph %s 2>&1 | FileCheck %s --check-prefix FULL
+// FULL: "-cc1"
+// FULL-SAME: "-mllvm" "-enable-machine-call-graph"
+
+// RUN: %clang -### -fmachine-profile-generate -fmachine-profile-runtime-buffer=1024 %s 2>&1 | FileCheck %s --check-prefix RUNTIMEBUF
+// RUNTIMEBUF: "-cc1"
+// RUNTIMEBUF-SAME: "-mllvm" "-machine-profile-runtime-buffer=1024"
+
+// RUN: %clang -### -fmachine-profile-generate -fmachine-profile-function-group-count=22 -fmachine-profile-selected-function-group=11 %s 2>&1 | FileCheck %s --check-prefix GEN-GROUPS
+// GEN-GROUPS: "-cc1"
+// GEN-GROUPS-SAME: "-mllvm" "-machine-profile-function-group-count=22"
+// GEN-GROUPS-SAME: "-mllvm" "-machine-profile-selected-function-group=11"