[HIP][Clang][Driver][RFC] Add driver support for C++ Parallel Algorithm Offload

[AlexVlx]

Summary

This patch adds the Driver changes needed by the standard algorithm offload feature being proposed here: https://discourse.llvm.org/t/rfc-adding-c-parallel-algorithm-offload-support-to-clang-llvm/72159/1. The verbose documentation is included in its parent patch. What this change does can be summed up as follows:

1. add two flags, one for enabling stdpar compilation, the second enabling the optional allocation interposition mode;
2. the flags correspond to new LangOpt members;
3. if we are compiling or linking with -stdpar, we enable HIP; in the compilation case C and C++ inputs are treated as HIP inputs;
4. the ROCm / AMDGPU driver is augmented to look for and include an implementation detail forwarding header, which is provided here https://github.com/ROCmSoftwarePlatform/roc-stdpar/blob/main/include/stdpar_lib.hpp; we error out if the user requested stdpar but the header or its dependencies cannot be found (it is plausible that in the future we'll move the check for the dependencies to the header itself in order to reduce the compiler footprint).

Tests for the behaviour described above are also added.

[AlexVlx]

Removed some accidental noise.

[AlexVlx]

Exploit the fact that ROCm/AMDGPU does LTCG at the moment and for the foreseeable future by moving the accelerator code selection pass to later.

[AlexVlx]

Updating this to reflect the outcome of the RFC, which is that this will be added as a HIP extension exclusively.

[MaskRay]

clang/test/Driver/hipstdpar.c

1 ↗

