1//===----------------------------------------------------------------------===//
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#include "clang/Basic/OffloadArch.h"
9
10#include "llvm/ADT/SmallVector.h"
11#include "llvm/ADT/StringRef.h"
12#include "llvm/TargetParser/AMDGPUTargetParser.h"
13#include "llvm/TargetParser/IntelGPUTargetParser.h"
14#include "llvm/TargetParser/NVPTXTargetParser.h"
15#include "llvm/TargetParser/Triple.h"
16#include <cassert>
17
18namespace clang {
19
20OffloadArch OffloadArch::CudaDefault() {
21 return getNVPTX(K: llvm::NVPTX::parseArch(CPU: "sm_52"));
22}
23
24OffloadArch OffloadArch::HIPDefault() {
25 return getAMDGPU(K: llvm::AMDGPU::parseArchAMDGCN(CPU: "gfx906"));
26}
27
28OffloadArch OffloadArch::getIntelIGCA(llvm::IntelGPU::IGCATarget T) {
29 assert(T.isValid() && "T is not a valid IGCA target");
30 return {TargetArch::IntelIGCA, T.pack()};
31}
32
33llvm::IntelGPU::IGCATarget OffloadArch::igcaTarget() const {
34 assert(isIntelIGCA() && "cannot get IGCA target from a non-IGCA OffloadArch");
35 return llvm::IntelGPU::IGCATarget::unpack(V: Kind);
36}
37
38const char *OffloadArchToString(OffloadArch A) {
39 switch (A.targetArch()) {
40 case OffloadArch::TargetArch::Unused:
41 return "";
42 case OffloadArch::TargetArch::Unknown:
43 return "unknown";
44 case OffloadArch::TargetArch::NVPTX:
45 return llvm::NVPTX::getArchName(Kind: A.nvptxKind()).data();
46 case OffloadArch::TargetArch::AMDGPU:
47 return llvm::AMDGPU::getArchNameAMDGCN(AK: A.amdgpuKind()).data();
48 case OffloadArch::TargetArch::AMDGCNSPIRV:
49 return "amdgcnspirv";
50 case OffloadArch::TargetArch::IntelCPU:
51 return "graniterapids";
52 case OffloadArch::TargetArch::IntelGPU:
53 return llvm::IntelGPU::getArchName(Kind: A.intelGPUKind()).data();
54 case OffloadArch::TargetArch::IntelIGCA:
55 return llvm::IntelGPU::getIGCATargetName(Target: A.igcaTarget()).data();
56 case OffloadArch::TargetArch::Generic:
57 return "generic";
58 }
59 return "unknown";
60}
61
62const char *OffloadArchToVirtualArchString(OffloadArch A) {
63 switch (A.targetArch()) {
64 case OffloadArch::TargetArch::NVPTX:
65 return llvm::NVPTX::getVirtualArch(Kind: A.nvptxKind()).data();
66 case OffloadArch::TargetArch::AMDGPU:
67 case OffloadArch::TargetArch::AMDGCNSPIRV:
68 return "compute_amdgcn";
69 case OffloadArch::TargetArch::Unknown:
70 return "unknown";
71 case OffloadArch::TargetArch::IntelIGCA:
72 return llvm::IntelGPU::getIGCATargetName(Target: A.igcaTarget()).data();
73 case OffloadArch::TargetArch::Unused:
74 case OffloadArch::TargetArch::IntelCPU:
75 case OffloadArch::TargetArch::IntelGPU:
76 case OffloadArch::TargetArch::Generic:
77 return "";
78 }
79 return "unknown";
80}
81
82OffloadArch StringToOffloadArch(llvm::StringRef S) {
83 // The empty string denotes the "unused" architecture.
84 if (S.empty())
85 return OffloadArch::getUnused();
86
87 // Non-GPU-table pseudo/sentinel architectures.
88 if (S == "amdgcnspirv")
89 return OffloadArch::getAMDGCNSPIRV();
90 if (S == "generic")
91 return OffloadArch::getGeneric();
92 // Intel CPU offload has a single processor and no TargetParser list.
93 if (S == "graniterapids")
94 return OffloadArch::getIntelCPU();
95
96 // Otherwise defer to the vendor TargetParser GPU lists.
97 if (llvm::NVPTX::GPUKind NV = llvm::NVPTX::parseArch(CPU: S))
98 return OffloadArch::getNVPTX(K: NV);
99 if (llvm::AMDGPU::GPUKind AK = llvm::AMDGPU::parseArchAMDGCN(CPU: S))
100 return OffloadArch::getAMDGPU(K: AK);
101 if (llvm::IntelGPU::GPUKind IK = llvm::IntelGPU::parseArch(Name: S))
102 return OffloadArch::getIntelGPU(K: IK);
103 if (llvm::IntelGPU::IGCATarget IT = llvm::IntelGPU::parseIGCATarget(MaybeTarget: S))
104 return OffloadArch::getIntelIGCA(T: IT);
105 return OffloadArch::getUnknown();
106}
107
108OffloadArch getSubArchOffloadArch(llvm::Triple::SubArchType SubArch) {
109 llvm::AMDGPU::GPUKind AK = llvm::AMDGPU::getGPUKindFromSubArch(SubArch);
110 if (AK == llvm::AMDGPU::GK_NONE)
111 return OffloadArch::getUnknown();
112 return OffloadArch::getAMDGPU(K: AK);
113}
114
115llvm::Triple::SubArchType getOffloadArchSubArch(OffloadArch ID) {
116 if (!ID.isAMDGPU())
117 return llvm::Triple::NoSubArch;
118 return llvm::AMDGPU::getSubArch(AK: ID.amdgpuKind());
119}
120
121llvm::Triple OffloadArchToTriple(const llvm::Triple &DefaultToolchainTriple,
122 OffloadArch ID) {
123 if (ID.isAMDGCNSPIRV())
124 return llvm::Triple(llvm::Triple::spirv64, llvm::Triple::NoSubArch,
125 llvm::Triple::AMD, llvm::Triple::AMDHSA);
126
127 if (ID.isNVPTX()) {
128 llvm::Triple::ArchType Arch = DefaultToolchainTriple.isArch64Bit()
129 ? llvm::Triple::nvptx64
130 : llvm::Triple::nvptx;
131 return llvm::Triple(Arch, llvm::Triple::NoSubArch, llvm::Triple::NVIDIA,
132 llvm::Triple::CUDA);
133 }
134
135 if (ID.isAMDGPU())
136 return llvm::Triple(llvm::Triple::amdgpu, llvm::Triple::NoSubArch,
137 llvm::Triple::AMD, llvm::Triple::AMDHSA);
138
139 return {};
140}
141
142} // namespace clang
143