[Clang][AIX][p]Enable -p Functionality

[francii]

Summary

This patch enables -p functionality into Clang on AIX and Linux
To create parity with GCC.

The purpose of the -p flag is similar to that of -pg, but the
results are analyzed with the prof tool as opposed to the gprof tool.
More details can be found in this RFC post:
https://discourse.llvm.org/t/rfc-add-p-driver-support-to-clang/66013?u=francii

On AIX, compiling with -p links against mcrt0.o
and produces a mon.out file analyzed with the prof tool,
while -pg links against gcrt0.o and produces a gmon.outfile
analyzed with the gprof tool. The differences are therefore
only a concern when linking, so calling -p will push -pg to cc1.

An AIX test for -p already exists, and I recently
another test was added here:
https://github.com/llvm/llvm-project/commit/dc9846ce988b9ddfcbc42cd462d5d94b634b3161
As such, there is no AIX test case attached to this patch.

[francii]

This comment was removed by francii.

[francii]

Added Linux implementation and test case

[francii]

Updated Linux test case
Added profiled library search for AIX.

[francii]

Add profiled libraries check AIX

[francii]

Add sysroot check to aix-ld.c test cases

[francii]

Specify prof and gprof in help text

[MaskRay]

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

[francii]

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

[MaskRay]

In D137753#3935126, @francii wrote:

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

The current warning: argument unused during compilation: '-p' [-Wunused-command-line-argument] is good for Linux.
In the future Linux can try removing -p.

[francii]

Recall that the goal with -p is to create parity with GCC (at least with Linux and AIX), as per the RFC discussion.

In D137753#3935138, @MaskRay wrote:

In D137753#3935126, @francii wrote:

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

The current warning: argument unused during compilation: '-p' [-Wunused-command-line-argument] is good for Linux.
In the future Linux can try removing -p.

The current behaviour of ignoring the option without stopping with an error return code is not a good one.

Recall that the goal is to create parity with GCC, as per the RFC post.

Is there a reason this flag shouldn't be supported on Linux? Specifically, what is your justification for diverging from GCC on this matter?

[MaskRay]

In D137753#3935305, @francii wrote:

Recall that the goal with -p is to create parity with GCC (at least with Linux and AIX), as per the RFC discussion.

In D137753#3935138, @MaskRay wrote:

In D137753#3935126, @francii wrote:

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

The current warning: argument unused during compilation: '-p' [-Wunused-command-line-argument] is good for Linux.
In the future Linux can try removing -p.

The current behaviour of ignoring the option without stopping with an error return code is not a good one.

Recall that the goal is to create parity with GCC, as per the RFC post.

Is there a reason this flag shouldn't be supported on Linux? Specifically, what is your justification for diverging from GCC on this matter?

It's a legacy option (at least for Linux, FreeBSD, etc) and we don't want the usage to grow. I objected in the RFC, either. Note that the objection is not only from me, also from a Linux distro folk I checked with.

[francii]

In D137753#3935391, @MaskRay wrote:

In D137753#3935305, @francii wrote:

Recall that the goal with -p is to create parity with GCC (at least with Linux and AIX), as per the RFC discussion.

In D137753#3935138, @MaskRay wrote:

In D137753#3935126, @francii wrote:

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

The current warning: argument unused during compilation: '-p' [-Wunused-command-line-argument] is good for Linux.
In the future Linux can try removing -p.

The current behaviour of ignoring the option without stopping with an error return code is not a good one.

Recall that the goal is to create parity with GCC, as per the RFC post.

Is there a reason this flag shouldn't be supported on Linux? Specifically, what is your justification for diverging from GCC on this matter?

It's a legacy option (at least for Linux, FreeBSD, etc) and we don't want the usage to grow. I objected in the RFC, either. Note that the objection is not only from me, also from a Linux distro folk I checked with.

If we aren't adding Linux functionality, we should make it throw an error at the same time.

Once again, ignoring the option without stopping with an error code is not ideal. I can update this patch to throw an error on Linux, much like this patch for z/OS: https://reviews.llvm.org/D137756

[MaskRay]