(On Diff #552556)

Better to use --hipstdpar instead of -hipstdpar.

In GCC, -h is a Joined Separate option that accepts a value.

[AlexVlx]

Use --hipstdpar instead of -hipstdpar in the test.

[AlexVlx]

Gentle ping.

[yaxunl]

clang/include/clang/Basic/DiagnosticDriverKinds.td

75

needs to update the option name, same as below

[AlexVlx]

Use correct flag naming.

[yaxunl]

LGTM. Thanks

[MaskRay]

clang/include/clang/Driver/Options.td

1151

Accept just -- for new options. See --hip-path=.

[MaskRay]

clang/lib/Driver/ToolChains/Clang.cpp

6539

This can use AddLastArg.

[AlexVlx]

Use double dash compiler flags only.

[AlexVlx]

@MaskRay do you think there's anything else that needs adjusting? Thanks.

[MaskRay]

clang/include/clang/Driver/Options.td

1171

The convention is to omit the trailing dot.

clang/lib/Driver/ToolChains/AMDGPU.cpp

340

Prefer concat so that if HIPRocThrustPathArg ends with /, we will not get ...//thrust.

clang/lib/Driver/ToolChains/Clang.cpp

6534

Note that I have refactored the code to use addOptInFlag. You need to remove the repeated OPT_fgpu_allow_device_init checking.

[AlexVlx]

Remove noise, add missing stub folders needed by the test.

clang/lib/Driver/ToolChains/AMDGPU.cpp

340

If you don't mind, I'll do this in a subsequent patch since it's just annoying and not an outright error. The issue being that RocmInstallationDetector is not a ToolChain and isn't friendly to one either, so concat is inaccessible. Addressing that would add a bit of unrelated noise (looking through the file we probably want concat in more places).

[MaskRay]

clang/lib/Driver/ToolChains/AMDGPU.cpp

340

Don't mind:)

[thakis]

This seems to break tests on Mac and windows, see eg http://45.33.8.238/macm1/70415/step_7.txt

Please take a look and revert for now if it takes a while to fix.

[thakis]

Windows: http://45.33.8.238/win/84498/step_7.txt

[AlexVlx]

In D155775#4652683, @thakis wrote:

This seems to break tests on Mac and windows, see eg http://45.33.8.238/macm1/70415/step_7.txt

Please take a look and revert for now if it takes a while to fix.

Whoops, thank you for flagging this, my bad. At the moment (and for the foreseeable future) this is Linux only, so I think I'd rather XFAIL it on non Linux targets, if that's OK.

[yaxunl]

In D155775#4652686, @AlexVlx wrote:

In D155775#4652683, @thakis wrote:

This seems to break tests on Mac and windows, see eg http://45.33.8.238/macm1/70415/step_7.txt

Please take a look and revert for now if it takes a while to fix.

Whoops, thank you for flagging this, my bad. At the moment (and for the foreseeable future) this is Linux only, so I think I'd rather XFAIL it on non Linux targets, if that's OK.

LGTM

[AlexVlx]

https://reviews.llvm.org/rG0701ee69f7ac should fix it, once again apologies for the noise.

[dyung]

Hi @AlexVlx, the test you added is failing on an linux bot, can you take a look and revert if you need time to investigate? It appears it has been failing for over 6 hours.

https://lab.llvm.org/buildbot/#/builders/139/builds/50940

[dyung]

In D155775#4652698, @AlexVlx wrote:

https://reviews.llvm.org/rG0701ee69f7ac should fix it, once again apologies for the noise.

FYI, the test is still failing on the Windows PS5 bot after your change: https://lab.llvm.org/buildbot/#/builders/216/builds/28289

[AlexVlx]

In D155775#4652767, @dyung wrote:

Hi @AlexVlx, the test you added is failing on an linux bot, can you take a look and revert if you need time to investigate? It appears it has been failing for over 6 hours.

https://lab.llvm.org/buildbot/#/builders/139/builds/50940

This is another unsupported target (as is hexagon which is also failing), that I'll temporarily disable, but I admit to being actually confused as to why it's failing there, because the sequence it cannot find appears to be there. Thank you for flagging it.

[dyung]

In D155775#4652773, @AlexVlx wrote:

In D155775#4652767, @dyung wrote:

Hi @AlexVlx, the test you added is failing on an linux bot, can you take a look and revert if you need time to investigate? It appears it has been failing for over 6 hours.

https://lab.llvm.org/buildbot/#/builders/139/builds/50940

This is another unsupported target (as is hexagon which is also failing), that I'll temporarily disable, but I admit to being actually confused as to why it's failing there, because the sequence it cannot find appears to be there. Thank you for flagging it.

Note that this linux bot builds with the ps4 target as the default target.

At this point, would it be easier to add a REQUIRES line for the target the test should support rather than just whack-a-mole for the targets it does not?

[AlexVlx]

In D155775#4652780, @dyung wrote:

In D155775#4652773, @AlexVlx wrote:

In D155775#4652767, @dyung wrote:

Hi @AlexVlx, the test you added is failing on an linux bot, can you take a look and revert if you need time to investigate? It appears it has been failing for over 6 hours.

https://lab.llvm.org/buildbot/#/builders/139/builds/50940

This is another unsupported target (as is hexagon which is also failing), that I'll temporarily disable, but I admit to being actually confused as to why it's failing there, because the sequence it cannot find appears to be there. Thank you for flagging it.

Note that this linux bot builds with the ps4 target as the default target.

At this point, would it be easier to add a REQUIRES line for the target the test should support rather than just whack-a-mole for the targets it does not?

Oh, it definitely would be MUCH easier to add a REQUIRES line, however I'd have had to have thought about that, which I did not, so thank you for the wake up call. I'll update this in a few minutes.

[ro]

In D155775#4652785, @AlexVlx wrote:

In D155775#4652780, @dyung wrote:

At this point, would it be easier to add a REQUIRES line for the target the test should support rather than just whack-a-mole for the targets it does not?

Oh, it definitely would be MUCH easier to add a REQUIRES line, however I'd have had to have thought about that, which I did not, so thank you for the wake up call. I'll update this in a few minutes.

Unfortunately, this is still not done after almost a day, leaving quite a number of buildbots broken. Please fix or revert.

[AlexVlx]

In D155775#4652851, @ro wrote:

In D155775#4652785, @AlexVlx wrote:

In D155775#4652780, @dyung wrote:

At this point, would it be easier to add a REQUIRES line for the target the test should support rather than just whack-a-mole for the targets it does not?

Oh, it definitely would be MUCH easier to add a REQUIRES line, however I'd have had to have thought about that, which I did not, so thank you for the wake up call. I'll update this in a few minutes.

Unfortunately, this is still not done after almost a day, leaving quite a number of buildbots broken. Please fix or revert.

Apologies, do you have an indication of which buildbots are still broken due to this change, after the most recent commit? The ones I was initially aware of, as well as those brought up here appear to pass at the moment, and glancing through the currently failing builds didn’t point to this as being the culprit (I could’ve simply missed it). Thank you!

[ro]

In D155775#4652872, @AlexVlx wrote:

In D155775#4652851, @ro wrote:

In D155775#4652785, @AlexVlx wrote:

In D155775#4652780, @dyung wrote:

At this point, would it be easier to add a REQUIRES line for the target the test should support rather than just whack-a-mole for the targets it does not?

Oh, it definitely would be MUCH easier to add a REQUIRES line, however I'd have had to have thought about that, which I did not, so thank you for the wake up call. I'll update this in a few minutes.

Unfortunately, this is still not done after almost a day, leaving quite a number of buildbots broken. Please fix or revert.

Apologies, do you have an indication of which buildbots are still broken due to this change, after the most recent commit? The ones I was initially aware of, as well as those brought up here appear to pass at the moment, and glancing through the currently failing builds didn’t point to this as being the culprit (I could’ve simply missed it). Thank you!

At least the Solaris/sparcv9 and Solaris/amd64 buildbots are still affected. However, XFAILing a long list of targets when it's known that particular targets/target properties are required for the test to PASS is fundamentally wrong!

clang/include/clang/Basic/DiagnosticDriverKinds.td

 
 def err_drv_no_rocm_device_lib : Error<
   "cannot find ROCm device library%select{| for %1|for ABI version %1}0; provide its path via "
   "'--rocm-path' or '--rocm-device-lib-path', or pass '-nogpulib' to build "
   "without ROCm device library">;
 def err_drv_no_hip_runtime : Error<
   "cannot find HIP runtime; provide its path via '--rocm-path', or pass "
   "'-nogpuinc' to build without HIP runtime">;
+def err_drv_no_hip_stdpar_lib : Error<
+  "cannot find HIP Standard Parallelism Acceleration library; provide it via "
+  "'--stdpar-path'">;
+def err_drv_no_hip_stdpar_thrust_lib : Error<
+  "cannot find rocThrust, which is required by the HIP Standard Parallelism "
+  "Acceleration library; provide it via "
+  "'--stdpar-thrust-path'">;
+def err_drv_no_hip_stdpar_prim_lib : Error<
+  "cannot find rocPrim, which is required by the HIP Standard Parallelism "
+  "Acceleration library; provide it via '--stdpar-prim-path'">;
 
 def err_drv_no_hipspv_device_lib : Error<
   "cannot find HIP device library%select{| for %1}0; provide its path via "
   "'--hip-path' or '--hip-device-lib-path', or pass '-nogpulib' to build "
   "without HIP device library">;
 def err_drv_hipspv_no_hip_path : Error<
   "'--hip-path' must be specified when offloading to "
   "SPIR-V%select{| unless %1 is given}0.">;

clang/include/clang/Basic/LangOptions.def

 LANGOPT(OffloadingNewDriver, 1, 0, "use the new driver for generating offloading code.")
 
 LANGOPT(SYCLIsDevice      , 1, 0, "Generate code for SYCL device")
 LANGOPT(SYCLIsHost        , 1, 0, "SYCL host compilation")
 ENUM_LANGOPT(SYCLVersion  , SYCLMajorVersion, 2, SYCL_None, "Version of the SYCL standard used")
 
 LANGOPT(HIPUseNewLaunchAPI, 1, 0, "Use new kernel launching API for HIP")
 LANGOPT(OffloadUniformBlock, 1, 0, "Assume that kernels are launched with uniform block sizes (default true for CUDA/HIP and false otherwise)")
+LANGOPT(HIPStdPar, 1, 0, "Enable Standard Parallel Algorithm Acceleration for HIP (experimental)")
+LANGOPT(HIPStdParInterposeAlloc, 1, 0, "Replace allocations / deallocations with HIP RT calls when Standard Parallel Algorithm Acceleration for HIP is enabled (Experimental)")
 
 LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
 LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
 LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
 LANGOPT(NewAlignOverride  , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")
 BENIGN_LANGOPT(ModulesCodegen , 1, 0, "Modules code generation")
 BENIGN_LANGOPT(ModulesDebugInfo , 1, 0, "Modules debug info")
 BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision")

clang/include/clang/Driver/Options.td

 def hip_link : Flag<["--"], "hip-link">, Group<opencl_Group>,
   HelpText<"Link clang-offload-bundler bundles for HIP">;
 def no_hip_rt: Flag<["-"], "no-hip-rt">, Group<hip_Group>,
   HelpText<"Do not link against HIP runtime libraries">;
 def rocm_path_EQ : Joined<["--"], "rocm-path=">, Group<hip_Group>,
   HelpText<"ROCm installation path, used for finding and automatically linking required bitcode libraries.">;
 def hip_path_EQ : Joined<["--"], "hip-path=">, Group<hip_Group>,
   HelpText<"HIP runtime installation path, used for finding HIP version and adding HIP include path.">;
 def rocm_device_lib_path_EQ : Joined<["--"], "rocm-device-lib-path=">, Group<hip_Group>,
+// TODO: use MarshallingInfo here
+def stdpar_path_EQ : Joined<["--"], "stdpar-path=">, Group<i_Group>,
+  HelpText<
+    "HIP Standard Parallel Algorithm Acceleration library path, used for "
+    "finding and implicitly including the library header.">;
+def stdpar_thrust_path_EQ : Joined<["--"], "stdpar-thrust-path=">,
+  Group<i_Group>,
+  HelpText<
+    "rocThrust path, required by the HIP Standard Parallel Algorithm "
+    "Acceleration library, used to implicitly include the rocThrust library.">;
+def stdpar_prim_path_EQ : Joined<["--"], "stdpar-prim-path=">,
+  Group<i_Group>,
+  HelpText<
+    "rocPrim path, required by the HIP Standard Parallel Algorithm "
+    "Acceleration library, used to implicitly include the rocPrim library.">;
+def amdgpu_arch_tool_EQ : Joined<["--"], "amdgpu-arch-tool=">, Group<i_Group>,
+  HelpText<"Tool used for detecting AMD GPU arch in the system.">;
+def nvptx_arch_tool_EQ : Joined<["--"], "nvptx-arch-tool=">, Group<i_Group>,
+  HelpText<"Tool used for detecting NVIDIA GPU arch in the system.">;
+def rocm_device_lib_path_EQ : Joined<["--"], "rocm-device-lib-path=">, Group<Link_Group>,
   HelpText<"ROCm device library path. Alternative to rocm-path.">;
 def : Joined<["--"], "hip-device-lib-path=">, Alias<rocm_device_lib_path_EQ>;
 def hip_device_lib_EQ : Joined<["--"], "hip-device-lib=">, Group<hip_Group>,
   HelpText<"HIP device library">;
 def hip_version_EQ : Joined<["--"], "hip-version=">, Group<hip_Group>,
   HelpText<"HIP version in the format of major.minor.patch">;
 def fhip_dump_offload_linker_script : Flag<["-"], "fhip-dump-offload-linker-script">,
   Group<hip_Group>, Flags<[NoArgumentUnused, HelpHidden]>;

 def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>,
   MarshallingInfoFlag<DiagnosticOpts<"IgnoreWarnings">>;
 def x : JoinedOrSeparate<["-"], "x">,
 Flags<[NoXarchOption,CC1Option,FlangOption,FC1Option]>,
   HelpText<"Treat subsequent input files as having type <language>">,
   MetaVarName<"<language>">;
 def y : Joined<["-"], "y">;
 
+// TODO: we may want to alias this to -x hip
+def stdpar : Flag<["-", "--"], "stdpar">, Flags<[CoreOption, CC1Option]>,
+  Group<CompileOnly_Group>,
+  HelpText<"Enable HIP acceleration for standard parallel algorithms">,
+  MarshallingInfoFlag<LangOpts<"HIPStdPar">>;
+def stdpar_interpose_alloc : Flag<["-", "--"], "stdpar-interpose-alloc">,
+  Flags<[CoreOption, CC1Option]>,
+  Group<CompileOnly_Group>,
+  HelpText<"Replace all memory allocation / deallocation calls with "
+           "hipManagedMalloc / hipFree equivalents.">,
+  MarshallingInfoFlag<LangOpts<"HIPStdParInterposeAlloc">>;
+
 defm integrated_as : BoolFOption<"integrated-as",
   CodeGenOpts<"DisableIntegratedAS">, DefaultFalse,
   NegFlag<SetTrue, [CC1Option, FlangOption], "Disable">, PosFlag<SetFalse, [], "Enable">,
   BothFlags<[], " the integrated assembler">>;
 
 def fintegrated_cc1 : Flag<["-"], "fintegrated-cc1">,
                       Flags<[CoreOption, NoXarchOption]>, Group<f_Group>,
                       HelpText<"Run cc1 in-process">;

clang/lib/Driver/Driver.cpp

bool IsCuda =
       llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
         return types::isCuda(I.first);
       });
   bool IsHIP =
       llvm::any_of(Inputs,
                    [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
                      return types::isHIP(I.first);
                    }) ||
