1//===- OffloadBinary.cpp - Utilities for handling offloading code ---------===//
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 "llvm/Object/OffloadBinary.h"
10
11#include "llvm/ADT/ArrayRef.h"
12#include "llvm/ADT/StringExtras.h"
13#include "llvm/ADT/StringSwitch.h"
14#include "llvm/BinaryFormat/Magic.h"
15#include "llvm/IR/Constants.h"
16#include "llvm/IR/Module.h"
17#include "llvm/IRReader/IRReader.h"
18#include "llvm/MC/StringTableBuilder.h"
19#include "llvm/Object/Archive.h"
20#include "llvm/Object/Binary.h"
21#include "llvm/Object/ELFObjectFile.h"
22#include "llvm/Object/Error.h"
23#include "llvm/Object/IRObjectFile.h"
24#include "llvm/Object/ObjectFile.h"
25#include "llvm/Support/Alignment.h"
26#include "llvm/Support/Compression.h"
27#include "llvm/Support/Error.h"
28#include "llvm/Support/SourceMgr.h"
29#include "llvm/Support/raw_ostream.h"
30#include "llvm/TargetParser/AMDGPUTargetParser.h"
31
32#include <cassert>
33#include <cstddef>
34#include <memory>
35
36using namespace llvm;
37using namespace llvm::object;
38
39namespace {
40
41/// Attempts to extract all the embedded device images contained inside the
42/// buffer \p Contents. The buffer is expected to contain a valid offloading
43/// binary format.
44Error extractOffloadFiles(MemoryBufferRef Contents,
45 SmallVectorImpl<OffloadFile> &Binaries) {
46 uint64_t Offset = 0;
47 // There could be multiple offloading binaries stored at this section.
48 while (Offset < Contents.getBufferSize()) {
49 std::unique_ptr<MemoryBuffer> Buffer =
50 MemoryBuffer::getMemBuffer(InputData: Contents.getBuffer().drop_front(N: Offset), BufferName: "",
51 /*RequiresNullTerminator*/ false);
52 if (!isAddrAligned(Lhs: Align(OffloadBinary::getAlignment()),
53 Addr: Buffer->getBufferStart()))
54 Buffer = MemoryBuffer::getMemBufferCopy(InputData: Buffer->getBuffer(),
55 BufferName: Buffer->getBufferIdentifier());
56
57 auto HeaderOrErr = OffloadBinary::extractHeader(Buf: *Buffer);
58 if (!HeaderOrErr)
59 return HeaderOrErr.takeError();
60 const OffloadBinary::Header *Header = *HeaderOrErr;
61
62 MemoryBufferRef Slice(Buffer->getBuffer().take_front(N: Header->Size),
63 Contents.getBufferIdentifier());
64 auto BinariesOrErr = OffloadBinary::create(Buf: Slice);
65 if (!BinariesOrErr)
66 return BinariesOrErr.takeError();
67
68 for (auto &Binary : *BinariesOrErr)
69 Binaries.emplace_back(Args: std::move(Binary));
70
71 Offset = alignTo(Value: Offset + Header->Size, Align: OffloadBinary::getAlignment());
72 }
73
74 return Error::success();
75}
76
77// Extract offloading binaries from an Object file \p Obj.
78Error extractFromObject(const ObjectFile &Obj,
79 SmallVectorImpl<OffloadFile> &Binaries) {
80 assert((Obj.isELF() || Obj.isCOFF()) && "Invalid file type");
81
82 for (SectionRef Sec : Obj.sections()) {
83 // ELF files contain a section with the LLVM_OFFLOADING type.
84 if (Obj.isELF() &&
85 static_cast<ELFSectionRef>(Sec).getType() != ELF::SHT_LLVM_OFFLOADING)
86 continue;
87
88 // COFF has no section types so we rely on the name of the section.
89 if (Obj.isCOFF()) {
90 Expected<StringRef> NameOrErr = Sec.getName();
91 if (!NameOrErr)
92 return NameOrErr.takeError();
93
94 if (!NameOrErr->starts_with(Prefix: ".llvm.offloading"))
95 continue;
96 }
97
98 Expected<StringRef> Buffer = Sec.getContents();
99 if (!Buffer)
100 return Buffer.takeError();
101
102 MemoryBufferRef Contents(*Buffer, Obj.getFileName());
103 if (Error Err = extractOffloadFiles(Contents, Binaries))
104 return Err;
105 }
106
107 return Error::success();
108}
109
110Error extractFromBitcode(MemoryBufferRef Buffer,
111 SmallVectorImpl<OffloadFile> &Binaries) {
112 LLVMContext Context;
113 SMDiagnostic Err;
114 std::unique_ptr<Module> M = getLazyIRModule(
115 Buffer: MemoryBuffer::getMemBuffer(Ref: Buffer, /*RequiresNullTerminator=*/false), Err,
116 Context);
117 if (!M)
118 return createStringError(EC: inconvertibleErrorCode(),
119 S: "Failed to create module");
120
121 // Extract offloading data from globals referenced by the
122 // `llvm.embedded.object` metadata with the `.llvm.offloading` section.
123 auto *MD = M->getNamedMetadata(Name: "llvm.embedded.objects");
124 if (!MD)
125 return Error::success();
126
127 for (const MDNode *Op : MD->operands()) {
128 if (Op->getNumOperands() < 2)
129 continue;
130
131 MDString *SectionID = dyn_cast<MDString>(Val: Op->getOperand(I: 1));
132 if (!SectionID || SectionID->getString() != ".llvm.offloading")
133 continue;
134
135 GlobalVariable *GV =
136 mdconst::dyn_extract_or_null<GlobalVariable>(MD: Op->getOperand(I: 0));
137 if (!GV)
138 continue;
139
140 auto *CDS = dyn_cast<ConstantDataSequential>(Val: GV->getInitializer());
141 if (!CDS)
142 continue;
143
144 MemoryBufferRef Contents(CDS->getAsString(), M->getName());
145 if (Error Err = extractOffloadFiles(Contents, Binaries))
146 return Err;
147 }
148
149 return Error::success();
150}
151
152Error extractFromArchive(const Archive &Library,
153 SmallVectorImpl<OffloadFile> &Binaries) {
154 // Try to extract device code from each file stored in the static archive.
155 Error Err = Error::success();
156 for (auto Child : Library.children(Err)) {
157 auto ChildBufferOrErr = Child.getMemoryBufferRef();
158 if (!ChildBufferOrErr)
159 return ChildBufferOrErr.takeError();
160 std::unique_ptr<MemoryBuffer> ChildBuffer =
161 MemoryBuffer::getMemBuffer(Ref: *ChildBufferOrErr, RequiresNullTerminator: false);
162
163 // Check if the buffer has the required alignment.
164 if (!isAddrAligned(Lhs: Align(OffloadBinary::getAlignment()),
165 Addr: ChildBuffer->getBufferStart()))
166 ChildBuffer = MemoryBuffer::getMemBufferCopy(
167 InputData: ChildBufferOrErr->getBuffer(),
168 BufferName: ChildBufferOrErr->getBufferIdentifier());
169
170 if (Error Err = extractOffloadBinaries(Buffer: *ChildBuffer, Binaries))
171 return Err;
172 }
173
174 if (Err)
175 return Err;
176 return Error::success();
177}
178
179Expected<std::unique_ptr<MemoryBuffer>>
180decompressOffloadBinary(MemoryBufferRef Buf) {
181 const auto *Header =
182 reinterpret_cast<const OffloadBinary::Header *>(Buf.getBufferStart());
183 if (Header->EntriesOffset != sizeof(OffloadBinary::Header) ||
184 Header->EntriesOffset > Header->Size ||
185 Header->InflatedSize < Header->EntriesOffset)
186 return errorCodeToError(EC: object_error::unexpected_eof);
187
188 // Get the compressed binary blob after the header.
189 StringRef Compressed = Buf.getBuffer()
190 .take_front(N: Header->Size)
191 .drop_front(N: Header->EntriesOffset);
192 uint64_t BodySize = Header->InflatedSize - Header->EntriesOffset;
193
194 SmallVector<uint8_t, 0> Body;
195 if (Error Err = compression::decompress(Input: arrayRefFromStringRef(Input: Compressed),
196 Output&: Body, UncompressedSize: BodySize))
197 return std::move(Err);
198
199 // Restore the old header data for the newly uncompressed blob.
200 OffloadBinary::Header Restored = *Header;
201 Restored.Size = Restored.InflatedSize;
202 Restored.InflatedSize = 0;
203 if (Restored.EntriesOffset + Body.size() != Restored.Size)
204 return errorCodeToError(EC: object_error::parse_failed);
205
206 SmallString<0> Out;
207 Out.reserve(N: Restored.Size);
208 Out.append(RHS: StringRef(reinterpret_cast<const char *>(&Restored),
209 sizeof(OffloadBinary::Header)));
210 Out.append(RHS: toStringRef(Input: Body));
211 return MemoryBuffer::getMemBufferCopy(InputData: Out, BufferName: Buf.getBufferIdentifier());
212}
213
214} // namespace
215
216bool OffloadBinary::isCompressed(MemoryBufferRef Buf) {
217 if (Buf.getBufferSize() < sizeof(Header) ||
218 !isAddrAligned(Lhs: Align(getAlignment()), Addr: Buf.getBufferStart()) ||
219 identify_magic(magic: Buf.getBuffer()) != file_magic::offload_binary)
220 return false;
221
222 const auto *Hdr = reinterpret_cast<const Header *>(Buf.getBufferStart());
223 return Hdr->Version >= 3 && Hdr->InflatedSize != 0;
224}
225
226Expected<const OffloadBinary::Header *>
227OffloadBinary::extractHeader(MemoryBufferRef Buf) {
228 if (Buf.getBufferSize() < sizeof(Header))
229 return errorCodeToError(EC: object_error::parse_failed);
230
231 // Check for 0x10FF1OAD magic bytes.
232 if (identify_magic(magic: Buf.getBuffer()) != file_magic::offload_binary)
233 return errorCodeToError(EC: object_error::parse_failed);
234
235 // Make sure that the data has sufficient alignment.
236 if (!isAddrAligned(Lhs: Align(getAlignment()), Addr: Buf.getBufferStart()))
237 return errorCodeToError(EC: object_error::parse_failed);
238
239 const char *Start = Buf.getBufferStart();
240 const Header *TheHeader = reinterpret_cast<const Header *>(Start);
241 if (TheHeader->Version == 0 || TheHeader->Version > OffloadBinary::Version)
242 return errorCodeToError(EC: object_error::parse_failed);
243
244 if (TheHeader->Size > Buf.getBufferSize() || TheHeader->Size < sizeof(Header))
245 return errorCodeToError(EC: object_error::unexpected_eof);
246
247 if (isCompressed(Buf))
248 return TheHeader;
249
250 if (TheHeader->Size < sizeof(Entry))
251 return errorCodeToError(EC: object_error::unexpected_eof);
252
253 uint64_t EntriesCount =
254 (TheHeader->Version == 1) ? 1 : TheHeader->EntriesCount;
255 uint64_t EntriesSize = sizeof(Entry) * EntriesCount;
256 if (TheHeader->EntriesOffset > TheHeader->Size - EntriesSize ||
257 // v1/v2 headers are 32 bytes; sizeof(Header) grew in v3.
258 EntriesSize > TheHeader->Size - offsetof(Header, InflatedSize))
259 return errorCodeToError(EC: object_error::unexpected_eof);
260
261 return TheHeader;
262}
263
264Expected<SmallVector<std::unique_ptr<OffloadBinary>>>
265OffloadBinary::create(MemoryBufferRef Buf, std::optional<uint64_t> Index) {
266 auto HeaderOrErr = extractHeader(Buf);
267 if (!HeaderOrErr)
268 return HeaderOrErr.takeError();
269 const Header *OnDisk = *HeaderOrErr;
270
271 // The binary data may be a compressed image.
272 std::shared_ptr<MemoryBuffer> Binary;
273 if (isCompressed(Buf)) {
274 auto DecompressedOrErr = decompressOffloadBinary(Buf);
275 if (!DecompressedOrErr)
276 return DecompressedOrErr.takeError();
277 Binary = std::shared_ptr<MemoryBuffer>(std::move(*DecompressedOrErr));
278 } else {
279 Binary = std::shared_ptr<MemoryBuffer>(MemoryBuffer::getMemBufferCopy(
280 InputData: Buf.getBuffer().take_front(N: OnDisk->Size), BufferName: Buf.getBufferIdentifier()));
281 }
282
283 // Owned is now an uncompressed OffloadBinary, parse it as before.
284 MemoryBufferRef Owned = *Binary;
285 HeaderOrErr = extractHeader(Buf: Owned);
286 if (!HeaderOrErr)
287 return HeaderOrErr.takeError();
288 const Header *TheHeader = *HeaderOrErr;
289
290 const char *Start = Owned.getBufferStart();
291 const Entry *Entries =
292 reinterpret_cast<const Entry *>(&Start[TheHeader->EntriesOffset]);
293
294 auto validateEntry = [&](const Entry *TheEntry) -> Error {
295 const uint64_t BufSize = Owned.getBufferSize();
296 if (TheEntry->ImageOffset > BufSize ||
297 TheEntry->ImageSize > BufSize - TheEntry->ImageOffset)
298 return errorCodeToError(EC: object_error::unexpected_eof);
299
300 const size_t StringEntrySize =
301 TheHeader->Version == 1 ? sizeof(StringEntryV1) : sizeof(StringEntry);
302 if (TheEntry->StringOffset > BufSize ||
303 TheEntry->NumStrings >
304 (BufSize - TheEntry->StringOffset) / StringEntrySize)
305 return errorCodeToError(EC: object_error::unexpected_eof);
306 return Error::success();
307 };
308
309 SmallVector<std::unique_ptr<OffloadBinary>> Binaries;
310 if (TheHeader->Version > 1 && Index.has_value()) {
311 if (*Index >= TheHeader->EntriesCount)
312 return errorCodeToError(EC: object_error::parse_failed);
313 const Entry *TheEntry = &Entries[*Index];
314 if (auto Err = validateEntry(TheEntry))
315 return std::move(Err);
316
317 Binaries.emplace_back(
318 Args: new OffloadBinary(Binary, TheHeader, TheEntry, *Index));
319 return std::move(Binaries);
320 }
321
322 uint64_t EntriesCount = TheHeader->Version == 1 ? 1 : TheHeader->EntriesCount;
323 for (uint64_t I = 0; I < EntriesCount; ++I) {
324 const Entry *TheEntry = &Entries[I];
325 if (auto Err = validateEntry(TheEntry))
326 return std::move(Err);
327
328 Binaries.emplace_back(Args: new OffloadBinary(Binary, TheHeader, TheEntry, I));
329 }
330
331 return std::move(Binaries);
332}
333
334SmallString<0> OffloadBinary::write(ArrayRef<OffloadingImage> OffloadingData) {
335 uint64_t EntriesCount = OffloadingData.size();
336 assert(EntriesCount > 0 && "At least one offloading image is required");
337
338 // Create a null-terminated string table with all the used strings.
339 // Also calculate total size of images.
340 StringTableBuilder StrTab(StringTableBuilder::ELF);
341 uint64_t TotalStringEntries = 0;
342 uint64_t TotalImagesSize = 0;
343 for (const OffloadingImage &Img : OffloadingData) {
344 for (auto &KeyAndValue : Img.StringData) {
345 StrTab.add(S: KeyAndValue.first);
346 StrTab.add(S: KeyAndValue.second);
347 }
348 TotalStringEntries += Img.StringData.size();
349 TotalImagesSize += Img.Image->getBufferSize();
350 }
351 StrTab.finalize();
352
353 uint64_t StringEntrySize = sizeof(StringEntry) * TotalStringEntries;
354 uint64_t EntriesSize = sizeof(Entry) * EntriesCount;
355 uint64_t StrTabOffset = sizeof(Header) + EntriesSize + StringEntrySize;
356
357 // Make sure the image we're wrapping around is aligned as well.
358 uint64_t BinaryDataSize =
359 alignTo(Value: StrTabOffset + StrTab.getSize(), Align: getAlignment());
360
361 // Create the header and fill in the offsets. The entries will be directly
362 // placed after the header in memory. Align the size to the alignment of the
363 // header so this can be placed contiguously in a single section.
364 Header TheHeader{};
365 TheHeader.Size = alignTo(Value: BinaryDataSize + TotalImagesSize, Align: getAlignment());
366 TheHeader.EntriesOffset = sizeof(Header);
367 TheHeader.EntriesCount = EntriesCount;
368
369 SmallString<0> Data;
370 Data.reserve(N: TheHeader.Size);
371 raw_svector_ostream OS(Data);
372 OS << StringRef(reinterpret_cast<char *>(&TheHeader), sizeof(Header));
373
374 // Create the entries using the string table offsets. The string table will be
375 // placed directly after the set of entries in memory, and all the images are
376 // after that.
377 uint64_t StringEntryOffset = sizeof(Header) + EntriesSize;
378 uint64_t ImageOffset = BinaryDataSize;
379 for (const OffloadingImage &Img : OffloadingData) {
380 Entry TheEntry;
381
382 TheEntry.TheImageKind = Img.TheImageKind;
383 TheEntry.TheOffloadKind = Img.TheOffloadKind;
384 TheEntry.Flags = Img.Flags;
385
386 TheEntry.StringOffset = StringEntryOffset;
387 StringEntryOffset += sizeof(StringEntry) * Img.StringData.size();
388 TheEntry.NumStrings = Img.StringData.size();
389
390 TheEntry.ImageOffset = ImageOffset;
391 ImageOffset += Img.Image->getBufferSize();
392 TheEntry.ImageSize = Img.Image->getBufferSize();
393
394 OS << StringRef(reinterpret_cast<char *>(&TheEntry), sizeof(Entry));
395 }
396
397 // Create the string map entries.
398 for (const OffloadingImage &Img : OffloadingData) {
399 for (auto &KeyAndValue : Img.StringData) {
400 StringEntry Map{.KeyOffset: StrTabOffset + StrTab.getOffset(S: KeyAndValue.first),
401 .ValueOffset: StrTabOffset + StrTab.getOffset(S: KeyAndValue.second),
402 .ValueSize: KeyAndValue.second.size()};
403 OS << StringRef(reinterpret_cast<char *>(&Map), sizeof(StringEntry));
404 }
405 }
406
407 StrTab.write(OS);
408 // Add padding to required image alignment.
409 OS.write_zeros(NumZeros: BinaryDataSize - OS.tell());
410
411 for (const OffloadingImage &Img : OffloadingData)
412 OS << Img.Image->getBuffer();
413
414 // Add final padding to required alignment.
415 assert(TheHeader.Size >= OS.tell() && "Too much data written?");
416 OS.write_zeros(NumZeros: TheHeader.Size - OS.tell());
417 assert(TheHeader.Size == OS.tell() && "Size mismatch");
418
419 return Data;
420}
421
422Expected<SmallString<0>>
423OffloadBinary::write(ArrayRef<OffloadingImage> OffloadingData,
424 compression::Params Compress) {
425 if (const char *Reason = compression::getReasonIfUnsupported(F: Compress.format))
426 return createStringError(Fmt: Reason);
427
428 // Write the complete offloading binary as normal.
429 SmallString<0> Uncompressed = write(OffloadingData);
430 OffloadBinary::Header Header =
431 *reinterpret_cast<const OffloadBinary::Header *>(Uncompressed.data());
432
433 // Compress the entries after the header with the requested configuration.
434 StringRef Body = StringRef(Uncompressed).drop_front(N: Header.EntriesOffset);
435 SmallVector<uint8_t, 0> CompressedBuffer;
436 compression::compress(P: Compress, Input: arrayRefFromStringRef(Input: Body),
437 Output&: CompressedBuffer);
438
439 // Reset the header sizes and create the newly compressed binary.
440 Header.InflatedSize = Uncompressed.size();
441 Header.Size = Header.EntriesOffset + CompressedBuffer.size();
442
443 SmallString<0> Data;
444 Data.reserve(N: alignTo(Value: Header.Size, Align: getAlignment()));
445 raw_svector_ostream OS(Data);
446 OS << StringRef(reinterpret_cast<const char *>(&Header),
447 Header.EntriesOffset);
448 OS << toStringRef(Input: CompressedBuffer);
449 assert(Header.Size == OS.tell() && "Size mismatch");
450 OS.write_zeros(NumZeros: alignTo(Value: Header.Size, Align: getAlignment()) - Header.Size);
451 return Data;
452}
453
454Error object::extractOffloadBinaries(MemoryBufferRef Buffer,
455 SmallVectorImpl<OffloadFile> &Binaries) {
456 file_magic Type = identify_magic(magic: Buffer.getBuffer());
457 switch (Type) {
458 case file_magic::bitcode:
459 return extractFromBitcode(Buffer, Binaries);
460 case file_magic::elf_relocatable:
461 case file_magic::elf_executable:
462 case file_magic::elf_shared_object:
463 case file_magic::coff_object: {
464 Expected<std::unique_ptr<ObjectFile>> ObjFile =
465 ObjectFile::createObjectFile(Object: Buffer, Type);
466 if (!ObjFile)
467 return ObjFile.takeError();
468 return extractFromObject(Obj: *ObjFile->get(), Binaries);
469 }
470 case file_magic::archive: {
471 Expected<std::unique_ptr<llvm::object::Archive>> LibFile =
472 object::Archive::create(Source: Buffer);
473 if (!LibFile)
474 return LibFile.takeError();
475 return extractFromArchive(Library: *LibFile->get(), Binaries);
476 }
477 case file_magic::offload_binary:
478 return extractOffloadFiles(Contents: Buffer, Binaries);
479 default:
480 return Error::success();
481 }
482}
483
484OffloadKind object::getOffloadKind(StringRef Name) {
485 return llvm::StringSwitch<OffloadKind>(Name)
486 .Case(S: "openmp", Value: OFK_OpenMP)
487 .Case(S: "cuda", Value: OFK_Cuda)
488 .Case(S: "hip", Value: OFK_HIP)
489 .Case(S: "sycl", Value: OFK_SYCL)
490 .Case(S: "openacc", Value: OFK_OpenACC)
491 .Default(Value: OFK_None);
492}
493
494StringRef object::getOffloadKindName(OffloadKind Kind) {
495 switch (Kind) {
496 case OFK_OpenMP:
497 return "openmp";
498 case OFK_Cuda:
499 return "cuda";
500 case OFK_HIP:
501 return "hip";
502 case OFK_SYCL:
503 return "sycl";
504 case OFK_OpenACC:
505 return "openacc";
506 default:
507 return "none";
508 }
509}
510
511ImageKind object::getImageKind(StringRef Name) {
512 return llvm::StringSwitch<ImageKind>(Name)
513 .Case(S: "o", Value: IMG_Object)
514 .Case(S: "bc", Value: IMG_Bitcode)
515 .Case(S: "cubin", Value: IMG_Cubin)
516 .Case(S: "fatbin", Value: IMG_Fatbinary)
517 .Case(S: "s", Value: IMG_PTX)
518 .Case(S: "spv", Value: IMG_SPIRV)
519 .Default(Value: IMG_None);
520}
521
522StringRef object::getImageKindName(ImageKind Kind) {
523 switch (Kind) {
524 case IMG_Object:
525 return "o";
526 case IMG_Bitcode:
527 return "bc";
528 case IMG_Cubin:
529 return "cubin";
530 case IMG_Fatbinary:
531 return "fatbin";
532 case IMG_PTX:
533 return "s";
534 case IMG_SPIRV:
535 return "spv";
536 default:
537 return "";
538 }
539}
540
541bool object::areTargetsEquivalent(const OffloadFile::TargetID &LHS,
542 const OffloadFile::TargetID &RHS) {
543 llvm::Triple LHSTT(LHS.first);
544 llvm::Triple RHSTT(RHS.first);
545
546 // Check for logical AMDGPU target-id equivalence.
547 if (LHSTT.isAMDGPU()) {
548 AMDGPU::TargetID LHSID(LHSTT, LHS.second);
549 AMDGPU::TargetID RHSID(RHSTT, RHS.second);
550 return LHSID.isEquivalent(Other: RHSID);
551 }
552
553 // For other targets the triples must be compatible and the arch must match.
554 return LHSTT.isCompatibleWith(Other: RHSTT) && LHS.second == RHS.second;
555}
556
557bool object::areTargetsCompatible(const OffloadFile::TargetID &Provided,
558 const OffloadFile::TargetID &Requested) {
559 llvm::Triple ProvidedTT(Provided.first);
560 llvm::Triple RequestedTT(Requested.first);
561
562 // The AMDGPU target requires target-id aware checks (base processor plus
563 // xnack/sramecc features).
564 if (ProvidedTT.isAMDGPU()) {
565 AMDGPU::TargetID ProvidedID(ProvidedTT, Provided.second);
566 AMDGPU::TargetID RequestedID(RequestedTT, Requested.second);
567 return ProvidedID.providesFor(Other: RequestedID);
568 }
569
570 // For other targets the triples must be compatible.
571 if (!ProvidedTT.isCompatibleWith(Other: RequestedTT))
572 return false;
573
574 // If the architecture is "generic" we assume it is always compatible.
575 if (Provided.second == "generic" || Requested.second == "generic")
576 return true;
577
578 return Provided.second == Requested.second;
579}
580