Skip to content

Commit 9f5a223

Browse files
cperkinsintelcperkinsintel
committed
resolve merge conflict
2 parents ef344c2 + 57aabe7 commit 9f5a223

File tree

82 files changed

+763
-1559
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

82 files changed

+763
-1559
lines changed

‎clang/include/clang/Driver/Options.td

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -956,6 +956,12 @@ def cuda_include_ptx_EQ : Joined<["--"], "cuda-include-ptx=">, Flags<[NoXarchOpt
956956
HelpText<"Include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.">;
957957
def no_cuda_include_ptx_EQ : Joined<["--"], "no-cuda-include-ptx=">, Flags<[NoXarchOption]>,
958958
HelpText<"Do not include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.">;
959+
def fno_bundle_offload_arch : Flag<["-"], "fno-bundle-offload-arch">,
960+
HelpText<"Specify that the offload bundler should not identify a bundle with "
961+
"specific arch. For example, the bundle for `nvptx64-nvidia-cuda-sm_80` "
962+
"uses the bundle tag `nvptx64-nvidia-cuda` when used. "
963+
"This allows .o files to contain .bc bundles that are unspecific "
964+
"to a particular arch version.">;
959965
def offload_arch_EQ : Joined<["--"], "offload-arch=">, Flags<[NoXarchOption]>,
960966
HelpText<"CUDA offloading device architecture (e.g. sm_35), or HIP offloading target ID in the form of a "
961967
"device architecture followed by target ID features delimited by a colon. Each target ID feature "

‎clang/lib/Driver/Driver.cpp

Lines changed: 92 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -4680,6 +4680,9 @@ class OffloadingActionBuilder final {
46804680
/// List of static archives to extract FPGA dependency info from
46814681
ActionList FPGAArchiveInputs;
46824682

4683+
// SYCLInstallation is needed in order to link SYCLDeviceLibs
4684+
SYCLInstallationDetector SYCLInstallation;
4685+
46834686
/// List of GPU architectures to use in this compilation with NVPTX/AMDGCN
46844687
/// targets.
46854688
SmallVector<std::pair<llvm::Triple, const char *>, 8> GpuArchList;
@@ -4720,7 +4723,8 @@ class OffloadingActionBuilder final {
47204723
SYCLActionBuilder(Compilation &C, DerivedArgList &Args,
47214724
const Driver::InputList &Inputs,
47224725
OffloadingActionBuilder &OAB)
4723-
: DeviceActionBuilder(C, Args, Inputs, Action::OFK_SYCL, OAB) {}
4726+
: DeviceActionBuilder(C, Args, Inputs, Action::OFK_SYCL, OAB),
4727+
SYCLInstallation(C.getDriver()) {}
47244728

47254729
void withBoundArchForToolChain(const ToolChain *TC,
47264730
llvm::function_ref<void(const char *)> Op) {
@@ -5099,10 +5103,8 @@ class OffloadingActionBuilder final {
50995103
}
51005104
}
51015105

5102-
const toolchains::SYCLToolChain *SYCLTC =
5103-
static_cast<const toolchains::SYCLToolChain *>(TC);
51045106
SmallVector<SmallString<128>, 4> LibLocCandidates;
5105-
SYCLTC->SYCLInstallation.getSYCLDeviceLibPath(LibLocCandidates);
5107+
SYCLInstallation.getSYCLDeviceLibPath(LibLocCandidates);
51065108
StringRef LibSuffix = isMSVCEnv ? ".obj" : ".o";
51075109
using SYCLDeviceLibsList = SmallVector<DeviceLibOptInfo, 5>;
51085110

@@ -5155,20 +5157,100 @@ class OffloadingActionBuilder final {
51555157
auto *SYCLDeviceLibsUnbundleAction =
51565158
C.MakeAction<OffloadUnbundlingJobAction>(
51575159
SYCLDeviceLibsInputAction);
5158-
addDeviceDepences(SYCLDeviceLibsUnbundleAction);
5159-
DeviceLinkObjects.push_back(SYCLDeviceLibsUnbundleAction);
5160+
5161+
// We are using BoundArch="" here since the NVPTX bundles in
5162+
// the devicelib .o files do not contain any arch information
5163+
SYCLDeviceLibsUnbundleAction->registerDependentActionInfo(
5164+
TC, /*BoundArch=*/"", Action::OFK_SYCL);
5165+
OffloadAction::DeviceDependences Dep;
5166+
Dep.add(*SYCLDeviceLibsUnbundleAction, *TC, /*BoundArch=*/"",
5167+
Action::OFK_SYCL);
5168+
auto *SYCLDeviceLibsDependenciesAction =
5169+
C.MakeAction<OffloadAction>(
5170+
Dep, SYCLDeviceLibsUnbundleAction->getType());
5171+
5172+
DeviceLinkObjects.push_back(SYCLDeviceLibsDependenciesAction);
51605173
if (!LibLocSelected)
51615174
LibLocSelected = !LibLocSelected;
51625175
}
51635176
}
51645177
}
51655178
};
5179+
51665180
addInputs(sycl_device_wrapper_libs);
5167-
if (isSpirvAOT)
5181+
if (isSpirvAOT || TC->getTriple().isNVPTX())
51685182
addInputs(sycl_device_fallback_libs);
51695183
if (Args.hasFlag(options::OPT_fsycl_instrument_device_code,
51705184
options::OPT_fno_sycl_instrument_device_code, true))
51715185
addInputs(sycl_device_annotation_libs);
5186+
5187+
// For NVPTX backend we need to also link libclc and CUDA libdevice
5188+
// at the same stage that we link all of the unbundled SYCL libdevice
5189+
// objects together.
5190+
if (TC->getTriple().isNVPTX() && NumOfDeviceLibLinked) {
5191+
std::string LibSpirvFile;
5192+
if (Args.hasArg(options::OPT_fsycl_libspirv_path_EQ)) {
5193+
auto ProvidedPath =
5194+
Args.getLastArgValue(options::OPT_fsycl_libspirv_path_EQ).str();
5195+
if (llvm::sys::fs::exists(ProvidedPath))
5196+
LibSpirvFile = ProvidedPath;
5197+
} else {
5198+
SmallVector<StringRef, 8> LibraryPaths;
5199+
5200+
// Expected path w/out install.
5201+
SmallString<256> WithoutInstallPath(C.getDriver().ResourceDir);
5202+
llvm::sys::path::append(WithoutInstallPath, Twine("../../clc"));
5203+
LibraryPaths.emplace_back(WithoutInstallPath.c_str());
5204+
5205+
// Expected path w/ install.
5206+
SmallString<256> WithInstallPath(C.getDriver().ResourceDir);
5207+
llvm::sys::path::append(WithInstallPath, Twine("../../../share/clc"));
5208+
LibraryPaths.emplace_back(WithInstallPath.c_str());
5209+
5210+
// Select remangled libclc variant
5211+
std::string LibSpirvTargetName =
5212+
(TC->getAuxTriple()->isOSWindows())
5213+
? "remangled-l32-signed_char.libspirv-nvptx64--nvidiacl."
5214+
"bc"
5215+
: "remangled-l64-signed_char.libspirv-nvptx64--nvidiacl."
5216+
"bc";
5217+
5218+
for (StringRef LibraryPath : LibraryPaths) {
5219+
SmallString<128> LibSpirvTargetFile(LibraryPath);
5220+
llvm::sys::path::append(LibSpirvTargetFile, LibSpirvTargetName);
5221+
if (llvm::sys::fs::exists(LibSpirvTargetFile) ||
5222+
Args.hasArg(options::OPT__HASH_HASH_HASH)) {
5223+
LibSpirvFile = std::string(LibSpirvTargetFile.str());
5224+
break;
5225+
}
5226+
}
5227+
}
5228+
5229+
if (!LibSpirvFile.empty()) {
5230+
Arg *LibClcInputArg = MakeInputArg(Args, C.getDriver().getOpts(),
5231+
Args.MakeArgString(LibSpirvFile));
5232+
auto *SYCLLibClcInputAction =
5233+
C.MakeAction<InputAction>(*LibClcInputArg, types::TY_LLVM_BC);
5234+
DeviceLinkObjects.push_back(SYCLLibClcInputAction);
5235+
}
5236+
5237+
const toolchains::CudaToolChain *CudaTC =
5238+
static_cast<const toolchains::CudaToolChain *>(TC);
5239+
for (auto LinkInputEnum : enumerate(DeviceLinkerInputs)) {
5240+
const char *BoundArch =
5241+
SYCLTargetInfoList[LinkInputEnum.index()].BoundArch;
5242+
std::string LibDeviceFile =
5243+
CudaTC->CudaInstallation.getLibDeviceFile(BoundArch);
5244+
if (!LibDeviceFile.empty()) {
5245+
Arg *CudaDeviceLibInputArg =
5246+
MakeInputArg(Args, C.getDriver().getOpts(),
5247+
Args.MakeArgString(LibDeviceFile));
5248+
auto *SYCLDeviceLibInputAction = C.MakeAction<InputAction>(
5249+
*CudaDeviceLibInputArg, types::TY_LLVM_BC);
5250+
DeviceLinkObjects.push_back(SYCLDeviceLibInputAction);
5251+
}
5252+
}
5253+
}
51725254
return NumOfDeviceLibLinked != 0;
51735255
}
51745256