In D137753#3935617, @francii wrote:

In D137753#3935391, @MaskRay wrote:

In D137753#3935305, @francii wrote:

Recall that the goal with -p is to create parity with GCC (at least with Linux and AIX), as per the RFC discussion.

In D137753#3935138, @MaskRay wrote:

In D137753#3935126, @francii wrote:

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

The current warning: argument unused during compilation: '-p' [-Wunused-command-line-argument] is good for Linux.
In the future Linux can try removing -p.

The current behaviour of ignoring the option without stopping with an error return code is not a good one.

Recall that the goal is to create parity with GCC, as per the RFC post.

Is there a reason this flag shouldn't be supported on Linux? Specifically, what is your justification for diverging from GCC on this matter?

It's a legacy option (at least for Linux, FreeBSD, etc) and we don't want the usage to grow. I objected in the RFC, either. Note that the objection is not only from me, also from a Linux distro folk I checked with.

If we aren't adding Linux functionality, we should make it throw an error at the same time.

Once again, ignoring the option without stopping with an error code is not ideal. I can update this patch to throw an error on Linux, much like this patch for z/OS: https://reviews.llvm.org/D137756

I acknowledge that the current state is bad. Reject it for FreeBSD/Linux (perhaps most OSes. An OS can opt in if their platform really needs this) is likely fine. I don't think -p has many uses.

Something like D137756 will be nice, but I think it can be done in clang/lib/Driver/ToolChains/Clang.cpp: D138255

[francii]

In D137753#3935391, @MaskRay wrote:

In D137753#3935305, @francii wrote:

Recall that the goal with -p is to create parity with GCC (at least with Linux and AIX), as per the RFC discussion.

In D137753#3935138, @MaskRay wrote:

In D137753#3935126, @francii wrote:

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

The current warning: argument unused during compilation: '-p' [-Wunused-command-line-argument] is good for Linux.
In the future Linux can try removing -p.

The current behaviour of ignoring the option without stopping with an error return code is not a good one.

Recall that the goal is to create parity with GCC, as per the RFC post.

Is there a reason this flag shouldn't be supported on Linux? Specifically, what is your justification for diverging from GCC on this matter?

It's a legacy option (at least for Linux, FreeBSD, etc) and we don't want the usage to grow. I objected in the RFC, either. Note that the objection is not only from me, also from a Linux distro folk I checked with.

If we aren't adding Linux functionality, we should make it throw an error at the same time.

Once again, ignoring the option without stopping with an error code is not ideal.

I can update this patch to throw an error, much like this patch for z/OS: https://reviews.llvm.org/D137756

In D137753#3935674, @MaskRay wrote:

In D137753#3935617, @francii wrote:

In D137753#3935391, @MaskRay wrote:

In D137753#3935305, @francii wrote:

Recall that the goal with -p is to create parity with GCC (at least with Linux and AIX), as per the RFC discussion.

In D137753#3935138, @MaskRay wrote:

In D137753#3935126, @francii wrote:

In D137753#3934932, @MaskRay wrote:

Please make -p accepted for AIX only and don't change the semantics for other targets in this patch. For FreeBSD and Linux (musl and gnu) we can try rejecting -p. If OpenBSD wants to make -p an alias for -pg, that's fine.

We can make -p emit a message on Linux while also accepting it as an alias to -pg. Do you have a suggestion as to what that message would be?

The current warning: argument unused during compilation: '-p' [-Wunused-command-line-argument] is good for Linux.
In the future Linux can try removing -p.

The current behaviour of ignoring the option without stopping with an error return code is not a good one.

Recall that the goal is to create parity with GCC, as per the RFC post.

Is there a reason this flag shouldn't be supported on Linux? Specifically, what is your justification for diverging from GCC on this matter?

It's a legacy option (at least for Linux, FreeBSD, etc) and we don't want the usage to grow. I objected in the RFC, either. Note that the objection is not only from me, also from a Linux distro folk I checked with.

If we aren't adding Linux functionality, we should make it throw an error at the same time.

Once again, ignoring the option without stopping with an error code is not ideal. I can update this patch to throw an error on Linux, much like this patch for z/OS: https://reviews.llvm.org/D137756