-      C.getInputArgs().hasArg(options::OPT_hip_link);
+      C.getInputArgs().hasArg(options::OPT_hip_link) ||
+      C.getInputArgs().hasArg(options::OPT_stdpar);
   if (IsCuda && IsHIP) {
     Diag(clang::diag::err_drv_mix_cuda_hip);
     return;
   }
   if (IsCuda) {
     const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
     const llvm::Triple &HostTriple = HostTC->getTriple();
     auto OFK = Action::OFK_Cuda;
if (A->getOption().getKind() == Option::InputClass) {
             Ty = types::TY_Object;
         }
         if (Ty == types::TY_INVALID) {
           Ty = InputType;
           InputTypeArg->claim();
         }
       }
 
+      if ((Ty == types::TY_C || Ty == types::TY_CXX) &&
+          Args.hasArgNoClaim(options::OPT_stdpar))
+        Ty = types::TY_HIP;
+
       if (DiagnoseInputExistence(Args, Value, Ty, /*TypoCorrect=*/true))
         Inputs.push_back(std::make_pair(Ty, A));
 
     } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
       StringRef Value = A->getValue();
       if (DiagnoseInputExistence(Args, Value, types::TY_C,
                                  /*TypoCorrect=*/false)) {
         Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
if (YcArg && Inputs.size() > 1) {
     Args.eraseArg(options::OPT__SLASH_Yc);
     YcArg = nullptr;
   }
 
   Arg *FinalPhaseArg;
   phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
 
   if (FinalPhase == phases::Link) {
+    if (Args.hasArgNoClaim(options::OPT_stdpar)) {
+      Args.AddFlagArg(nullptr, getOpts().getOption(options::OPT_hip_link));
+      Args.AddFlagArg(nullptr,
+                      getOpts().getOption(options::OPT_frtlib_add_rpath));
+    }
     // Emitting LLVM while linking disabled except in HIPAMD Toolchain
     if (Args.hasArg(options::OPT_emit_llvm) && !Args.hasArg(options::OPT_hip_link))
       Diag(clang::diag::err_drv_emit_llvm_link);
     if (IsCLMode() && LTOMode != LTOK_None &&
         !Args.getLastArgValue(options::OPT_fuse_ld_EQ)
              .equals_insensitive("lld"))
       Diag(clang::diag::err_drv_lto_without_lld);
 

clang/lib/Driver/ToolChains/AMDGPU.cpp

RocmInstallationDetector::RocmInstallationDetector(
     : D(D) {
   Verbose = Args.hasArg(options::OPT_v);
   RocmPathArg = Args.getLastArgValue(clang::driver::options::OPT_rocm_path_EQ);
   PrintROCmSearchDirs =
       Args.hasArg(clang::driver::options::OPT_print_rocm_search_dirs);
   RocmDeviceLibPathArg =
       Args.getAllArgValues(clang::driver::options::OPT_rocm_device_lib_path_EQ);
   HIPPathArg = Args.getLastArgValue(clang::driver::options::OPT_hip_path_EQ);
+  HIPStdParPathArg =
+    Args.getLastArgValue(clang::driver::options::OPT_stdpar_path_EQ);
+  HasHIPStdParLibrary = !HIPStdParPathArg.empty() &&
+                        D.getVFS().exists(HIPStdParPathArg + "/stdpar_lib.hpp");
+  HIPRocThrustPathArg =
+    Args.getLastArgValue(clang::driver::options::OPT_stdpar_thrust_path_EQ);
+  HasRocThrustLibrary = !HIPRocThrustPathArg.empty() &&
+                        D.getVFS().exists(HIPRocThrustPathArg + "/thrust");
+  HIPRocPrimPathArg =
+    Args.getLastArgValue(clang::driver::options::OPT_stdpar_prim_path_EQ);
+  HasRocPrimLibrary = !HIPRocPrimPathArg.empty() &&
+                      D.getVFS().exists(HIPRocPrimPathArg + "/rocprim");
+
   if (auto *A = Args.getLastArg(clang::driver::options::OPT_hip_version_EQ)) {
     HIPVersionArg = A->getValue();
     unsigned Major = ~0U;
     unsigned Minor = ~0U;
     SmallVector<StringRef, 3> Parts;
     HIPVersionArg.split(Parts, '.');
     if (Parts.size())
       Parts[0].getAsInteger(0, Major);
if (hasHIPRuntime())
     OS << "Found HIP installation: " << InstallPath << ", version "
        << DetectedVersion << '\n';
 }
 
 void RocmInstallationDetector::AddHIPIncludeArgs(const ArgList &DriverArgs,
                                                  ArgStringList &CC1Args) const {
   bool UsesRuntimeWrapper = VersionMajorMinor > llvm::VersionTuple(3, 5) &&
                             !DriverArgs.hasArg(options::OPT_nohipwrapperinc);
+  bool HasStdPar = DriverArgs.hasArg(options::OPT_stdpar);
 
   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     // HIP header includes standard library wrapper headers under clang
     // cuda_wrappers directory. Since these wrapper headers include_next
     // standard C++ headers, whereas libc++ headers include_next other clang
     // headers. The include paths have to follow this order:
     // - wrapper include path
     // - standard C++ include path
     // - other clang include path
     // Since standard C++ and other clang include paths are added in other
     // places after this function, here we only need to make sure wrapper
     // include path is added.
     //
     // ROCm 3.5 does not fully support the wrapper headers. Therefore it needs
     // a workaround.
     SmallString<128> P(D.ResourceDir);
     if (UsesRuntimeWrapper)
       llvm::sys::path::append(P, "include", "cuda_wrappers");
     CC1Args.push_back("-internal-isystem");
     CC1Args.push_back(DriverArgs.MakeArgString(P));
   }
 
-  if (DriverArgs.hasArg(options::OPT_nogpuinc))
+  const auto HandleStdPar = [=, &DriverArgs, &CC1Args]() {
+    if (!hasHIPStdParLibrary()) {
+      D.Diag(diag::err_drv_no_hip_stdpar_lib);
+      return;
+    }
+    if (!HasRocThrustLibrary &&
+        !D.getVFS().exists(getIncludePath() + "/thrust")) {
+      D.Diag(diag::err_drv_no_hip_stdpar_thrust_lib);
+      return;
+    }
+    if (!HasRocPrimLibrary &&
+        !D.getVFS().exists(getIncludePath() + "/rocprim")) {
+      D.Diag(diag::err_drv_no_hip_stdpar_prim_lib);
+      return;
+    }
+
+    const char *ThrustPath;
+    if (HasRocThrustLibrary)
+      ThrustPath = DriverArgs.MakeArgString(HIPRocThrustPathArg);
+    else
+      ThrustPath = DriverArgs.MakeArgString(getIncludePath() + "/thrust");
+
+    const char *PrimPath;
+    if (HasRocPrimLibrary)
+      PrimPath = DriverArgs.MakeArgString(HIPRocPrimPathArg);
+    else
+      PrimPath = DriverArgs.MakeArgString(getIncludePath() + "/rocprim");
+
+    CC1Args.append({"-idirafter", ThrustPath, "-idirafter", PrimPath,
+                    "-idirafter", DriverArgs.MakeArgString(HIPStdParPathArg),
+                    "-include", "stdpar_lib.hpp"});
+  };
+
+  if (DriverArgs.hasArg(options::OPT_nogpuinc)) {
+    if (HasStdPar)
+      HandleStdPar();
+
     return;
+  }
 
   if (!hasHIPRuntime()) {
     D.Diag(diag::err_drv_no_hip_runtime);
     return;
   }
 
   CC1Args.push_back("-idirafter");
   CC1Args.push_back(DriverArgs.MakeArgString(getIncludePath()));
   if (UsesRuntimeWrapper)
     CC1Args.append({"-include", "__clang_hip_runtime_wrapper.h"});
+  if (HasStdPar)
+    HandleStdPar();
 }
 
 void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfo &Output,
                                   const InputInfoList &Inputs,
                                   const ArgList &Args,
                                   const char *LinkingOutput) const {
 

clang/lib/Driver/ToolChains/Clang.cpp

   // Forward hlsl options to -cc1
   RenderHLSLOptions(Args, CmdArgs, InputType);
 
   if (IsHIP) {
     if (Args.hasFlag(options::OPT_fhip_new_launch_api,
                      options::OPT_fno_hip_new_launch_api, true))
       CmdArgs.push_back("-fhip-new-launch-api");
     if (Args.hasFlag(options::OPT_fgpu_allow_device_init,
                      options::OPT_fno_gpu_allow_device_init, false))
       CmdArgs.push_back("-fgpu-allow-device-init");
+    if (Args.hasArg(options::OPT_stdpar)) {
+      CmdArgs.push_back("-stdpar");
+
+      if (Args.hasArg(options::OPT_stdpar_interpose_alloc))
+        CmdArgs.push_back("-stdpar-interpose-alloc");
+    }
     Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name,
                       options::OPT_fno_hip_kernel_arg_name);
   }
 
   if (IsCuda || IsHIP) {
     if (IsRDCMode)
       CmdArgs.push_back("-fgpu-rdc");
     if (Args.hasFlag(options::OPT_fgpu_defer_diag,

clang/lib/Driver/ToolChains/HIPAMD.cpp

void AMDGCN::Linker::constructLldCommand(Compilation &C, const JobAction &JA,
   // The output from ld.lld is an HSA code object file.
   ArgStringList LldArgs{"-flavor",
                         "gnu",
                         "-m",
                         "elf64_amdgpu",
                         "--no-undefined",
                         "-shared",
                         "-plugin-opt=-amdgpu-internalize-symbols"};
+  if (Args.hasArg(options::OPT_stdpar))
+    LldArgs.push_back("-plugin-opt=-amdgpu-enable-stdpar");
 
   auto &TC = getToolChain();
   auto &D = TC.getDriver();
   assert(!Inputs.empty() && "Must have at least one input.");
   bool IsThinLTO = D.getLTOMode(/*IsOffload=*/true) == LTOK_Thin;
   addLTOOptions(TC, Args, LldArgs, Output, Inputs[0], IsThinLTO);
 
   // Extract all the -m options
void HIPAMDToolChain::addClangTargetOptions(
   assert(DeviceOffloadingKind == Action::OFK_HIP &&
          "Only HIP offloading kinds are supported for GPUs.");
 
   CC1Args.push_back("-fcuda-is-device");
 
   if (!DriverArgs.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,
                           false))
     CC1Args.append({"-mllvm", "-amdgpu-internalize-symbols"});
+  if (DriverArgs.hasArgNoClaim(options::OPT_stdpar))
+    CC1Args.append({"-mllvm", "-amdgpu-enable-stdpar"});
 
   StringRef MaxThreadsPerBlock =
       DriverArgs.getLastArgValue(options::OPT_gpu_max_threads_per_block_EQ);
   if (!MaxThreadsPerBlock.empty()) {
     std::string ArgStr =
         (Twine("--gpu-max-threads-per-block=") + MaxThreadsPerBlock).str();
     CC1Args.push_back(DriverArgs.MakeArgStringRef(ArgStr));
   }

clang/lib/Driver/ToolChains/ROCm.h

Candidate(std::string Path, bool StrictChecking = false,
               StringRef SPACKReleaseStr = {})
         : Path(Path), StrictChecking(StrictChecking),
           SPACKReleaseStr(SPACKReleaseStr.str()) {}
   };
 
   const Driver &D;
   bool HasHIPRuntime = false;
   bool HasDeviceLibrary = false;
+  bool HasHIPStdParLibrary = false;
+  bool HasRocThrustLibrary = false;
+  bool HasRocPrimLibrary = false;
 
   // Default version if not detected or specified.
   const unsigned DefaultVersionMajor = 3;
   const unsigned DefaultVersionMinor = 5;
   const char *DefaultVersionPatch = "0";
 
   // The version string in Major.Minor.Patch format.
   std::string DetectedVersion;
   // Version containing major and minor.
   llvm::VersionTuple VersionMajorMinor;
   // Version containing patch.
   std::string VersionPatch;
 
   // ROCm path specified by --rocm-path.
   StringRef RocmPathArg;
   // ROCm device library paths specified by --rocm-device-lib-path.
   std::vector<std::string> RocmDeviceLibPathArg;
   // HIP runtime path specified by --hip-path.
   StringRef HIPPathArg;
+  // HIP Standard Parallel Algorithm acceleration library specified by
+  // --stdpar-path
+  StringRef HIPStdParPathArg;
+  // rocThrust algorithm library specified by --stdpar-thrust-path
+  StringRef HIPRocThrustPathArg;
+  // rocPrim algorithm library specified by --stdpar-prim-path
+  StringRef HIPRocPrimPathArg;
   // HIP version specified by --hip-version.
   StringRef HIPVersionArg;
   // Wheter -nogpulib is specified.
   bool NoBuiltinLibs = false;
 
   // Paths
   SmallString<0> InstallPath;
   SmallString<0> BinPath;
bool checkCommonBitcodeLibs(StringRef GPUArch, StringRef LibDeviceFile,
                               DeviceLibABIVersion ABIVer) const;
 
   /// Check whether we detected a valid HIP runtime.
   bool hasHIPRuntime() const { return HasHIPRuntime; }
 
   /// Check whether we detected a valid ROCm device library.
   bool hasDeviceLibrary() const { return HasDeviceLibrary; }
 
+  /// Check whether we detected a valid HIP STDPAR Acceleration library.
+  bool hasHIPStdParLibrary() const { return HasHIPStdParLibrary; }
+
   /// Print information about the detected ROCm installation.
   void print(raw_ostream &OS) const;
 
   /// Get the detected Rocm install's version.
   // RocmVersion version() const { return Version; }
 
   /// Get the detected Rocm installation path.
   StringRef getInstallPath() const { return InstallPath; }

clang/test/Driver/stdpar.c

+// RUN: %clang -### -stdpar --compile %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=STDPAR-MISSING-LIB %s
+// STDPAR-MISSING-LIB: error: cannot find HIP Standard Parallelism Acceleration library; provide it via '--stdpar-path'
+
+// RUN: %clang -### --stdpar --stdpar-path=%S/Inputs/stdpar \
+// RUN:   --stdpar-thrust-path=%S/Inputs/stdpar/thrust \
+// RUN:   --stdpar-prim-path=%S/Inputs/stdpar/prim --compile %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=STDPAR-COMPILE %s
+// STDPAR-COMPILE: "-x" "hip"
+// STDPAR-COMPILE: "-idirafter" "{{.*/thrust}}"
+// STDPAR-COMPILE: "-idirafter" "{{.*/prim}}"
+// STDPAR-COMPILE: "-idirafter" "{{.*/Inputs/stdpar}}"
+// STDPAR-COMPILE: "-include" "stdpar_lib.hpp"
+
+// RUN: touch %t.o
+// RUN: %clang -### -stdpar %t.o 2>&1 | FileCheck --check-prefix=STDPAR-LINK %s
+// STDPAR-LINK: "-rpath"
+// STDPAR-LINK: "-l{{.*hip.*}}"