| 1 |
//===--- AMDGPU.cpp - Implement AMDGPU target feature support -------------===// |
| 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 |
// This file implements AMDGPU TargetInfo objects. |
| 10 |
// |
| 11 |
//===----------------------------------------------------------------------===// |
| 12 |
|
| 13 |
#include "AMDGPU.h" |
| 14 |
#include "clang/Basic/Builtins.h" |
| 15 |
#include "clang/Basic/CodeGenOptions.h" |
| 16 |
#include "clang/Basic/Diagnostic.h" |
| 17 |
#include "clang/Basic/LangOptions.h" |
| 18 |
#include "clang/Basic/MacroBuilder.h" |
| 19 |
#include "clang/Basic/TargetBuiltins.h" |
| 20 |
|
| 21 |
using namespace clang; |
| 22 |
using namespace clang::targets; |
| 23 |
|
| 24 |
namespace clang { |
| 25 |
namespace targets { |
| 26 |
|
| 27 |
// If you edit the description strings, make sure you update |
| 28 |
// getPointerWidthV(). |
| 29 |
|
| 30 |
static const char *const DataLayoutStringR600 = |
| 31 |
"e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128" |
| 32 |
"-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1"; |
| 33 |
|
| 34 |
static const char *const DataLayoutStringAMDGCN = |
| 35 |
"e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32" |
| 36 |
"-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128" |
| 37 |
"-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1" |
| 38 |
"-ni:7"; |
| 39 |
|
| 40 |
const LangASMap AMDGPUTargetInfo::AMDGPUDefIsGenMap = { |
| 41 |
Generic, // Default |
| 42 |
Global, // opencl_global |
| 43 |
Local, // opencl_local |
| 44 |
Constant, // opencl_constant |
| 45 |
Private, // opencl_private |
| 46 |
Generic, // opencl_generic |
| 47 |
Global, // opencl_global_device |
| 48 |
Global, // opencl_global_host |
| 49 |
Global, // cuda_device |
| 50 |
Constant, // cuda_constant |
| 51 |
Local, // cuda_shared |
| 52 |
Global, // sycl_global |
| 53 |
Global, // sycl_global_device |
| 54 |
Global, // sycl_global_host |
| 55 |
Local, // sycl_local |
| 56 |
Private, // sycl_private |
| 57 |
Generic, // ptr32_sptr |
| 58 |
Generic, // ptr32_uptr |
| 59 |
Generic, // ptr64 |
| 60 |
Generic, // hlsl_groupshared |
| 61 |
}; |
| 62 |
|
| 63 |
const LangASMap AMDGPUTargetInfo::AMDGPUDefIsPrivMap = { |
| 64 |
Private, // Default |
| 65 |
Global, // opencl_global |
| 66 |
Local, // opencl_local |
| 67 |
Constant, // opencl_constant |
| 68 |
Private, // opencl_private |
| 69 |
Generic, // opencl_generic |
| 70 |
Global, // opencl_global_device |
| 71 |
Global, // opencl_global_host |
| 72 |
Global, // cuda_device |
| 73 |
Constant, // cuda_constant |
| 74 |
Local, // cuda_shared |
| 75 |
// SYCL address space values for this map are dummy |
| 76 |
Generic, // sycl_global |
| 77 |
Generic, // sycl_global_device |
| 78 |
Generic, // sycl_global_host |
| 79 |
Generic, // sycl_local |
| 80 |
Generic, // sycl_private |
| 81 |
Generic, // ptr32_sptr |
| 82 |
Generic, // ptr32_uptr |
| 83 |
Generic, // ptr64 |
| 84 |
Generic, // hlsl_groupshared |
| 85 |
|
| 86 |
}; |
| 87 |
} // namespace targets |
| 88 |
} // namespace clang |
| 89 |
|
| 90 |
static constexpr Builtin::Info BuiltinInfo[] = { |
| 91 |
#define BUILTIN(ID, TYPE, ATTRS) \ |
| 92 |
{#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, |
| 93 |
#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \ |
| 94 |
{#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, |
| 95 |
#include "clang/Basic/BuiltinsAMDGPU.def" |
| 96 |
}; |
| 97 |
|
| 98 |
const char *const AMDGPUTargetInfo::GCCRegNames[] = { |
| 99 |
"v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", |
| 100 |
"v9", "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", |
| 101 |
"v18", "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26", |
| 102 |
"v27", "v28", "v29", "v30", "v31", "v32", "v33", "v34", "v35", |
| 103 |
"v36", "v37", "v38", "v39", "v40", "v41", "v42", "v43", "v44", |
| 104 |
"v45", "v46", "v47", "v48", "v49", "v50", "v51", "v52", "v53", |
| 105 |
"v54", "v55", "v56", "v57", "v58", "v59", "v60", "v61", "v62", |
| 106 |
"v63", "v64", "v65", "v66", "v67", "v68", "v69", "v70", "v71", |
| 107 |
"v72", "v73", "v74", "v75", "v76", "v77", "v78", "v79", "v80", |
| 108 |
"v81", "v82", "v83", "v84", "v85", "v86", "v87", "v88", "v89", |
| 109 |
"v90", "v91", "v92", "v93", "v94", "v95", "v96", "v97", "v98", |
| 110 |
"v99", "v100", "v101", "v102", "v103", "v104", "v105", "v106", "v107", |
| 111 |
"v108", "v109", "v110", "v111", "v112", "v113", "v114", "v115", "v116", |
| 112 |
"v117", "v118", "v119", "v120", "v121", "v122", "v123", "v124", "v125", |
| 113 |
"v126", "v127", "v128", "v129", "v130", "v131", "v132", "v133", "v134", |
| 114 |
"v135", "v136", "v137", "v138", "v139", "v140", "v141", "v142", "v143", |
| 115 |
"v144", "v145", "v146", "v147", "v148", "v149", "v150", "v151", "v152", |
| 116 |
"v153", "v154", "v155", "v156", "v157", "v158", "v159", "v160", "v161", |
| 117 |
"v162", "v163", "v164", "v165", "v166", "v167", "v168", "v169", "v170", |
| 118 |
"v171", "v172", "v173", "v174", "v175", "v176", "v177", "v178", "v179", |
| 119 |
"v180", "v181", "v182", "v183", "v184", "v185", "v186", "v187", "v188", |
| 120 |
"v189", "v190", "v191", "v192", "v193", "v194", "v195", "v196", "v197", |
| 121 |
"v198", "v199", "v200", "v201", "v202", "v203", "v204", "v205", "v206", |
| 122 |
"v207", "v208", "v209", "v210", "v211", "v212", "v213", "v214", "v215", |
| 123 |
"v216", "v217", "v218", "v219", "v220", "v221", "v222", "v223", "v224", |
| 124 |
"v225", "v226", "v227", "v228", "v229", "v230", "v231", "v232", "v233", |
| 125 |
"v234", "v235", "v236", "v237", "v238", "v239", "v240", "v241", "v242", |
| 126 |
"v243", "v244", "v245", "v246", "v247", "v248", "v249", "v250", "v251", |
| 127 |
"v252", "v253", "v254", "v255", "s0", "s1", "s2", "s3", "s4", |
| 128 |
"s5", "s6", "s7", "s8", "s9", "s10", "s11", "s12", "s13", |
| 129 |
"s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21", "s22", |
| 130 |
"s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", |
| 131 |
"s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39", "s40", |
| 132 |
"s41", "s42", "s43", "s44", "s45", "s46", "s47", "s48", "s49", |
| 133 |
"s50", "s51", "s52", "s53", "s54", "s55", "s56", "s57", "s58", |
| 134 |
"s59", "s60", "s61", "s62", "s63", "s64", "s65", "s66", "s67", |
| 135 |
"s68", "s69", "s70", "s71", "s72", "s73", "s74", "s75", "s76", |
| 136 |
"s77", "s78", "s79", "s80", "s81", "s82", "s83", "s84", "s85", |
| 137 |
"s86", "s87", "s88", "s89", "s90", "s91", "s92", "s93", "s94", |
| 138 |
"s95", "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103", |
| 139 |
"s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111", "s112", |
| 140 |
"s113", "s114", "s115", "s116", "s117", "s118", "s119", "s120", "s121", |
| 141 |
"s122", "s123", "s124", "s125", "s126", "s127", "exec", "vcc", "scc", |
| 142 |
"m0", "flat_scratch", "exec_lo", "exec_hi", "vcc_lo", "vcc_hi", |
| 143 |
"flat_scratch_lo", "flat_scratch_hi", |
| 144 |
"a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", |
| 145 |
"a9", "a10", "a11", "a12", "a13", "a14", "a15", "a16", "a17", |
| 146 |
"a18", "a19", "a20", "a21", "a22", "a23", "a24", "a25", "a26", |
| 147 |
"a27", "a28", "a29", "a30", "a31", "a32", "a33", "a34", "a35", |
| 148 |
"a36", "a37", "a38", "a39", "a40", "a41", "a42", "a43", "a44", |
| 149 |
"a45", "a46", "a47", "a48", "a49", "a50", "a51", "a52", "a53", |
| 150 |
"a54", "a55", "a56", "a57", "a58", "a59", "a60", "a61", "a62", |
| 151 |
"a63", "a64", "a65", "a66", "a67", "a68", "a69", "a70", "a71", |
| 152 |
"a72", "a73", "a74", "a75", "a76", "a77", "a78", "a79", "a80", |
| 153 |
"a81", "a82", "a83", "a84", "a85", "a86", "a87", "a88", "a89", |
| 154 |
"a90", "a91", "a92", "a93", "a94", "a95", "a96", "a97", "a98", |
| 155 |
"a99", "a100", "a101", "a102", "a103", "a104", "a105", "a106", "a107", |
| 156 |
"a108", "a109", "a110", "a111", "a112", "a113", "a114", "a115", "a116", |
| 157 |
"a117", "a118", "a119", "a120", "a121", "a122", "a123", "a124", "a125", |
| 158 |
"a126", "a127", "a128", "a129", "a130", "a131", "a132", "a133", "a134", |
| 159 |
"a135", "a136", "a137", "a138", "a139", "a140", "a141", "a142", "a143", |
| 160 |
"a144", "a145", "a146", "a147", "a148", "a149", "a150", "a151", "a152", |
| 161 |
"a153", "a154", "a155", "a156", "a157", "a158", "a159", "a160", "a161", |
| 162 |
"a162", "a163", "a164", "a165", "a166", "a167", "a168", "a169", "a170", |
| 163 |
"a171", "a172", "a173", "a174", "a175", "a176", "a177", "a178", "a179", |
| 164 |
"a180", "a181", "a182", "a183", "a184", "a185", "a186", "a187", "a188", |
| 165 |
"a189", "a190", "a191", "a192", "a193", "a194", "a195", "a196", "a197", |
| 166 |
"a198", "a199", "a200", "a201", "a202", "a203", "a204", "a205", "a206", |
| 167 |
"a207", "a208", "a209", "a210", "a211", "a212", "a213", "a214", "a215", |
| 168 |
"a216", "a217", "a218", "a219", "a220", "a221", "a222", "a223", "a224", |
| 169 |
"a225", "a226", "a227", "a228", "a229", "a230", "a231", "a232", "a233", |
| 170 |
"a234", "a235", "a236", "a237", "a238", "a239", "a240", "a241", "a242", |
| 171 |
"a243", "a244", "a245", "a246", "a247", "a248", "a249", "a250", "a251", |
| 172 |
"a252", "a253", "a254", "a255" |
| 173 |
}; |
| 174 |
|
| 175 |
ArrayRef<const char *> AMDGPUTargetInfo::getGCCRegNames() const { |
| 176 |
return llvm::ArrayRef(GCCRegNames); |
| 177 |
} |
| 178 |
|
| 179 |
bool AMDGPUTargetInfo::initFeatureMap( |
| 180 |
llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, |
| 181 |
const std::vector<std::string> &FeatureVec) const { |
| 182 |
const bool IsNullCPU = CPU.empty(); |
| 183 |
bool IsWave32Capable = false; |
| 184 |
|
| 185 |
using namespace llvm::AMDGPU; |
| 186 |
|
| 187 |
// XXX - What does the member GPU mean if device name string passed here? |
| 188 |
if (isAMDGCN(getTriple())) { |
| 189 |
switch (llvm::AMDGPU::parseArchAMDGCN(CPU)) { |
| 190 |
case GK_GFX1103: |
| 191 |
case GK_GFX1102: |
| 192 |
case GK_GFX1101: |
| 193 |
case GK_GFX1100: |
| 194 |
IsWave32Capable = true; |
| 195 |
Features["ci-insts"] = true; |
| 196 |
Features["dot5-insts"] = true; |
| 197 |
Features["dot7-insts"] = true; |
| 198 |
Features["dot8-insts"] = true; |
| 199 |
Features["dot9-insts"] = true; |
| 200 |
Features["dl-insts"] = true; |
| 201 |
Features["16-bit-insts"] = true; |
| 202 |
Features["dpp"] = true; |
| 203 |
Features["gfx8-insts"] = true; |
| 204 |
Features["gfx9-insts"] = true; |
| 205 |
Features["gfx10-insts"] = true; |
| 206 |
Features["gfx10-3-insts"] = true; |
| 207 |
Features["gfx11-insts"] = true; |
| 208 |
break; |
| 209 |
case GK_GFX1036: |
| 210 |
case GK_GFX1035: |
| 211 |
case GK_GFX1034: |
| 212 |
case GK_GFX1033: |
| 213 |
case GK_GFX1032: |
| 214 |
case GK_GFX1031: |
| 215 |
case GK_GFX1030: |
| 216 |
IsWave32Capable = true; |
| 217 |
Features["ci-insts"] = true; |
| 218 |
Features["dot1-insts"] = true; |
| 219 |
Features["dot2-insts"] = true; |
| 220 |
Features["dot5-insts"] = true; |
| 221 |
Features["dot6-insts"] = true; |
| 222 |
Features["dot7-insts"] = true; |
| 223 |
Features["dl-insts"] = true; |
| 224 |
Features["16-bit-insts"] = true; |
| 225 |
Features["dpp"] = true; |
| 226 |
Features["gfx8-insts"] = true; |
| 227 |
Features["gfx9-insts"] = true; |
| 228 |
Features["gfx10-insts"] = true; |
| 229 |
Features["gfx10-3-insts"] = true; |
| 230 |
Features["s-memrealtime"] = true; |
| 231 |
Features["s-memtime-inst"] = true; |
| 232 |
break; |
| 233 |
case GK_GFX1012: |
| 234 |
case GK_GFX1011: |
| 235 |
Features["dot1-insts"] = true; |
| 236 |
Features["dot2-insts"] = true; |
| 237 |
Features["dot5-insts"] = true; |
| 238 |
Features["dot6-insts"] = true; |
| 239 |
Features["dot7-insts"] = true; |
| 240 |
[[fallthrough]]; |
| 241 |
case GK_GFX1013: |
| 242 |
case GK_GFX1010: |
| 243 |
IsWave32Capable = true; |
| 244 |
Features["dl-insts"] = true; |
| 245 |
Features["ci-insts"] = true; |
| 246 |
Features["16-bit-insts"] = true; |
| 247 |
Features["dpp"] = true; |
| 248 |
Features["gfx8-insts"] = true; |
| 249 |
Features["gfx9-insts"] = true; |
| 250 |
Features["gfx10-insts"] = true; |
| 251 |
Features["s-memrealtime"] = true; |
| 252 |
Features["s-memtime-inst"] = true; |
| 253 |
break; |
| 254 |
case GK_GFX940: |
| 255 |
Features["gfx940-insts"] = true; |
| 256 |
Features["fp8-insts"] = true; |
| 257 |
[[fallthrough]]; |
| 258 |
case GK_GFX90A: |
| 259 |
Features["gfx90a-insts"] = true; |
| 260 |
[[fallthrough]]; |
| 261 |
case GK_GFX908: |
| 262 |
Features["dot3-insts"] = true; |
| 263 |
Features["dot4-insts"] = true; |
| 264 |
Features["dot5-insts"] = true; |
| 265 |
Features["dot6-insts"] = true; |
| 266 |
Features["mai-insts"] = true; |
| 267 |
[[fallthrough]]; |
| 268 |
case GK_GFX906: |
| 269 |
Features["dl-insts"] = true; |
| 270 |
Features["dot1-insts"] = true; |
| 271 |
Features["dot2-insts"] = true; |
| 272 |
Features["dot7-insts"] = true; |
| 273 |
[[fallthrough]]; |
| 274 |
case GK_GFX90C: |
| 275 |
case GK_GFX909: |
| 276 |
case GK_GFX904: |
| 277 |
case GK_GFX902: |
| 278 |
case GK_GFX900: |
| 279 |
Features["gfx9-insts"] = true; |
| 280 |
[[fallthrough]]; |
| 281 |
case GK_GFX810: |
| 282 |
case GK_GFX805: |
| 283 |
case GK_GFX803: |
| 284 |
case GK_GFX802: |
| 285 |
case GK_GFX801: |
| 286 |
Features["gfx8-insts"] = true; |
| 287 |
Features["16-bit-insts"] = true; |
| 288 |
Features["dpp"] = true; |
| 289 |
Features["s-memrealtime"] = true; |
| 290 |
[[fallthrough]]; |
| 291 |
case GK_GFX705: |
| 292 |
case GK_GFX704: |
| 293 |
case GK_GFX703: |
| 294 |
case GK_GFX702: |
| 295 |
case GK_GFX701: |
| 296 |
case GK_GFX700: |
| 297 |
Features["ci-insts"] = true; |
| 298 |
[[fallthrough]]; |
| 299 |
case GK_GFX602: |
| 300 |
case GK_GFX601: |
| 301 |
case GK_GFX600: |
| 302 |
Features["s-memtime-inst"] = true; |
| 303 |
break; |
| 304 |
case GK_NONE: |
| 305 |
break; |
| 306 |
default: |
| 307 |
llvm_unreachable("Unhandled GPU!"); |
| 308 |
} |
| 309 |
} else { |
| 310 |
if (CPU.empty()) |
| 311 |
CPU = "r600"; |
| 312 |
|
| 313 |
switch (llvm::AMDGPU::parseArchR600(CPU)) { |
| 314 |
case GK_CAYMAN: |
| 315 |
case GK_CYPRESS: |
| 316 |
case GK_RV770: |
| 317 |
case GK_RV670: |
| 318 |
// TODO: Add fp64 when implemented. |
| 319 |
break; |
| 320 |
case GK_TURKS: |
| 321 |
case GK_CAICOS: |
| 322 |
case GK_BARTS: |
| 323 |
case GK_SUMO: |
| 324 |
case GK_REDWOOD: |
| 325 |
case GK_JUNIPER: |
| 326 |
case GK_CEDAR: |
| 327 |
case GK_RV730: |
| 328 |
case GK_RV710: |
| 329 |
case GK_RS880: |
| 330 |
case GK_R630: |
| 331 |
case GK_R600: |
| 332 |
break; |
| 333 |
default: |
| 334 |
llvm_unreachable("Unhandled GPU!"); |
| 335 |
} |
| 336 |
} |
| 337 |
|
| 338 |
if (!TargetInfo::initFeatureMap(Features, Diags, CPU, FeatureVec)) |
| 339 |
return false; |
| 340 |
|
| 341 |
// FIXME: Not diagnosing wavefrontsize32 on wave64 only targets. |
| 342 |
const bool HaveWave32 = |
| 343 |
(IsWave32Capable || IsNullCPU) && Features.count("wavefrontsize32"); |
| 344 |
const bool HaveWave64 = Features.count("wavefrontsize64"); |
| 345 |
|
| 346 |
// TODO: Should move this logic into TargetParser |
| 347 |
if (HaveWave32 && HaveWave64) { |
| 348 |
Diags.Report(diag::err_invalid_feature_combination) |
| 349 |
<< "'wavefrontsize32' and 'wavefrontsize64' are mutually exclusive"; |
| 350 |
return false; |
| 351 |
} |
| 352 |
|
| 353 |
// Don't assume any wavesize with an unknown subtarget. |
| 354 |
if (!IsNullCPU) { |
| 355 |
// Default to wave32 if available, or wave64 if not |
| 356 |
if (!HaveWave32 && !HaveWave64) { |
| 357 |
StringRef DefaultWaveSizeFeature = |
| 358 |
IsWave32Capable ? "wavefrontsize32" : "wavefrontsize64"; |
| 359 |
Features.insert(std::make_pair(DefaultWaveSizeFeature, true)); |
| 360 |
} |
| 361 |
} |
| 362 |
|
| 363 |
return true; |
| 364 |
} |
| 365 |
|
| 366 |
void AMDGPUTargetInfo::fillValidCPUList( |
| 367 |
SmallVectorImpl<StringRef> &Values) const { |
| 368 |
if (isAMDGCN(getTriple())) |
| 369 |
llvm::AMDGPU::fillValidArchListAMDGCN(Values); |
| 370 |
else |
| 371 |
llvm::AMDGPU::fillValidArchListR600(Values); |
| 372 |
} |
| 373 |
|
| 374 |
void AMDGPUTargetInfo::setAddressSpaceMap(bool DefaultIsPrivate) { |
| 375 |
AddrSpaceMap = DefaultIsPrivate ? &AMDGPUDefIsPrivMap : &AMDGPUDefIsGenMap; |
| 376 |
} |
| 377 |
|
| 378 |
AMDGPUTargetInfo::AMDGPUTargetInfo(const llvm::Triple &Triple, |
| 379 |
const TargetOptions &Opts) |
| 380 |
: TargetInfo(Triple), |
| 381 |
GPUKind(isAMDGCN(Triple) ? |
| 382 |
llvm::AMDGPU::parseArchAMDGCN(Opts.CPU) : |
| 383 |
llvm::AMDGPU::parseArchR600(Opts.CPU)), |
| 384 |
GPUFeatures(isAMDGCN(Triple) ? |
| 385 |
llvm::AMDGPU::getArchAttrAMDGCN(GPUKind) : |
| 386 |
llvm::AMDGPU::getArchAttrR600(GPUKind)) { |
| 387 |
resetDataLayout(isAMDGCN(getTriple()) ? DataLayoutStringAMDGCN |
| 388 |
: DataLayoutStringR600); |
| 389 |
|
| 390 |
setAddressSpaceMap(Triple.getOS() == llvm::Triple::Mesa3D || |
| 391 |
!isAMDGCN(Triple)); |
| 392 |
UseAddrSpaceMapMangling = true; |
| 393 |
|
| 394 |
if (isAMDGCN(Triple)) { |
| 395 |
// __bf16 is always available as a load/store only type on AMDGCN. |
| 396 |
BFloat16Width = BFloat16Align = 16; |
| 397 |
BFloat16Format = &llvm::APFloat::BFloat(); |
| 398 |
} |
| 399 |
|
| 400 |
HasLegalHalfType = true; |
| 401 |
HasFloat16 = true; |
| 402 |
WavefrontSize = GPUFeatures & llvm::AMDGPU::FEATURE_WAVE32 ? 32 : 64; |
| 403 |
AllowAMDGPUUnsafeFPAtomics = Opts.AllowAMDGPUUnsafeFPAtomics; |
| 404 |
|
| 405 |
// Set pointer width and alignment for the generic address space. |
| 406 |
PointerWidth = PointerAlign = getPointerWidthV(LangAS::Default); |
| 407 |
if (getMaxPointerWidth() == 64) { |
| 408 |
LongWidth = LongAlign = 64; |
| 409 |
SizeType = UnsignedLong; |
| 410 |
PtrDiffType = SignedLong; |
| 411 |
IntPtrType = SignedLong; |
| 412 |
} |
| 413 |
|
| 414 |
MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; |
| 415 |
} |
| 416 |
|
| 417 |
void AMDGPUTargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) { |
| 418 |
TargetInfo::adjust(Diags, Opts); |
| 419 |
// ToDo: There are still a few places using default address space as private |
| 420 |
// address space in OpenCL, which needs to be cleaned up, then Opts.OpenCL |
| 421 |
// can be removed from the following line. |
| 422 |
setAddressSpaceMap(/*DefaultIsPrivate=*/Opts.OpenCL || |
| 423 |
!isAMDGCN(getTriple())); |
| 424 |
} |
| 425 |
|
| 426 |
ArrayRef<Builtin::Info> AMDGPUTargetInfo::getTargetBuiltins() const { |
| 427 |
return llvm::ArrayRef(BuiltinInfo, |
| 428 |
clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin); |
| 429 |
} |
| 430 |
|
| 431 |
void AMDGPUTargetInfo::getTargetDefines(const LangOptions &Opts, |
| 432 |
MacroBuilder &Builder) const { |
| 433 |
Builder.defineMacro("__AMD__"); |
| 434 |
Builder.defineMacro("__AMDGPU__"); |
| 435 |
|
| 436 |
if (isAMDGCN(getTriple())) |
| 437 |
Builder.defineMacro("__AMDGCN__"); |
| 438 |
else |
| 439 |
Builder.defineMacro("__R600__"); |
| 440 |
|
| 441 |
if (GPUKind != llvm::AMDGPU::GK_NONE) { |
| 442 |
StringRef CanonName = isAMDGCN(getTriple()) ? |
| 443 |
getArchNameAMDGCN(GPUKind) : getArchNameR600(GPUKind); |
| 444 |
Builder.defineMacro(Twine("__") + Twine(CanonName) + Twine("__")); |
| 445 |
// Emit macros for gfx family e.g. gfx906 -> __GFX9__, gfx1030 -> __GFX10___ |
| 446 |
if (isAMDGCN(getTriple())) { |
| 447 |
assert(CanonName.startswith("gfx") && "Invalid amdgcn canonical name"); |
| 448 |
Builder.defineMacro(Twine("__") + Twine(CanonName.drop_back(2).upper()) + |
| 449 |
Twine("__")); |
| 450 |
} |
| 451 |
if (isAMDGCN(getTriple())) { |
| 452 |
Builder.defineMacro("__amdgcn_processor__", |
| 453 |
Twine("\"") + Twine(CanonName) + Twine("\"")); |
| 454 |
Builder.defineMacro("__amdgcn_target_id__", |
| 455 |
Twine("\"") + Twine(*getTargetID()) + Twine("\"")); |
| 456 |
for (auto F : getAllPossibleTargetIDFeatures(getTriple(), CanonName)) { |
| 457 |
auto Loc = OffloadArchFeatures.find(F); |
| 458 |
if (Loc != OffloadArchFeatures.end()) { |
| 459 |
std::string NewF = F.str(); |
| 460 |
std::replace(NewF.begin(), NewF.end(), '-', '_'); |
| 461 |
Builder.defineMacro(Twine("__amdgcn_feature_") + Twine(NewF) + |
| 462 |
Twine("__"), |
| 463 |
Loc->second ? "1" : "0"); |
| 464 |
} |
| 465 |
} |
| 466 |
} |
| 467 |
} |
| 468 |
|
| 469 |
if (AllowAMDGPUUnsafeFPAtomics) |
| 470 |
Builder.defineMacro("__AMDGCN_UNSAFE_FP_ATOMICS__"); |
| 471 |
|
| 472 |
// TODO: __HAS_FMAF__, __HAS_LDEXPF__, __HAS_FP64__ are deprecated and will be |
| 473 |
// removed in the near future. |
| 474 |
if (hasFMAF()) |
| 475 |
Builder.defineMacro("__HAS_FMAF__"); |
| 476 |
if (hasFastFMAF()) |
| 477 |
Builder.defineMacro("FP_FAST_FMAF"); |
| 478 |
if (hasLDEXPF()) |
| 479 |
Builder.defineMacro("__HAS_LDEXPF__"); |
| 480 |
if (hasFP64()) |
| 481 |
Builder.defineMacro("__HAS_FP64__"); |
| 482 |
if (hasFastFMA()) |
| 483 |
Builder.defineMacro("FP_FAST_FMA"); |
| 484 |
|
| 485 |
Builder.defineMacro("__AMDGCN_WAVEFRONT_SIZE", Twine(WavefrontSize)); |
| 486 |
} |
| 487 |
|
| 488 |
void AMDGPUTargetInfo::setAuxTarget(const TargetInfo *Aux) { |
| 489 |
assert(HalfFormat == Aux->HalfFormat); |
| 490 |
assert(FloatFormat == Aux->FloatFormat); |
| 491 |
assert(DoubleFormat == Aux->DoubleFormat); |
| 492 |
|
| 493 |
// On x86_64 long double is 80-bit extended precision format, which is |
| 494 |
// not supported by AMDGPU. 128-bit floating point format is also not |
| 495 |
// supported by AMDGPU. Therefore keep its own format for these two types. |
| 496 |
auto SaveLongDoubleFormat = LongDoubleFormat; |
| 497 |
auto SaveFloat128Format = Float128Format; |
| 498 |
auto SaveLongDoubleWidth = LongDoubleWidth; |
| 499 |
auto SaveLongDoubleAlign = LongDoubleAlign; |
| 500 |
copyAuxTarget(Aux); |
| 501 |
LongDoubleFormat = SaveLongDoubleFormat; |
| 502 |
Float128Format = SaveFloat128Format; |
| 503 |
LongDoubleWidth = SaveLongDoubleWidth; |
| 504 |
LongDoubleAlign = SaveLongDoubleAlign; |
| 505 |
// For certain builtin types support on the host target, claim they are |
| 506 |
// support to pass the compilation of the host code during the device-side |
| 507 |
// compilation. |
| 508 |
// FIXME: As the side effect, we also accept `__float128` uses in the device |
| 509 |
// code. To rejct these builtin types supported in the host target but not in |
| 510 |
// the device target, one approach would support `device_builtin` attribute |
| 511 |
// so that we could tell the device builtin types from the host ones. The |
| 512 |
// also solves the different representations of the same builtin type, such |
| 513 |
// as `size_t` in the MSVC environment. |
| 514 |
if (Aux->hasFloat128Type()) { |
| 515 |
HasFloat128 = true; |
| 516 |
Float128Format = DoubleFormat; |
| 517 |
} |
| 518 |
} |