I acknowledge that the current state is bad. Reject it for FreeBSD/Linux (perhaps most OSes. An OS can opt in if their platform really needs this) is likely fine. I don't think -p has many uses.

Something like D137756 will be nice, but I think it can be done in clang/lib/Driver/ToolChains/Clang.cpp: D138255

Thank you, I will remove the Linux/Gnu changes from this patch shortly.

[francii]

Remove Linux changes

[francii]

Add supports profiling check

[francii]

Remove codegen option approach

[francii]

Specifically check for AIX before pushing pg

[francii]

Rebase

[francii]

Rebase

[daltenty]

clang/include/clang/Driver/Options.td

4097

Why is this a cc1 option if it's not used in CC1?

clang/lib/Driver/ToolChains/AIX.cpp

252–260

Maybe I'm a bit confused, I though these options had different handling with respect to the paths? Otherwise, it's simply an alias.

[francii]

Remove cc1 option

[francii]

clang/lib/Driver/ToolChains/AIX.cpp

252–260

You may be referring to lines 167-175 of this same file:

auto getCrt0Basename = [&Args, IsArch32Bit] {
  // Enable gprofiling when "-pg" is specified.
  if (Args.hasArg(options::OPT_pg))
    return IsArch32Bit ? "gcrt0.o" : "gcrt0_64.o";
  // Enable profiling when "-p" is specified.
  else if (Args.hasArg(options::OPT_p))
    return IsArch32Bit ? "mcrt0.o" : "mcrt0_64.o";
  else
    return IsArch32Bit ? "crt0.o" : "crt0_64.o";
};

This is the only time we handle -p differently. With both -p and -pg, we want to link the profiled libraries.

[daltenty]

LGTM, with small nit to address before commit

clang/lib/Driver/ToolChains/Clang.cpp

6297–6298

nit: we can save our selves a query and clarify by writing this as if-elseif

[francii]

Update based on review

[francii]

Rebase

clang/include/clang/Basic/CodeGenOptions.def

 
 VALUE_CODEGENOPT(PatchableFunctionEntryCount , 32, 0) ///< Number of NOPs at function entry
 VALUE_CODEGENOPT(PatchableFunctionEntryOffset , 32, 0)
 
 CODEGENOPT(HotPatch, 1, 0) ///< Supports the Microsoft /HOTPATCH flag and
                            ///< generates a 'patchable-function' attribute.
 
 CODEGENOPT(JMCInstrument, 1, 0) ///< Set when -fjmc is enabled.
-CODEGENOPT(InstrumentForProfiling , 1, 0) ///< Set when -pg is enabled.
+CODEGENOPT(InstrumentForProfiling , 1, 0) ///< Set when -p is enabled.
+CODEGENOPT(InstrumentForProfilingGraph , 1, 0) ///< Set when -pg is enabled.
 CODEGENOPT(CallFEntry , 1, 0) ///< Set when -mfentry is enabled.
 CODEGENOPT(MNopMCount , 1, 0) ///< Set when -mnop-mcount is enabled.
 CODEGENOPT(RecordMCount , 1, 0) ///< Set when -mrecord-mcount is enabled.
 CODEGENOPT(PackedStack , 1, 0) ///< Set when -mpacked-stack is enabled.
 CODEGENOPT(LessPreciseFPMAD  , 1, 0) ///< Enable less precise MAD instructions to
                                      ///< be generated.
 CODEGENOPT(PrepareForLTO     , 1, 0) ///< Set when -flto is enabled on the
                                      ///< compile step.

clang/include/clang/Driver/Options.td

 def object_file_name : Separate<["-"], "object-file-name">, Flags<[CC1Option, CC1AsOption, CoreOption]>,
     Alias<object_file_name_EQ>;
 def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
 def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>,
   MarshallingInfoFlag<DiagnosticOpts<"PedanticErrors">>;
 def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option,FlangOption,FC1Option]>,
   HelpText<"Warn on language extensions">, MarshallingInfoFlag<DiagnosticOpts<"Pedantic">>;
