1//===---------- DeviceOffload.cpp - Device Offloading------------*- 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
10// This file implements offloading to devices.
11//
12//===----------------------------------------------------------------------===//
13
14#include "DeviceOffload.h"
15
16#include "clang/Basic/TargetOptions.h"
17#include "clang/CodeGen/BackendUtil.h"
18#include "clang/CodeGen/ModuleBuilder.h"
19#include "clang/Frontend/CompilerInstance.h"
20#include "clang/Interpreter/PartialTranslationUnit.h"
21
22#include "llvm/ADT/StringExtras.h"
23#include "llvm/IR/LegacyPassManager.h"
24#include "llvm/IR/Module.h"
25#include "llvm/MC/TargetRegistry.h"
26#include "llvm/Target/TargetMachine.h"
27#include "llvm/TargetParser/Triple.h"
28
29namespace clang {
30
31IncrementalDeviceParser::IncrementalDeviceParser(
32 CompilerInstance &DeviceInstance, CompilerInstance &HostInstance,
33 IncrementalAction *DeviceAct,
34 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS,
35 llvm::Error &Err, std::list<PartialTranslationUnit> &PTUs)
36 : IncrementalParser(DeviceInstance, DeviceAct, Err, PTUs), VFS(FS),
37 CodeGenOpts(HostInstance.getCodeGenOpts()),
38 TargetOpts(DeviceInstance.getTargetOpts()) {}
39
40IncrementalDeviceParser::~IncrementalDeviceParser() {}
41
42IncrementalHIPDeviceParser::IncrementalHIPDeviceParser(
43 CompilerInstance &DeviceInstance, CompilerInstance &HostInstance,
44 IncrementalAction *DeviceAct,
45 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS,
46 llvm::Error &Err, std::list<PartialTranslationUnit> &PTUs)
47 : IncrementalDeviceParser(DeviceInstance, HostInstance, DeviceAct, FS, Err,
48 PTUs),
49 DeviceCI(DeviceInstance) {
50 if (Err)
51 return;
52 if (!llvm::Triple(TargetOpts.Triple).isAMDGCN()) {
53 Err = llvm::joinErrors(
54 E1: std::move(Err),
55 E2: llvm::make_error<llvm::StringError>(
56 Args: "Invalid HIP architecture for target '" + TargetOpts.Triple + "'",
57 Args: llvm::inconvertibleErrorCode()));
58 return;
59 }
60}
61
62llvm::Expected<llvm::StringRef>
63IncrementalHIPDeviceParser::GenerateDeviceObject() {
64 auto &PTU = PTUs.back();
65
66 CodeGenOptions CodeGenOptsForObj = DeviceCI.getCodeGenOpts();
67
68 ObjectContent.clear();
69 auto ObjOS = std::make_unique<llvm::raw_svector_ostream>(args&: ObjectContent);
70 emitBackendOutput(CI&: DeviceCI, CGOpts&: CodeGenOptsForObj, M: PTU.TheModule.get(),
71 Action: Backend_EmitObj, VFS: DeviceCI.getVirtualFileSystemPtr(),
72 OS: std::move(ObjOS));
73
74 if (DeviceCI.getDiagnostics().hasErrorOccurred())
75 return llvm::make_error<llvm::StringError>(
76 Args: "Backend code generation failed for HIP device code.",
77 Args: llvm::inconvertibleErrorCode());
78
79 return llvm::StringRef(ObjectContent.data(), ObjectContent.size());
80}
81
82llvm::Error IncrementalHIPDeviceParser::GenerateOffloadBinary() {
83 llvm::Expected<llvm::StringRef> Object = GenerateDeviceObject();
84 if (!Object)
85 return Object.takeError();
86
87 // FIXME: Link the object into an HSACO and bundle it for the host
88 // compilation.
89 return llvm::make_error<llvm::StringError>(
90 Args: "HIP offload binary generation is not supported yet.",
91 Args: llvm::inconvertibleErrorCode());
92}
93
94IncrementalHIPDeviceParser::~IncrementalHIPDeviceParser() {}
95
96IncrementalCUDADeviceParser::IncrementalCUDADeviceParser(
97 CompilerInstance &DeviceInstance, CompilerInstance &HostInstance,
98 IncrementalAction *DeviceAct,
99 llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS,
100 llvm::Error &Err, std::list<PartialTranslationUnit> &PTUs)
101 : IncrementalDeviceParser(DeviceInstance, HostInstance, DeviceAct, FS, Err,
102 PTUs) {
103 if (Err)
104 return;
105 StringRef Arch = TargetOpts.CPU;
106 if (!Arch.starts_with(Prefix: "sm_") || Arch.substr(Start: 3).getAsInteger(Radix: 10, Result&: SMVersion)) {
107 Err = llvm::joinErrors(E1: std::move(Err), E2: llvm::make_error<llvm::StringError>(
108 Args: "Invalid CUDA architecture",
109 Args: llvm::inconvertibleErrorCode()));
110 return;
111 }
112}
113
114llvm::Expected<llvm::StringRef> IncrementalCUDADeviceParser::GeneratePTX() {
115 auto &PTU = PTUs.back();
116 std::string Error;
117
118 const llvm::Target *Target = llvm::TargetRegistry::lookupTarget(
119 TheTriple: PTU.TheModule->getTargetTriple(), Error);
120 if (!Target)
121 return llvm::make_error<llvm::StringError>(Args: std::move(Error),
122 Args: std::error_code());
123 llvm::TargetOptions TO = llvm::TargetOptions();
124 std::unique_ptr<llvm::TargetMachine> TM(Target->createTargetMachine(
125 TT: PTU.TheModule->getTargetTriple(), CPU: TargetOpts.CPU,
126 Features: llvm::join(R: TargetOpts.Features, Separator: ","), Options: TO, RM: llvm::Reloc::Model::PIC_));
127
128 PTXCode.clear();
129 llvm::raw_svector_ostream dest(PTXCode);
130
131 llvm::legacy::PassManager PM;
132 if (TM->addPassesToEmitFile(PM, dest, nullptr,
133 llvm::CodeGenFileType::AssemblyFile)) {
134 return llvm::make_error<llvm::StringError>(
135 Args: "NVPTX backend cannot produce PTX code.",
136 Args: llvm::inconvertibleErrorCode());
137 }
138
139 PM.run(M&: *PTU.TheModule);
140
141 PTXCode += '\0';
142 while (PTXCode.size() % 8)
143 PTXCode += '\0';
144 return PTXCode.str();
145}
146
147llvm::Error IncrementalCUDADeviceParser::GenerateFatbinary() {
148 enum FatBinFlags {
149 AddressSize64 = 0x01,
150 HasDebugInfo = 0x02,
151 ProducerCuda = 0x04,
152 HostLinux = 0x10,
153 HostMac = 0x20,
154 HostWindows = 0x40
155 };
156
157 struct FatBinInnerHeader {
158 uint16_t Kind; // 0x00
159 uint16_t unknown02; // 0x02
160 uint32_t HeaderSize; // 0x04
161 uint32_t DataSize; // 0x08
162 uint32_t unknown0c; // 0x0c
163 uint32_t CompressedSize; // 0x10
164 uint32_t SubHeaderSize; // 0x14
165 uint16_t VersionMinor; // 0x18
166 uint16_t VersionMajor; // 0x1a
167 uint32_t CudaArch; // 0x1c
168 uint32_t unknown20; // 0x20
169 uint32_t unknown24; // 0x24
170 uint32_t Flags; // 0x28
171 uint32_t unknown2c; // 0x2c
172 uint32_t unknown30; // 0x30
173 uint32_t unknown34; // 0x34
174 uint32_t UncompressedSize; // 0x38
175 uint32_t unknown3c; // 0x3c
176 uint32_t unknown40; // 0x40
177 uint32_t unknown44; // 0x44
178 FatBinInnerHeader(uint32_t DataSize, uint32_t CudaArch, uint32_t Flags)
179 : Kind(1 /*PTX*/), unknown02(0x0101), HeaderSize(sizeof(*this)),
180 DataSize(DataSize), unknown0c(0), CompressedSize(0),
181 SubHeaderSize(HeaderSize - 8), VersionMinor(2), VersionMajor(4),
182 CudaArch(CudaArch), unknown20(0), unknown24(0), Flags(Flags),
183 unknown2c(0), unknown30(0), unknown34(0), UncompressedSize(0),
184 unknown3c(0), unknown40(0), unknown44(0) {}
185 };
186
187 struct FatBinHeader {
188 uint32_t Magic; // 0x00
189 uint16_t Version; // 0x04
190 uint16_t HeaderSize; // 0x06
191 uint32_t DataSize; // 0x08
192 uint32_t unknown0c; // 0x0c
193 public:
194 FatBinHeader(uint32_t DataSize)
195 : Magic(0xba55ed50), Version(1), HeaderSize(sizeof(*this)),
196 DataSize(DataSize), unknown0c(0) {}
197 };
198
199 FatBinHeader OuterHeader(sizeof(FatBinInnerHeader) + PTXCode.size());
200 FatbinContent.append(in_start: (char *)&OuterHeader,
201 in_end: ((char *)&OuterHeader) + OuterHeader.HeaderSize);
202
203 FatBinInnerHeader InnerHeader(PTXCode.size(), SMVersion,
204 FatBinFlags::AddressSize64 |
205 FatBinFlags::HostLinux);
206 FatbinContent.append(in_start: (char *)&InnerHeader,
207 in_end: ((char *)&InnerHeader) + InnerHeader.HeaderSize);
208
209 FatbinContent.append(in_start: PTXCode.begin(), in_end: PTXCode.end());
210
211 const PartialTranslationUnit &PTU = PTUs.back();
212
213 std::string FatbinFileName = "/" + PTU.TheModule->getName().str() + ".fatbin";
214
215 VFS->addFile(Path: FatbinFileName, ModificationTime: 0,
216 Buffer: llvm::MemoryBuffer::getMemBuffer(
217 InputData: llvm::StringRef(FatbinContent.data(), FatbinContent.size()),
218 BufferName: "", RequiresNullTerminator: false));
219
220 CodeGenOpts.OffloadBinaryToEmbedFile = std::move(FatbinFileName);
221
222 FatbinContent.clear();
223
224 return llvm::Error::success();
225}
226
227llvm::Error IncrementalCUDADeviceParser::GenerateOffloadBinary() {
228 llvm::Expected<llvm::StringRef> PTX = GeneratePTX();
229 if (!PTX)
230 return PTX.takeError();
231
232 return GenerateFatbinary();
233}
234
235IncrementalCUDADeviceParser::~IncrementalCUDADeviceParser() {}
236
237} // namespace clang
238