| 1 |
//===--- HIPAMD.cpp - HIP Tool and ToolChain Implementations ----*- 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 "HIPAMD.h" |
| 10 |
#include "AMDGPU.h" |
| 11 |
#include "CommonArgs.h" |
| 12 |
#include "HIPUtility.h" |
| 13 |
#include "clang/Basic/Cuda.h" |
| 14 |
#include "clang/Basic/TargetID.h" |
| 15 |
#include "clang/Driver/Compilation.h" |
| 16 |
#include "clang/Driver/Driver.h" |
| 17 |
#include "clang/Driver/DriverDiagnostic.h" |
| 18 |
#include "clang/Driver/InputInfo.h" |
| 19 |
#include "clang/Driver/Options.h" |
| 20 |
#include "clang/Driver/SanitizerArgs.h" |
| 21 |
#include "llvm/Support/Alignment.h" |
| 22 |
#include "llvm/Support/FileSystem.h" |
| 23 |
#include "llvm/Support/Path.h" |
| 24 |
#include "llvm/Support/TargetParser.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 |
#if defined(_WIN32) || defined(_WIN64) |
| 33 |
#define NULL_FILE "nul" |
| 34 |
#else |
| 35 |
#define NULL_FILE "/dev/null" |
| 36 |
#endif |
| 37 |
|
| 38 |
static bool shouldSkipSanitizeOption(const ToolChain &TC, |
| 39 |
const llvm::opt::ArgList &DriverArgs, |
| 40 |
StringRef TargetID, |
| 41 |
const llvm::opt::Arg *A) { |
| 42 |
// For actions without targetID, do nothing. |
| 43 |
if (TargetID.empty()) |
| 44 |
return false; |
| 45 |
Option O = A->getOption(); |
| 46 |
if (!O.matches(options::OPT_fsanitize_EQ)) |
| 47 |
return false; |
| 48 |
|
| 49 |
if (!DriverArgs.hasFlag(options::OPT_fgpu_sanitize, |
| 50 |
options::OPT_fno_gpu_sanitize, true)) |
| 51 |
return true; |
| 52 |
|
| 53 |
auto &Diags = TC.getDriver().getDiags(); |
| 54 |
|
| 55 |
// For simplicity, we only allow -fsanitize=address |
| 56 |
SanitizerMask K = parseSanitizerValue(A->getValue(), /*AllowGroups=*/false); |
| 57 |
if (K != SanitizerKind::Address) |
| 58 |
return true; |
| 59 |
|
| 60 |
llvm::StringMap<bool> FeatureMap; |
| 61 |
auto OptionalGpuArch = parseTargetID(TC.getTriple(), TargetID, &FeatureMap); |
| 62 |
|
| 63 |
assert(OptionalGpuArch && "Invalid Target ID"); |
| 64 |
(void)OptionalGpuArch; |
| 65 |
auto Loc = FeatureMap.find("xnack"); |
| 66 |
if (Loc == FeatureMap.end() || !Loc->second) { |
| 67 |
Diags.Report( |
| 68 |
clang::diag::warn_drv_unsupported_option_for_offload_arch_req_feature) |
| 69 |
<< A->getAsString(DriverArgs) << TargetID << "xnack+"; |
| 70 |
return true; |
| 71 |
} |
| 72 |
return false; |
| 73 |
} |
| 74 |
|
| 75 |
void AMDGCN::Linker::constructLlvmLinkCommand(Compilation &C, |
| 76 |
const JobAction &JA, |
| 77 |
const InputInfoList &Inputs, |
| 78 |
const InputInfo &Output, |
| 79 |
const llvm::opt::ArgList &Args) const { |
| 80 |
// Construct llvm-link command. |
| 81 |
// The output from llvm-link is a bitcode file. |
| 82 |
ArgStringList LlvmLinkArgs; |
| 83 |
|
| 84 |
assert(!Inputs.empty() && "Must have at least one input."); |
| 85 |
|
| 86 |
LlvmLinkArgs.append({"-o", Output.getFilename()}); |
| 87 |
for (auto Input : Inputs) |
| 88 |
LlvmLinkArgs.push_back(Input.getFilename()); |
| 89 |
|
| 90 |
// Look for archive of bundled bitcode in arguments, and add temporary files |
| 91 |
// for the extracted archive of bitcode to inputs. |
| 92 |
auto TargetID = Args.getLastArgValue(options::OPT_mcpu_EQ); |
| 93 |
AddStaticDeviceLibsLinking(C, *this, JA, Inputs, Args, LlvmLinkArgs, "amdgcn", |
| 94 |
TargetID, |
| 95 |
/*IsBitCodeSDL=*/true, |
| 96 |
/*PostClangLink=*/false); |
| 97 |
|
| 98 |
const char *LlvmLink = |
| 99 |
Args.MakeArgString(getToolChain().GetProgramPath("llvm-link")); |
| 100 |
C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(), |
| 101 |
LlvmLink, LlvmLinkArgs, Inputs, |
| 102 |
Output)); |
| 103 |
} |
| 104 |
|
| 105 |
void AMDGCN::Linker::constructLldCommand(Compilation &C, const JobAction &JA, |
| 106 |
const InputInfoList &Inputs, |
| 107 |
const InputInfo &Output, |
| 108 |
const llvm::opt::ArgList &Args) const { |
| 109 |
// Construct lld command. |
| 110 |
// The output from ld.lld is an HSA code object file. |
| 111 |
ArgStringList LldArgs{"-flavor", |
| 112 |
"gnu", |
| 113 |
"-m", |
| 114 |
"elf64_amdgpu", |
| 115 |
"--no-undefined", |
| 116 |
"-shared", |
| 117 |
"-plugin-opt=-amdgpu-internalize-symbols"}; |
| 118 |
|
| 119 |
auto &TC = getToolChain(); |
| 120 |
auto &D = TC.getDriver(); |
| 121 |
assert(!Inputs.empty() && "Must have at least one input."); |
| 122 |
bool IsThinLTO = D.getLTOMode(/*IsOffload=*/true) == LTOK_Thin; |
| 123 |
addLTOOptions(TC, Args, LldArgs, Output, Inputs[0], IsThinLTO); |
| 124 |
|
| 125 |
// Extract all the -m options |
| 126 |
std::vector<llvm::StringRef> Features; |
| 127 |
amdgpu::getAMDGPUTargetFeatures(D, TC.getTriple(), Args, Features); |
| 128 |
|
| 129 |
// Add features to mattr such as cumode |
| 130 |
std::string MAttrString = "-plugin-opt=-mattr="; |
| 131 |
for (auto OneFeature : unifyTargetFeatures(Features)) { |
| 132 |
MAttrString.append(Args.MakeArgString(OneFeature)); |
| 133 |
if (OneFeature != Features.back()) |
| 134 |
MAttrString.append(","); |
| 135 |
} |
| 136 |
if (!Features.empty()) |
| 137 |
LldArgs.push_back(Args.MakeArgString(MAttrString)); |
| 138 |
|
| 139 |
// ToDo: Remove this option after AMDGPU backend supports ISA-level linking. |
| 140 |
// Since AMDGPU backend currently does not support ISA-level linking, all |
| 141 |
// called functions need to be imported. |
| 142 |
if (IsThinLTO) |
| 143 |
LldArgs.push_back(Args.MakeArgString("-plugin-opt=-force-import-all")); |
| 144 |
|
| 145 |
for (const Arg *A : Args.filtered(options::OPT_mllvm)) { |
| 146 |
LldArgs.push_back( |
| 147 |
Args.MakeArgString(Twine("-plugin-opt=") + A->getValue(0))); |
| 148 |
} |
| 149 |
|
| 150 |
if (C.getDriver().isSaveTempsEnabled()) |
| 151 |
LldArgs.push_back("-save-temps"); |
| 152 |
|
| 153 |
addLinkerCompressDebugSectionsOption(TC, Args, LldArgs); |
| 154 |
|
| 155 |
for (auto *Arg : Args.filtered(options::OPT_Xoffload_linker)) |
| 156 |
LldArgs.push_back(Arg->getValue(1)); |
| 157 |
|
| 158 |
LldArgs.append({"-o", Output.getFilename()}); |
| 159 |
for (auto Input : Inputs) |
| 160 |
LldArgs.push_back(Input.getFilename()); |
| 161 |
|
| 162 |
// Look for archive of bundled bitcode in arguments, and add temporary files |
| 163 |
// for the extracted archive of bitcode to inputs. |
| 164 |
auto TargetID = Args.getLastArgValue(options::OPT_mcpu_EQ); |
| 165 |
AddStaticDeviceLibsLinking(C, *this, JA, Inputs, Args, LldArgs, "amdgcn", |
| 166 |
TargetID, |
| 167 |
/*IsBitCodeSDL=*/true, |
| 168 |
/*PostClangLink=*/false); |
| 169 |
|
| 170 |
const char *Lld = Args.MakeArgString(getToolChain().GetProgramPath("lld")); |
| 171 |
C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(), |
| 172 |
Lld, LldArgs, Inputs, Output)); |
| 173 |
} |
| 174 |
|
| 175 |
// For amdgcn the inputs of the linker job are device bitcode and output is |
| 176 |
// either an object file or bitcode (-emit-llvm). It calls llvm-link, opt, |
| 177 |
// llc, then lld steps. |
| 178 |
void AMDGCN::Linker::ConstructJob(Compilation &C, const JobAction &JA, |
| 179 |
const InputInfo &Output, |
| 180 |
const InputInfoList &Inputs, |
| 181 |
const ArgList &Args, |
| 182 |
const char *LinkingOutput) const { |
| 183 |
if (Inputs.size() > 0 && |
| 184 |
Inputs[0].getType() == types::TY_Image && |
| 185 |
JA.getType() == types::TY_Object) |
| 186 |
return HIP::constructGenerateObjFileFromHIPFatBinary(C, Output, Inputs, |
| 187 |
Args, JA, *this); |
| 188 |
|
| 189 |
if (JA.getType() == types::TY_HIP_FATBIN) |
| 190 |
return HIP::constructHIPFatbinCommand(C, JA, Output.getFilename(), Inputs, |
| 191 |
Args, *this); |
| 192 |
|
| 193 |
if (JA.getType() == types::TY_LLVM_BC) |
| 194 |
return constructLlvmLinkCommand(C, JA, Inputs, Output, Args); |
| 195 |
|
| 196 |
return constructLldCommand(C, JA, Inputs, Output, Args); |
| 197 |
} |
| 198 |
|
| 199 |
HIPAMDToolChain::HIPAMDToolChain(const Driver &D, const llvm::Triple &Triple, |
| 200 |
const ToolChain &HostTC, const ArgList &Args) |
| 201 |
: ROCMToolChain(D, Triple, Args), HostTC(HostTC) { |
| 202 |
// Lookup binaries into the driver directory, this is used to |
| 203 |
// discover the clang-offload-bundler executable. |
| 204 |
getProgramPaths().push_back(getDriver().Dir); |
| 205 |
|
| 206 |
// Diagnose unsupported sanitizer options only once. |
| 207 |
if (!Args.hasFlag(options::OPT_fgpu_sanitize, options::OPT_fno_gpu_sanitize, |
| 208 |
true)) |
| 209 |
return; |
| 210 |
for (auto *A : Args.filtered(options::OPT_fsanitize_EQ)) { |
| 211 |
SanitizerMask K = parseSanitizerValue(A->getValue(), /*AllowGroups=*/false); |
| 212 |
if (K != SanitizerKind::Address) |
| 213 |
D.getDiags().Report(clang::diag::warn_drv_unsupported_option_for_target) |
| 214 |
<< A->getAsString(Args) << getTriple().str(); |
| 215 |
} |
| 216 |
} |
| 217 |
|
| 218 |
void HIPAMDToolChain::addClangTargetOptions( |
| 219 |
const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, |
| 220 |
Action::OffloadKind DeviceOffloadingKind) const { |
| 221 |
HostTC.addClangTargetOptions(DriverArgs, CC1Args, DeviceOffloadingKind); |
| 222 |
|
| 223 |
assert(DeviceOffloadingKind == Action::OFK_HIP && |
| 224 |
"Only HIP offloading kinds are supported for GPUs."); |
| 225 |
|
| 226 |
CC1Args.push_back("-fcuda-is-device"); |
| 227 |
|
| 228 |
if (DriverArgs.hasFlag(options::OPT_fcuda_approx_transcendentals, |
| 229 |
options::OPT_fno_cuda_approx_transcendentals, false)) |
| 230 |
CC1Args.push_back("-fcuda-approx-transcendentals"); |
| 231 |
|
| 232 |
if (!DriverArgs.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc, |
| 233 |
false)) |
| 234 |
CC1Args.append({"-mllvm", "-amdgpu-internalize-symbols"}); |
| 235 |
|
| 236 |
StringRef MaxThreadsPerBlock = |
| 237 |
DriverArgs.getLastArgValue(options::OPT_gpu_max_threads_per_block_EQ); |
| 238 |
if (!MaxThreadsPerBlock.empty()) { |
| 239 |
std::string ArgStr = |
| 240 |
(Twine("--gpu-max-threads-per-block=") + MaxThreadsPerBlock).str(); |
| 241 |
CC1Args.push_back(DriverArgs.MakeArgStringRef(ArgStr)); |
| 242 |
} |
| 243 |
|
| 244 |
CC1Args.push_back("-fcuda-allow-variadic-functions"); |
| 245 |
|
| 246 |
// Default to "hidden" visibility, as object level linking will not be |
| 247 |
// supported for the foreseeable future. |
| 248 |
if (!DriverArgs.hasArg(options::OPT_fvisibility_EQ, |
| 249 |
options::OPT_fvisibility_ms_compat)) { |
| 250 |
CC1Args.append({"-fvisibility=hidden"}); |
| 251 |
CC1Args.push_back("-fapply-global-visibility-to-externs"); |
| 252 |
} |
| 253 |
|
| 254 |
for (auto BCFile : getDeviceLibs(DriverArgs)) { |
| 255 |
CC1Args.push_back(BCFile.ShouldInternalize ? "-mlink-builtin-bitcode" |
| 256 |
: "-mlink-bitcode-file"); |
| 257 |
CC1Args.push_back(DriverArgs.MakeArgString(BCFile.Path)); |
| 258 |
} |
| 259 |
} |
| 260 |
|
| 261 |
llvm::opt::DerivedArgList * |
| 262 |
HIPAMDToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args, |
| 263 |
StringRef BoundArch, |
| 264 |
Action::OffloadKind DeviceOffloadKind) const { |
| 265 |
DerivedArgList *DAL = |
| 266 |
HostTC.TranslateArgs(Args, BoundArch, DeviceOffloadKind); |
| 267 |
if (!DAL) |
| 268 |
DAL = new DerivedArgList(Args.getBaseArgs()); |
| 269 |
|
| 270 |
const OptTable &Opts = getDriver().getOpts(); |
| 271 |
|
| 272 |
for (Arg *A : Args) { |
| 273 |
if (!shouldSkipArgument(A) && |
| 274 |
!shouldSkipSanitizeOption(*this, Args, BoundArch, A)) |
| 275 |
DAL->append(A); |
| 276 |
} |
| 277 |
|
| 278 |
if (!BoundArch.empty()) { |
| 279 |
DAL->eraseArg(options::OPT_mcpu_EQ); |
| 280 |
DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mcpu_EQ), BoundArch); |
| 281 |
checkTargetID(*DAL); |
| 282 |
} |
| 283 |
|
| 284 |
return DAL; |
| 285 |
} |
| 286 |
|
| 287 |
Tool *HIPAMDToolChain::buildLinker() const { |
| 288 |
assert(getTriple().getArch() == llvm::Triple::amdgcn); |
| 289 |
return new tools::AMDGCN::Linker(*this); |
| 290 |
} |
| 291 |
|
| 292 |
void HIPAMDToolChain::addClangWarningOptions(ArgStringList &CC1Args) const { |
| 293 |
HostTC.addClangWarningOptions(CC1Args); |
| 294 |
} |
| 295 |
|
| 296 |
ToolChain::CXXStdlibType |
| 297 |
HIPAMDToolChain::GetCXXStdlibType(const ArgList &Args) const { |
| 298 |
return HostTC.GetCXXStdlibType(Args); |
| 299 |
} |
| 300 |
|
| 301 |
void HIPAMDToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, |
| 302 |
ArgStringList &CC1Args) const { |
| 303 |
HostTC.AddClangSystemIncludeArgs(DriverArgs, CC1Args); |
| 304 |
} |
| 305 |
|
| 306 |
void HIPAMDToolChain::AddClangCXXStdlibIncludeArgs( |
| 307 |
const ArgList &Args, ArgStringList &CC1Args) const { |
| 308 |
HostTC.AddClangCXXStdlibIncludeArgs(Args, CC1Args); |
| 309 |
} |
| 310 |
|
| 311 |
void HIPAMDToolChain::AddIAMCUIncludeArgs(const ArgList &Args, |
| 312 |
ArgStringList &CC1Args) const { |
| 313 |
HostTC.AddIAMCUIncludeArgs(Args, CC1Args); |
| 314 |
} |
| 315 |
|
| 316 |
void HIPAMDToolChain::AddHIPIncludeArgs(const ArgList &DriverArgs, |
| 317 |
ArgStringList &CC1Args) const { |
| 318 |
RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args); |
| 319 |
} |
| 320 |
|
| 321 |
SanitizerMask HIPAMDToolChain::getSupportedSanitizers() const { |
| 322 |
// The HIPAMDToolChain only supports sanitizers in the sense that it allows |
| 323 |
// sanitizer arguments on the command line if they are supported by the host |
| 324 |
// toolchain. The HIPAMDToolChain will actually ignore any command line |
| 325 |
// arguments for any of these "supported" sanitizers. That means that no |
| 326 |
// sanitization of device code is actually supported at this time. |
| 327 |
// |
| 328 |
// This behavior is necessary because the host and device toolchains |
| 329 |
// invocations often share the command line, so the device toolchain must |
| 330 |
// tolerate flags meant only for the host toolchain. |
| 331 |
return HostTC.getSupportedSanitizers(); |
| 332 |
} |
| 333 |
|
| 334 |
VersionTuple HIPAMDToolChain::computeMSVCVersion(const Driver *D, |
| 335 |
const ArgList &Args) const { |
| 336 |
return HostTC.computeMSVCVersion(D, Args); |
| 337 |
} |
| 338 |
|
| 339 |
llvm::SmallVector<ToolChain::BitCodeLibraryInfo, 12> |
| 340 |
HIPAMDToolChain::getDeviceLibs(const llvm::opt::ArgList &DriverArgs) const { |
| 341 |
llvm::SmallVector<BitCodeLibraryInfo, 12> BCLibs; |
| 342 |
if (DriverArgs.hasArg(options::OPT_nogpulib)) |
| 343 |
return {}; |
| 344 |
ArgStringList LibraryPaths; |
| 345 |
|
| 346 |
// Find in --hip-device-lib-path and HIP_LIBRARY_PATH. |
| 347 |
for (StringRef Path : RocmInstallation.getRocmDeviceLibPathArg()) |
| 348 |
LibraryPaths.push_back(DriverArgs.MakeArgString(Path)); |
| 349 |
|
| 350 |
addDirectoryList(DriverArgs, LibraryPaths, "", "HIP_DEVICE_LIB_PATH"); |
| 351 |
|
| 352 |
// Maintain compatability with --hip-device-lib. |
| 353 |
auto BCLibArgs = DriverArgs.getAllArgValues(options::OPT_hip_device_lib_EQ); |
| 354 |
if (!BCLibArgs.empty()) { |
| 355 |
llvm::for_each(BCLibArgs, [&](StringRef BCName) { |
| 356 |
StringRef FullName; |
| 357 |
for (StringRef LibraryPath : LibraryPaths) { |
| 358 |
SmallString<128> Path(LibraryPath); |
| 359 |
llvm::sys::path::append(Path, BCName); |
| 360 |
FullName = Path; |
| 361 |
if (llvm::sys::fs::exists(FullName)) { |
| 362 |
BCLibs.push_back(FullName); |
| 363 |
return; |
| 364 |
} |
| 365 |
} |
| 366 |
getDriver().Diag(diag::err_drv_no_such_file) << BCName; |
| 367 |
}); |
| 368 |
} else { |
| 369 |
if (!RocmInstallation.hasDeviceLibrary()) { |
| 370 |
getDriver().Diag(diag::err_drv_no_rocm_device_lib) << 0; |
| 371 |
return {}; |
| 372 |
} |
| 373 |
StringRef GpuArch = getGPUArch(DriverArgs); |
| 374 |
assert(!GpuArch.empty() && "Must have an explicit GPU arch."); |
| 375 |
|
| 376 |
// If --hip-device-lib is not set, add the default bitcode libraries. |
| 377 |
if (DriverArgs.hasFlag(options::OPT_fgpu_sanitize, |
| 378 |
options::OPT_fno_gpu_sanitize, true) && |
| 379 |
getSanitizerArgs(DriverArgs).needsAsanRt()) { |
| 380 |
auto AsanRTL = RocmInstallation.getAsanRTLPath(); |
| 381 |
if (AsanRTL.empty()) { |
| 382 |
unsigned DiagID = getDriver().getDiags().getCustomDiagID( |
| 383 |
DiagnosticsEngine::Error, |
| 384 |
"AMDGPU address sanitizer runtime library (asanrtl) is not found. " |
| 385 |
"Please install ROCm device library which supports address " |
| 386 |
"sanitizer"); |
| 387 |
getDriver().Diag(DiagID); |
| 388 |
return {}; |
| 389 |
} else |
| 390 |
BCLibs.emplace_back(AsanRTL, /*ShouldInternalize=*/false); |
| 391 |
} |
| 392 |
|
| 393 |
// Add the HIP specific bitcode library. |
| 394 |
BCLibs.push_back(RocmInstallation.getHIPPath()); |
| 395 |
|
| 396 |
// Add common device libraries like ocml etc. |
| 397 |
for (StringRef N : getCommonDeviceLibNames(DriverArgs, GpuArch.str())) |
| 398 |
BCLibs.emplace_back(N); |
| 399 |
|
| 400 |
// Add instrument lib. |
| 401 |
auto InstLib = |
| 402 |
DriverArgs.getLastArgValue(options::OPT_gpu_instrument_lib_EQ); |
| 403 |
if (InstLib.empty()) |
| 404 |
return BCLibs; |
| 405 |
if (llvm::sys::fs::exists(InstLib)) |
| 406 |
BCLibs.push_back(InstLib); |
| 407 |
else |
| 408 |
getDriver().Diag(diag::err_drv_no_such_file) << InstLib; |
| 409 |
} |
| 410 |
|
| 411 |
return BCLibs; |
| 412 |
} |
| 413 |
|
| 414 |
void HIPAMDToolChain::checkTargetID( |
| 415 |
const llvm::opt::ArgList &DriverArgs) const { |
| 416 |
auto PTID = getParsedTargetID(DriverArgs); |
| 417 |
if (PTID.OptionalTargetID && !PTID.OptionalGPUArch) { |
| 418 |
getDriver().Diag(clang::diag::err_drv_bad_target_id) |
| 419 |
<< *PTID.OptionalTargetID; |
| 420 |
} |
| 421 |
} |