-def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>,
+def p : Flag<["-"], "p">, HelpText<"Enable mcount instrumentation with prof">, Flags<[CC1Option]>,
   MarshallingInfoFlag<CodeGenOpts<"InstrumentForProfiling">>;
+def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation with gprof">, Flags<[CC1Option]>,
+  MarshallingInfoFlag<CodeGenOpts<"InstrumentForProfilingGraph">>;
 def pipe : Flag<["-", "--"], "pipe">,
   HelpText<"Use pipes between commands, when possible">;
 def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
 def prebind : Flag<["-"], "prebind">;
 def preload : Flag<["-"], "preload">;
 def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">,
   HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;
 def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>,

 def print_diagnostic_options : Flag<["-", "--"], "print-diagnostic-options">,
   HelpText<"Print all of Clang's warning options">;
 def private__bundle : Flag<["-"], "private_bundle">;
 def pthreads : Flag<["-"], "pthreads">;
 defm pthread : BoolOption<"", "pthread",
   LangOpts<"POSIXThreads">, DefaultFalse,
   PosFlag<SetTrue, [], "Support POSIX threads in generated code">,
   NegFlag<SetFalse>, BothFlags<[CC1Option]>>;
-def p : Flag<["-"], "p">;
 def pie : Flag<["-"], "pie">, Group<Link_Group>;
 def static_pie : Flag<["-"], "static-pie">, Group<Link_Group>;
 def read__only__relocs : Separate<["-"], "read_only_relocs">;
 def remap : Flag<["-"], "remap">;
 def rewrite_objc : Flag<["-"], "rewrite-objc">, Flags<[NoXarchOption,CC1Option]>,
   HelpText<"Rewrite Objective-C source to C++">, Group<Action_Group>;
 def rewrite_legacy_objc : Flag<["-"], "rewrite-legacy-objc">, Flags<[NoXarchOption]>,
   HelpText<"Rewrite Legacy Objective-C source to C++">;

clang/lib/CodeGen/BackendUtil.cpp