@@ -5318,11 +5400,12 @@ class OffloadingActionBuilder final {
53185400
// When spv online link is supported by all backends, the fallback
53195401
// device libraries are only needed when current toolchain is using
53205402
// AOT compilation.
5321-
if (isSPIR) {
5403+
if (isSPIR || isNVPTX) {
53225404
bool UseJitLink =
5405+
isSPIR &&
53235406
Args.hasFlag(options::OPT_fsycl_device_lib_jit_link,
53245407
options::OPT_fno_sycl_device_lib_jit_link, false);
5325-
bool UseAOTLink = isSpirvAOT || !UseJitLink;
5408+
bool UseAOTLink = isSPIR && (isSpirvAOT || !UseJitLink);
53265409
SYCLDeviceLibLinked = addSYCLDeviceLibs(
53275410
TC, FullLinkObjects, UseAOTLink,
53285411
C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment());

‎clang/lib/Driver/ToolChains/Clang.cpp

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8741,7 +8741,8 @@ void OffloadBundler::ConstructJob(Compilation &C, const JobAction &JA,
87418741
Triples += CurTC->getTriple().normalize();
87428742
if ((CurKind == Action::OFK_HIP || CurKind == Action::OFK_OpenMP ||
87438743
CurKind == Action::OFK_Cuda || CurKind == Action::OFK_SYCL) &&
8744-
!StringRef(CurDep->getOffloadingArch()).empty()) {
8744+
!StringRef(CurDep->getOffloadingArch()).empty() &&
8745+
!TCArgs.hasArg(options::OPT_fno_bundle_offload_arch)) {
87458746
Triples += '-';
87468747
Triples += CurDep->getOffloadingArch();
87478748
}
@@ -8930,7 +8931,8 @@ void OffloadBundler::ConstructJobMultipleOutputs(
89308931
Dep.DependentOffloadKind == Action::OFK_OpenMP ||
89318932
Dep.DependentOffloadKind == Action::OFK_Cuda ||
89328933
Dep.DependentOffloadKind == Action::OFK_SYCL) &&
8933-
!Dep.DependentBoundArch.empty()) {
8934+
!Dep.DependentBoundArch.empty() &&
8935+
!TCArgs.hasArg(options::OPT_fno_bundle_offload_arch)) {
89348936
Triples += '-';
89358937
Triples += Dep.DependentBoundArch;
89368938
}

‎clang/lib/Driver/ToolChains/Cuda.h

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -183,7 +183,9 @@ class LLVM_LIBRARY_VISIBILITY CudaToolChain : public ToolChain {
183183
bool supportsDebugInfoOption(const llvm::opt::Arg *A) const override;
184184
void adjustDebugInfoKind(codegenoptions::DebugInfoKind &DebugInfoKind,
185185
const llvm::opt::ArgList &Args) const override;
186-
bool IsMathErrnoDefault() const override { return false; }
186+
187+
// math-errno should be the default for SYCL but not other OFK using CUDA TC
188+
bool IsMathErrnoDefault() const override { return OK == Action::OFK_SYCL; }
187189

188190
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
189191
llvm::opt::ArgStringList &CC1Args) const override;

‎clang/lib/Driver/ToolChains/SYCL.cpp

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -170,6 +170,13 @@ const char *SYCL::Linker::constructLLVMLinkCommand(
170170
LibPostfix = ".obj";
171171
std::string FileName = this->getToolChain().getInputFilename(II);
172172
StringRef InputFilename = llvm::sys::path::filename(FileName);
173+
if (this->getToolChain().getTriple().isNVPTX()) {
174+
// Linking SYCL Device libs requires libclc as well as libdevice
175+
if ((InputFilename.find("nvidiacl") != InputFilename.npos ||
176+
InputFilename.find("libdevice") != InputFilename.npos))
177+
return true;
178+
LibPostfix = ".cubin";
179+
}
173180
StringRef LibSyclPrefix("libsycl-");
174181
if (!InputFilename.startswith(LibSyclPrefix) ||
175182
!InputFilename.endswith(LibPostfix) || (InputFilename.count('-') < 2))
@@ -620,7 +627,7 @@ void SYCL::x86_64::BackendCompiler::ConstructJob(
620627

621628
SYCLToolChain::SYCLToolChain(const Driver &D, const llvm::Triple &Triple,
622629
const ToolChain &HostTC, const ArgList &Args)
623-
: ToolChain(D, Triple, Args), HostTC(HostTC), SYCLInstallation(D) {
630+
: ToolChain(D, Triple, Args), HostTC(HostTC) {
624631
// Lookup binaries into the driver directory, this is used to
625632
// discover the clang-offload-bundler executable.
626633
getProgramPaths().push_back(getDriver().Dir);

‎clang/lib/Driver/ToolChains/SYCL.h

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -172,9 +172,7 @@ class LLVM_LIBRARY_VISIBILITY SYCLToolChain : public ToolChain {
172172
const llvm::opt::ArgList &Args,
173173
llvm::opt::ArgStringList &CC1Args) const override;
174174

175-
176175
const ToolChain &HostTC;
177-
const SYCLInstallationDetector SYCLInstallation;
178176

179177
protected:
180178
Tool *buildBackendCompiler() const override;

‎clang/test/Driver/Inputs/SYCL/lib/nvidiacl/remangled-l32-signed_char.libspirv-nvptx64--nvidiacl.bc

Whitespace-only changes.

‎clang/test/Driver/Inputs/SYCL/lib/nvidiacl/remangled-l64-signed_char.libspirv-nvptx64--nvidiacl.bc

Whitespace-only changes.

‎clang/test/Driver/sycl-cuda-tu-offload.cu

Lines changed: 70 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// RUN: %clangxx -ccc-print-phases -target x86_64-unknown-linux-gnu -fsycl -fsycl-targets=nvptx64-nvidia-cuda -Xsycl-target-backend --cuda-gpu-arch=sm_80 --cuda-gpu-arch=sm_80 -c %s 2>&1 | FileCheck %s --check-prefix=DEFAULT-PHASES
1+
// RUN: %clangxx -ccc-print-phases --sysroot=%S/Inputs/SYCL -target x86_64-unknown-linux-gnu -fsycl -fsycl-targets=nvptx64-nvidia-cuda -Xsycl-target-backend --cuda-gpu-arch=sm_80 --cuda-gpu-arch=sm_80 -c %s 2>&1 | FileCheck %s --check-prefix=DEFAULT-PHASES
22

33
// Test the correct placement of the offloading actions for compiling CUDA sources (*.cu) in SYCL.
44

@@ -19,7 +19,7 @@
1919
// DEFAULT-PHASES:|- 14: assembler, {13}, object, (host-cuda-sycl)
2020
// DEFAULT-PHASES:15: clang-offload-bundler, {3, 14}, object, (host-cuda-sycl)
2121

22-
// RUN: %clangxx -ccc-print-phases -target x86_64-unknown-linux-gnu -fsycl -fsycl-targets=nvptx64-nvidia-cuda -Xsycl-target-backend --cuda-gpu-arch=sm_80 --cuda-gpu-arch=sm_80 %s 2>&1 | FileCheck %s --check-prefix=DEFAULT-PHASES2
22+
// RUN: %clangxx -ccc-print-phases --sysroot=%S/Inputs/SYCL --cuda-path=%S/Inputs/CUDA_111/usr/local/cuda -fsycl-libspirv-path=%S/Inputs/SYCL/lib/nvidiacl -target x86_64-unknown-linux-gnu -fsycl -fsycl-targets=nvptx64-nvidia-cuda -Xsycl-target-backend --cuda-gpu-arch=sm_80 --cuda-gpu-arch=sm_80 %s 2>&1 | FileCheck %s --check-prefix=DEFAULT-PHASES2
2323

2424
// DEFAULT-PHASES2: +- 0: input, "{{.*}}", cuda, (host-cuda)
2525
// DEFAULT-PHASES2: +- 1: preprocessor, {0}, cuda-cpp-output, (host-cuda)
@@ -37,14 +37,71 @@
3737
// DEFAULT-PHASES2: +- 13: assembler, {12}, object, (host-cuda-sycl)
3838
// DEFAULT-PHASES2: +- 14: offload, "host-cuda-sycl (x86_64-unknown-linux-gnu)" {13}, object
3939
// DEFAULT-PHASES2:+- 15: linker, {14}, image, (host-cuda-sycl)
40-
// DEFAULT-PHASES2:| +- 16: offload, "device-cuda (nvptx64-nvidia-cuda:sm_80)" {5}, ir
41-
// DEFAULT-PHASES2:| +- 17: linker, {16}, ir, (device-sycl, sm_80)
42-
// DEFAULT-PHASES2:| +- 18: sycl-post-link, {17}, ir, (device-sycl, sm_80)
43-
// DEFAULT-PHASES2:| | +- 19: file-table-tform, {18}, ir, (device-sycl, sm_80)
44-
// DEFAULT-PHASES2:| | | +- 20: backend, {19}, assembler, (device-sycl, sm_80)
45-
// DEFAULT-PHASES2:| | | |- 21: assembler, {20}, object, (device-sycl, sm_80)
46-
// DEFAULT-PHASES2:| | |- 22: linker, {20, 21}, cuda-fatbin, (device-sycl, sm_80)
47-
// DEFAULT-PHASES2:| |- 23: foreach, {19, 22}, cuda-fatbin, (device-sycl, sm_80)
48-
// DEFAULT-PHASES2:| +- 24: file-table-tform, {18, 23}, tempfiletable, (device-sycl, sm_80)
49-
// DEFAULT-PHASES2:|- 25: clang-offload-wrapper, {24}, object, (device-sycl, sm_80)
50-
// DEFAULT-PHASES2:26: offload, "host-cuda-sycl (x86_64-unknown-linux-gnu)" {15}, "device-sycl (nvptx64-nvidia-cuda:sm_80)" {25}, image
40+
// DEFAULT-PHASES2:| +- 16: offload, "device-cuda (nvptx64-nvidia-cuda:sm_80)" {5}, ir
41+
// DEFAULT-PHASES2:| +- 17: linker, {16}, ir, (device-sycl, sm_80)
42+
// DEFAULT-PHASES2:| | +- 18: input, "{{.*}}", object
43+
// DEFAULT-PHASES2:| | +- 19: clang-offload-unbundler, {18}, object
44+
// DEFAULT-PHASES2:| |- 20: offload, " (nvptx64-nvidia-cuda)" {19}, object
45+
// DEFAULT-PHASES2:| | +- 21: input, "{{.*}}", object
46+
// DEFAULT-PHASES2:| | +- 22: clang-offload-unbundler, {21}, object
47+
// DEFAULT-PHASES2:| |- 23: offload, " (nvptx64-nvidia-cuda)" {22}, object
48+
// DEFAULT-PHASES2:| | +- 24: input, "{{.*}}", object
49+
// DEFAULT-PHASES2:| | +- 25: clang-offload-unbundler, {24}, object
50+
// DEFAULT-PHASES2:| |- 26: offload, " (nvptx64-nvidia-cuda)" {25}, object
51+
// DEFAULT-PHASES2:| | +- 27: input, "{{.*}}", object
52+
// DEFAULT-PHASES2:| | +- 28: clang-offload-unbundler, {27}, object
53+
// DEFAULT-PHASES2:| |- 29: offload, " (nvptx64-nvidia-cuda)" {28}, object
54+
// DEFAULT-PHASES2:| | +- 30: input, "{{.*}}", object
55+
// DEFAULT-PHASES2:| | +- 31: clang-offload-unbundler, {30}, object
56+
// DEFAULT-PHASES2:| |- 32: offload, " (nvptx64-nvidia-cuda)" {31}, object
57+
// DEFAULT-PHASES2:| | +- 33: input, "{{.*}}", object
58+
// DEFAULT-PHASES2:| | +- 34: clang-offload-unbundler, {33}, object
59+
// DEFAULT-PHASES2:| |- 35: offload, " (nvptx64-nvidia-cuda)" {34}, object
60+
// DEFAULT-PHASES2:| | +- 36: input, "{{.*}}", object
61+
// DEFAULT-PHASES2:| | +- 37: clang-offload-unbundler, {36}, object
62+
// DEFAULT-PHASES2:| |- 38: offload, " (nvptx64-nvidia-cuda)" {37}, object
63+
// DEFAULT-PHASES2:| | +- 39: input, "{{.*}}", object
64+
// DEFAULT-PHASES2:| | +- 40: clang-offload-unbundler, {39}, object
65+
// DEFAULT-PHASES2:| |- 41: offload, " (nvptx64-nvidia-cuda)" {40}, object
66+
// DEFAULT-PHASES2:| | +- 42: input, "{{.*}}", object
67+
// DEFAULT-PHASES2:| | +- 43: clang-offload-unbundler, {42}, object
68+
// DEFAULT-PHASES2:| |- 44: offload, " (nvptx64-nvidia-cuda)" {43}, object
69+
// DEFAULT-PHASES2:| | +- 45: input, "{{.*}}", object
70+
// DEFAULT-PHASES2:| | +- 46: clang-offload-unbundler, {45}, object
71+
// DEFAULT-PHASES2:| |- 47: offload, " (nvptx64-nvidia-cuda)" {46}, object
72+
// DEFAULT-PHASES2:| | +- 48: input, "{{.*}}", object
73+
// DEFAULT-PHASES2:| | +- 49: clang-offload-unbundler, {48}, object
74+
// DEFAULT-PHASES2:| |- 50: offload, " (nvptx64-nvidia-cuda)" {49}, object
75+
// DEFAULT-PHASES2:| | +- 51: input, "{{.*}}", object
76+
// DEFAULT-PHASES2:| | +- 52: clang-offload-unbundler, {51}, object
77+
// DEFAULT-PHASES2:| |- 53: offload, " (nvptx64-nvidia-cuda)" {52}, object
78+
// DEFAULT-PHASES2:| | +- 54: input, "{{.*}}", object
79+
// DEFAULT-PHASES2:| | +- 55: clang-offload-unbundler, {54}, object
80+
// DEFAULT-PHASES2:| |- 56: offload, " (nvptx64-nvidia-cuda)" {55}, object
81+
// DEFAULT-PHASES2:| | +- 57: input, "{{.*}}", object
82+
// DEFAULT-PHASES2:| | +- 58: clang-offload-unbundler, {57}, object
83+
// DEFAULT-PHASES2:| |- 59: offload, " (nvptx64-nvidia-cuda)" {58}, object
84+
// DEFAULT-PHASES2:| | +- 60: input, "{{.*}}", object
85+
// DEFAULT-PHASES2:| | +- 61: clang-offload-unbundler, {60}, object
86+
// DEFAULT-PHASES2:| |- 62: offload, " (nvptx64-nvidia-cuda)" {61}, object
87+
// DEFAULT-PHASES2:| | +- 63: input, "{{.*}}", object
88+
// DEFAULT-PHASES2:| | +- 64: clang-offload-unbundler, {63}, object
89+
// DEFAULT-PHASES2:| |- 65: offload, " (nvptx64-nvidia-cuda)" {64}, object
90+
// DEFAULT-PHASES2:| | +- 66: input, "{{.*}}", object
91+
// DEFAULT-PHASES2:| | +- 67: clang-offload-unbundler, {66}, object
92+
// DEFAULT-PHASES2:| |- 68: offload, " (nvptx64-nvidia-cuda)" {67}, object
93+
// DEFAULT-PHASES2:| | +- 69: input, "{{.*}}", object
94+
// DEFAULT-PHASES2:| | +- 70: clang-offload-unbundler, {69}, object
95+
// DEFAULT-PHASES2:| |- 71: offload, " (nvptx64-nvidia-cuda)" {70}, object
96+
// DEFAULT-PHASES2:| |- 72: input, "{{.*}}nvidiacl{{.*}}", ir, (device-sycl, sm_80)
97+
// DEFAULT-PHASES2:| |- 73: input, "{{.*}}libdevice{{.*}}", ir, (device-sycl, sm_80)
98+
// DEFAULT-PHASES2:| +- 74: linker, {17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 62, 65, 68, 71, 72, 73}, ir, (device-sycl, sm_80)
99+
// DEFAULT-PHASES2:| +- 75: sycl-post-link, {74}, ir, (device-sycl, sm_80)
100+
// DEFAULT-PHASES2:| | +- 76: file-table-tform, {75}, ir, (device-sycl, sm_80)
101+
// DEFAULT-PHASES2:| | | +- 77: backend, {76}, assembler, (device-sycl, sm_80)
102+
// DEFAULT-PHASES2:| | | |- 78: assembler, {77}, object, (device-sycl, sm_80)
103+
// DEFAULT-PHASES2:| | |- 79: linker, {77, 78}, cuda-fatbin, (device-sycl, sm_80)
104+
// DEFAULT-PHASES2:| |- 80: foreach, {76, 79}, cuda-fatbin, (device-sycl, sm_80)
105+
// DEFAULT-PHASES2:| +- 81: file-table-tform, {75, 80}, tempfiletable, (device-sycl, sm_80)
106+
// DEFAULT-PHASES2:|- 82: clang-offload-wrapper, {81}, object, (device-sycl, sm_80)
107+
// DEFAULT-PHASES2:83: offload, "host-cuda-sycl (x86_64-unknown-linux-gnu)" {15}, "device-sycl (nvptx64-nvidia-cuda:sm_80)" {82}, image

0 commit comments

Comments
 (0)