xref: /llvm-project/clang/lib/Driver/ToolChains/AMDGPUOpenMP.cpp (revision 12e8e0b10c3f52098cc41322c12eb7f3bfd75b06)
1 //===- AMDGPUOpenMP.cpp - AMDGPUOpenMP ToolChain Implementation -*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "AMDGPUOpenMP.h"
10 #include "AMDGPU.h"
11 #include "CommonArgs.h"
12 #include "ToolChains/ROCm.h"
13 #include "clang/Basic/DiagnosticDriver.h"
14 #include "clang/Driver/Compilation.h"
15 #include "clang/Driver/Driver.h"
16 #include "clang/Driver/DriverDiagnostic.h"
17 #include "clang/Driver/InputInfo.h"
18 #include "clang/Driver/Options.h"
19 #include "clang/Driver/Tool.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/Support/FileSystem.h"
22 #include "llvm/Support/FormatAdapters.h"
23 #include "llvm/Support/FormatVariadic.h"
24 #include "llvm/Support/Path.h"
25 
26 using namespace clang::driver;
27 using namespace clang::driver::toolchains;
28 using namespace clang::driver::tools;
29 using namespace clang;
30 using namespace llvm::opt;
31 
32 AMDGPUOpenMPToolChain::AMDGPUOpenMPToolChain(const Driver &D,
33                                              const llvm::Triple &Triple,
34                                              const ToolChain &HostTC,
35                                              const ArgList &Args)
36     : ROCMToolChain(D, Triple, Args), HostTC(HostTC) {
37   // Lookup binaries into the driver directory, this is used to
38   // discover the 'amdgpu-arch' executable.
39   getProgramPaths().push_back(getDriver().Dir);
40 }
41 
42 void AMDGPUOpenMPToolChain::addClangTargetOptions(
43     const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
44     Action::OffloadKind DeviceOffloadingKind) const {
45   HostTC.addClangTargetOptions(DriverArgs, CC1Args, DeviceOffloadingKind);
46 
47   assert(DeviceOffloadingKind == Action::OFK_OpenMP &&
48          "Only OpenMP offloading kinds are supported.");
49 
50   if (DriverArgs.hasArg(options::OPT_nogpulib))
51     return;
52 
53   for (auto BCFile : getDeviceLibs(DriverArgs)) {
54     CC1Args.push_back(BCFile.ShouldInternalize ? "-mlink-builtin-bitcode"
55                                                : "-mlink-bitcode-file");
56     CC1Args.push_back(DriverArgs.MakeArgString(BCFile.Path));
57   }
58 
59   // Link the bitcode library late if we're using device LTO.
60   if (getDriver().isUsingOffloadLTO())
61     return;
62 }
63 
64 llvm::opt::DerivedArgList *AMDGPUOpenMPToolChain::TranslateArgs(
65     const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
66     Action::OffloadKind DeviceOffloadKind) const {
67   DerivedArgList *DAL =
68       HostTC.TranslateArgs(Args, BoundArch, DeviceOffloadKind);
69   if (!DAL)
70     DAL = new DerivedArgList(Args.getBaseArgs());
71 
72   const OptTable &Opts = getDriver().getOpts();
73 
74   if (DeviceOffloadKind == Action::OFK_OpenMP) {
75     for (Arg *A : Args)
76       if (!llvm::is_contained(*DAL, A))
77         DAL->append(A);
78 
79     if (!DAL->hasArg(options::OPT_march_EQ)) {
80       StringRef Arch = BoundArch;
81       if (Arch.empty()) {
82         auto ArchsOrErr = getSystemGPUArchs(Args);
83         if (!ArchsOrErr) {
84           std::string ErrMsg =
85               llvm::formatv("{0}", llvm::fmt_consume(ArchsOrErr.takeError()));
86           getDriver().Diag(diag::err_drv_undetermined_gpu_arch)
87               << llvm::Triple::getArchTypeName(getArch()) << ErrMsg << "-march";
88           Arch = OffloadArchToString(OffloadArch::HIPDefault);
89         } else {
90           Arch = Args.MakeArgString(ArchsOrErr->front());
91         }
92       }
93       DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), Arch);
94     }
95 
96     return DAL;
97   }
98 
99   for (Arg *A : Args) {
100     DAL->append(A);
101   }
102 
103   if (!BoundArch.empty()) {
104     DAL->eraseArg(options::OPT_march_EQ);
105     DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ),
106                       BoundArch);
107   }
108 
109   return DAL;
110 }
111 
112 void AMDGPUOpenMPToolChain::addClangWarningOptions(
113     ArgStringList &CC1Args) const {
114   AMDGPUToolChain::addClangWarningOptions(CC1Args);
115   HostTC.addClangWarningOptions(CC1Args);
116 }
117 
118 ToolChain::CXXStdlibType
119 AMDGPUOpenMPToolChain::GetCXXStdlibType(const ArgList &Args) const {
120   return HostTC.GetCXXStdlibType(Args);
121 }
122 
123 void AMDGPUOpenMPToolChain::AddClangCXXStdlibIncludeArgs(
124     const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1Args) const {
125   HostTC.AddClangCXXStdlibIncludeArgs(Args, CC1Args);
126 }
127 
128 void AMDGPUOpenMPToolChain::AddClangSystemIncludeArgs(
129     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
130   HostTC.AddClangSystemIncludeArgs(DriverArgs, CC1Args);
131 }
132 
133 void AMDGPUOpenMPToolChain::AddIAMCUIncludeArgs(const ArgList &Args,
134                                                 ArgStringList &CC1Args) const {
135   HostTC.AddIAMCUIncludeArgs(Args, CC1Args);
136 }
137 
138 SanitizerMask AMDGPUOpenMPToolChain::getSupportedSanitizers() const {
139   // The AMDGPUOpenMPToolChain only supports sanitizers in the sense that it
140   // allows sanitizer arguments on the command line if they are supported by the
141   // host toolchain. The AMDGPUOpenMPToolChain will actually ignore any command
142   // line arguments for any of these "supported" sanitizers. That means that no
143   // sanitization of device code is actually supported at this time.
144   //
145   // This behavior is necessary because the host and device toolchains
146   // invocations often share the command line, so the device toolchain must
147   // tolerate flags meant only for the host toolchain.
148   return HostTC.getSupportedSanitizers();
149 }
150 
151 VersionTuple
152 AMDGPUOpenMPToolChain::computeMSVCVersion(const Driver *D,
153                                           const ArgList &Args) const {
154   return HostTC.computeMSVCVersion(D, Args);
155 }
156 
157 llvm::SmallVector<ToolChain::BitCodeLibraryInfo, 12>
158 AMDGPUOpenMPToolChain::getDeviceLibs(const llvm::opt::ArgList &Args) const {
159   if (Args.hasArg(options::OPT_nogpulib))
160     return {};
161 
162   if (!RocmInstallation->hasDeviceLibrary()) {
163     getDriver().Diag(diag::err_drv_no_rocm_device_lib) << 0;
164     return {};
165   }
166 
167   StringRef GpuArch = getProcessorFromTargetID(
168       getTriple(), Args.getLastArgValue(options::OPT_march_EQ));
169 
170   SmallVector<BitCodeLibraryInfo, 12> BCLibs;
171   for (auto BCLib : getCommonDeviceLibNames(Args, GpuArch.str(),
172                                             /*IsOpenMP=*/true))
173     BCLibs.emplace_back(BCLib);
174 
175   return BCLibs;
176 }
177