if (IsThinLTOPostLink)
             MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,
                                            /*ImportSummary=*/nullptr,
                                            /*DropTypeTests=*/true));
           });
 
     if (CodeGenOpts.InstrumentFunctions ||
         CodeGenOpts.InstrumentFunctionEntryBare ||
         CodeGenOpts.InstrumentFunctionsAfterInlining ||
-        CodeGenOpts.InstrumentForProfiling) {
+        CodeGenOpts.InstrumentForProfiling ||
+        CodeGenOpts.InstrumentForProfilingGraph) {
       PB.registerPipelineStartEPCallback(
           [](ModulePassManager &MPM, OptimizationLevel Level) {
             MPM.addPass(createModuleToFunctionPassAdaptor(
                 EntryExitInstrumenterPass(/*PostInlining=*/false)));
           });
       PB.registerOptimizerLastEPCallback(
           [](ModulePassManager &MPM, OptimizationLevel Level) {
             MPM.addPass(createModuleToFunctionPassAdaptor(

clang/lib/CodeGen/CodeGenFunction.cpp

if (CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
       CurFn->addFnAttr("instrument-function-entry-inlined",
                        "__cyg_profile_func_enter_bare");
   }
 
   // Since emitting the mcount call here impacts optimizations such as function
   // inlining, we just add an attribute to insert a mcount call in backend.
   // The attribute "counting-function" is set to mcount function name which is
   // architecture dependent.
-  if (CGM.getCodeGenOpts().InstrumentForProfiling) {
+  if (CGM.getCodeGenOpts().InstrumentForProfiling ||
+      CGM.getCodeGenOpts().InstrumentForProfilingGraph) {
     // Calls to fentry/mcount should not be generated if function has
     // the no_instrument_function attribute.
     if (!CurFuncDecl || !CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) {
       if (CGM.getCodeGenOpts().CallFEntry)
         Fn->addFnAttr("fentry-call", "true");
       else {
         Fn->addFnAttr("instrument-function-entry-inlined",
                       getTarget().getMCountName());

clang/lib/Driver/ToolChains/AIX.cpp

if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 
     // 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())
       CmdArgs.push_back("-lm");
 
     CmdArgs.push_back("-lc");
+
+    if (Args.hasArg(options::OPT_p, options::OPT_pg)) {
+      CmdArgs.push_back(Args.MakeArgString((llvm::Twine("-L") + D.SysRoot) +
+                                           "/lib/profiled"));
+      CmdArgs.push_back(Args.MakeArgString((llvm::Twine("-L") + D.SysRoot) +
+                                           "/usr/lib/profiled"));
+    }
   }
 
   const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
 /// AIX - AIX tool chain which can call as(1) and ld(1) directly.
 AIX::AIX(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)

clang/lib/Driver/ToolChains/Clang.cpp

case llvm::Triple::thumb:
     // ARM Darwin targets require a frame pointer to be always present to aid
     // offline debugging via backtraces.
     return Triple.isOSDarwin();
   }
 }
 
 static bool useFramePointerForTargetByDefault(const ArgList &Args,
                                               const llvm::Triple &Triple) {
-  if (Args.hasArg(options::OPT_pg) && !Args.hasArg(options::OPT_mfentry))
+  if (Args.hasArg(options::OPT_p, options::OPT_pg) &&
+      !Args.hasArg(options::OPT_mfentry))
     return true;
 
   switch (Triple.getArch()) {
   case llvm::Triple::xcore:
   case llvm::Triple::wasm32:
   case llvm::Triple::wasm64:
   case llvm::Triple::msp430:
     // XCore never wants frame pointers, regardless of OS.
else {
       CmdArgs.push_back(Args.MakeArgString(
           "-fpatchable-function-entry-offset=" + Twine(Offset)));
     }
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch);
 
   if (TC.SupportsProfiling()) {
+    Args.AddLastArg(CmdArgs, options::OPT_p);
     Args.AddLastArg(CmdArgs, options::OPT_pg);
 
     llvm::Triple::ArchType Arch = TC.getArch();
     if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
       if (Arch == llvm::Triple::systemz || TC.getTriple().isX86())
         A->render(Args, CmdArgs);
       else
         D.Diag(diag::err_drv_unsupported_opt_for_target)
             << A->getAsString(Args) << TripleStr;
     }
     if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
       if (Arch == llvm::Triple::systemz)
         A->render(Args, CmdArgs);
       else
         D.Diag(diag::err_drv_unsupported_opt_for_target)
             << A->getAsString(Args) << TripleStr;
     }
     if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
       if (Arch == llvm::Triple::systemz)
         A->render(Args, CmdArgs);
       else
         D.Diag(diag::err_drv_unsupported_opt_for_target)
             << A->getAsString(Args) << TripleStr;
     }
   }
 
   if (Args.getLastArg(options::OPT_fapple_kext) ||
       (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
     CmdArgs.push_back("-fapple-kext");
 
   Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
   Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);

 
   // Make the compile command echo its inputs for /showFilenames.
   if (Output.getType() == types::TY_Object &&
       Args.hasFlag(options::OPT__SLASH_showFilenames,
                    options::OPT__SLASH_showFilenames_, false)) {
     C.getJobs().getJobs().back()->PrintInputFilenames = true;
   }
 
-  if (Arg *A = Args.getLastArg(options::OPT_pg))
+  if (Arg *A = Args.getLastArg(options::OPT_p, options::OPT_pg))
     if (FPKeepKind == CodeGenOptions::FramePointerKind::None &&
         !Args.hasArg(options::OPT_mfentry))
       D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer"
                                                       << A->getAsString(Args);
 
   // Claim some arguments which clang supports automatically.
 
   // -fpch-preprocess is used with gcc to add a special marker in the output to

clang/lib/Driver/ToolChains/Gnu.cpp

void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
                    options::OPT_r)) {
     if (!isAndroid && !IsIAMCU) {
       const char *crt1 = nullptr;
       if (!Args.hasArg(options::OPT_shared)) {
-        if (Args.hasArg(options::OPT_pg))
+        if (Args.hasArg(options::OPT_p, options::OPT_pg))
           crt1 = "gcrt1.o";
         else if (IsPIE)
           crt1 = "Scrt1.o";
         else if (IsStaticPIE)
           crt1 = "rcrt1.o";
         else
           crt1 = "crt1.o";
       }

clang/test/Driver/aix-ld.c

 // CHECK-LD32-PROF-NOT: "-lc++"
 // CHECK-LD32-PROF-NOT: "-lc++abi"
 // CHECK-LD32-PROF:     "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}aix{{/|\\\\}}libclang_rt.builtins-powerpc.a"
 // CHECK-LD32-PROF-NOT: "--as-needed"
 // CHECK-LD32-PROF:     "-lunwind"
 // CHECK-LD32-PROF-NOT: "--no-as-needed"
 // CHECK-LD32-PROF-NOT: "-lm"
 // CHECK-LD32-PROF:     "-lc"
+// CHECK-LD32-PROF:     "-L[[SYSROOT]]/lib/profiled"
+// CHECK-LD32-PROF:     "-L[[SYSROOT]]/usr/lib/profiled"
 
 // Check powerpc64-ibm-aix7.1.0.0, 64-bit. Enable profiling.
 // RUN: %clang %s -### 2>&1 \
 // RUN:        -resource-dir=%S/Inputs/resource_dir \
 // RUN:        -p \
 // RUN:        --target=powerpc64-ibm-aix7.1.0.0 \
 // RUN:        --sysroot %S/Inputs/aix_ppc_tree \
 // RUN:        --unwindlib=libunwind \

 // CHECK-LD64-PROF-NOT: "-lc++"
 // CHECK-LD64-PROF-NOT: "-lc++abi"
 // CHECK-LD64-PROF:     "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}aix{{/|\\\\}}libclang_rt.builtins-powerpc64.a"
 // CHECK-LD64-PROF-NOT: "--as-needed"
 // CHECK-LD64-PROF:     "-lunwind"
 // CHECK-LD64-PROF-NOT: "--no-as-needed"
 // CHECK-LD64-PROF-NOT: "-lm"
 // CHECK-LD64-PROF:     "-lc"
+// CHECK-LD64-PROF:     "-L[[SYSROOT]]/lib/profiled"
+// CHECK-LD64-PROF:     "-L[[SYSROOT]]/usr/lib/profiled"
 
 // Check powerpc-ibm-aix7.1.0.0, 32-bit. Enable g-profiling.
 // RUN: %clang %s -### 2>&1 \
 // RUN:        -resource-dir=%S/Inputs/resource_dir \
 // RUN:        -pg \
 // RUN:        --target=powerpc-ibm-aix7.1.0.0 \
 // RUN:        --sysroot %S/Inputs/aix_ppc_tree \
 // RUN:        --unwindlib=libunwind \

clang/test/Driver/linux-ld.c

 // detection works.
 // RUN: %clang --target=i386-unknown-linux -no-pie -### %s -ffast-math \
 // RUN:        --gcc-toolchain="" \
 // RUN:        --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s
 // CHECK-CRTFASTMATH: usr/lib/gcc/x86_64-unknown-linux/10.2.0{{/|\\\\}}crtfastmath.o
 // CHECK-NOCRTFASTMATH-NOT: crtfastmath.o
 
+// Check that we link in gcrt1.o when compiling with -p
+// RUN: %clang -p --target=x86_64-unknown-linux -no-pie -### %s \
+// RUN:        --gcc-toolchain="" \
+// RUN:        --sysroot=%S/Inputs/basic_linux_tree 2>& 1 \
+// RUN:   | FileCheck --check-prefix=CHECK-P %s
+// CHECK-P: gcrt1.o
+
 // Check that we link in gcrt1.o when compiling with -pg
 // RUN: %clang -pg --target=x86_64-unknown-linux -no-pie -### %s \
 // RUN:        --gcc-toolchain="" \
 // RUN:        --sysroot=%S/Inputs/basic_linux_tree 2>& 1 \
 // RUN:   | FileCheck --check-prefix=CHECK-PG %s
 // CHECK-PG: gcrt1.o
 
 // GCC forwards -u to the linker.