1 //===--- Targets.cpp - Implement 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 construction of a TargetInfo object from a 10 // target triple. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "Targets.h" 15 16 #include "Targets/AArch64.h" 17 #include "Targets/AMDGPU.h" 18 #include "Targets/ARC.h" 19 #include "Targets/ARM.h" 20 #include "Targets/AVR.h" 21 #include "Targets/BPF.h" 22 #include "Targets/CSKY.h" 23 #include "Targets/DirectX.h" 24 #include "Targets/Hexagon.h" 25 #include "Targets/Lanai.h" 26 #include "Targets/LoongArch.h" 27 #include "Targets/M68k.h" 28 #include "Targets/MSP430.h" 29 #include "Targets/Mips.h" 30 #include "Targets/NVPTX.h" 31 #include "Targets/OSTargets.h" 32 #include "Targets/PNaCl.h" 33 #include "Targets/PPC.h" 34 #include "Targets/RISCV.h" 35 #include "Targets/SPIR.h" 36 #include "Targets/Sparc.h" 37 #include "Targets/SystemZ.h" 38 #include "Targets/TCE.h" 39 #include "Targets/VE.h" 40 #include "Targets/WebAssembly.h" 41 #include "Targets/X86.h" 42 #include "Targets/XCore.h" 43 #include "Targets/Xtensa.h" 44 #include "clang/Basic/Diagnostic.h" 45 #include "clang/Basic/DiagnosticFrontend.h" 46 #include "llvm/ADT/StringExtras.h" 47 #include "llvm/TargetParser/Triple.h" 48 49 using namespace clang; 50 51 namespace clang { 52 namespace targets { 53 //===----------------------------------------------------------------------===// 54 // Common code shared among targets. 55 //===----------------------------------------------------------------------===// 56 57 /// DefineStd - Define a macro name and standard variants. For example if 58 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix" 59 /// when in GNU mode. 60 void DefineStd(MacroBuilder &Builder, StringRef MacroName, 61 const LangOptions &Opts) { 62 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace"); 63 64 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier 65 // in the user's namespace. 66 if (Opts.GNUMode) 67 Builder.defineMacro(MacroName); 68 69 // Define __unix. 70 Builder.defineMacro("__" + MacroName); 71 72 // Define __unix__. 73 Builder.defineMacro("__" + MacroName + "__"); 74 } 75 76 void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) { 77 Builder.defineMacro("__" + CPUName); 78 Builder.defineMacro("__" + CPUName + "__"); 79 if (Tuning) 80 Builder.defineMacro("__tune_" + CPUName + "__"); 81 } 82 83 void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) { 84 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang 85 // supports __declspec natively under -fdeclspec (also enabled with 86 // -fms-extensions), but we define a no-op __declspec macro anyway for 87 // pre-processor compatibility. 88 if (Opts.DeclSpecKeyword) 89 Builder.defineMacro("__declspec", "__declspec"); 90 else 91 Builder.defineMacro("__declspec(a)", "__attribute__((a))"); 92 93 if (!Opts.MicrosoftExt) { 94 // Provide macros for all the calling convention keywords. Provide both 95 // single and double underscore prefixed variants. These are available on 96 // x64 as well as x86, even though they have no effect. 97 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"}; 98 for (const char *CC : CCs) { 99 std::string GCCSpelling = "__attribute__((__"; 100 GCCSpelling += CC; 101 GCCSpelling += "__))"; 102 Builder.defineMacro(Twine("_") + CC, GCCSpelling); 103 Builder.defineMacro(Twine("__") + CC, GCCSpelling); 104 } 105 } 106 } 107 108 //===----------------------------------------------------------------------===// 109 // Driver code 110 //===----------------------------------------------------------------------===// 111 112 std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple, 113 const TargetOptions &Opts) { 114 llvm::Triple::OSType os = Triple.getOS(); 115 116 switch (Triple.getArch()) { 117 default: 118 return nullptr; 119 120 case llvm::Triple::arc: 121 return std::make_unique<ARCTargetInfo>(Triple, Opts); 122 123 case llvm::Triple::xcore: 124 return std::make_unique<XCoreTargetInfo>(Triple, Opts); 125 126 case llvm::Triple::hexagon: 127 if (os == llvm::Triple::Linux && 128 Triple.getEnvironment() == llvm::Triple::Musl) 129 return std::make_unique<LinuxTargetInfo<HexagonTargetInfo>>(Triple, Opts); 130 return std::make_unique<HexagonTargetInfo>(Triple, Opts); 131 132 case llvm::Triple::lanai: 133 return std::make_unique<LanaiTargetInfo>(Triple, Opts); 134 135 case llvm::Triple::aarch64_32: 136 if (Triple.isOSDarwin()) 137 return std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts); 138 else if (Triple.isAppleMachO()) 139 return std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts); 140 141 return nullptr; 142 case llvm::Triple::aarch64: 143 if (Triple.isOSDarwin()) 144 return std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts); 145 else if (Triple.isAppleMachO()) 146 return std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts); 147 148 switch (os) { 149 case llvm::Triple::FreeBSD: 150 return std::make_unique<FreeBSDTargetInfo<AArch64leTargetInfo>>(Triple, 151 Opts); 152 case llvm::Triple::Fuchsia: 153 return std::make_unique<FuchsiaTargetInfo<AArch64leTargetInfo>>(Triple, 154 Opts); 155 case llvm::Triple::Haiku: 156 return std::make_unique<HaikuTargetInfo<AArch64leTargetInfo>>(Triple, 157 Opts); 158 case llvm::Triple::Linux: 159 switch (Triple.getEnvironment()) { 160 default: 161 return std::make_unique<LinuxTargetInfo<AArch64leTargetInfo>>(Triple, 162 Opts); 163 case llvm::Triple::OpenHOS: 164 return std::make_unique<OHOSTargetInfo<AArch64leTargetInfo>>(Triple, 165 Opts); 166 } 167 case llvm::Triple::NetBSD: 168 return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple, 169 Opts); 170 case llvm::Triple::OpenBSD: 171 return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(Triple, 172 Opts); 173 case llvm::Triple::Win32: 174 switch (Triple.getEnvironment()) { 175 case llvm::Triple::GNU: 176 return std::make_unique<MinGWARM64TargetInfo>(Triple, Opts); 177 case llvm::Triple::MSVC: 178 default: // Assume MSVC for unknown environments 179 return std::make_unique<MicrosoftARM64TargetInfo>(Triple, Opts); 180 } 181 default: 182 return std::make_unique<AArch64leTargetInfo>(Triple, Opts); 183 } 184 185 case llvm::Triple::aarch64_be: 186 switch (os) { 187 case llvm::Triple::FreeBSD: 188 return std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(Triple, 189 Opts); 190 case llvm::Triple::Fuchsia: 191 return std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(Triple, 192 Opts); 193 case llvm::Triple::Linux: 194 return std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(Triple, 195 Opts); 196 case llvm::Triple::NetBSD: 197 return std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(Triple, 198 Opts); 199 default: 200 return std::make_unique<AArch64beTargetInfo>(Triple, Opts); 201 } 202 203 case llvm::Triple::arm: 204 case llvm::Triple::thumb: 205 if (Triple.isOSBinFormatMachO()) 206 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts); 207 208 switch (os) { 209 case llvm::Triple::Linux: 210 switch (Triple.getEnvironment()) { 211 default: 212 return std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(Triple, Opts); 213 case llvm::Triple::OpenHOS: 214 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts); 215 } 216 case llvm::Triple::LiteOS: 217 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts); 218 case llvm::Triple::FreeBSD: 219 return std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts); 220 case llvm::Triple::NetBSD: 221 return std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts); 222 case llvm::Triple::OpenBSD: 223 return std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts); 224 case llvm::Triple::RTEMS: 225 return std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(Triple, Opts); 226 case llvm::Triple::Haiku: 227 return std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(Triple, Opts); 228 case llvm::Triple::NaCl: 229 return std::make_unique<NaClTargetInfo<ARMleTargetInfo>>(Triple, Opts); 230 case llvm::Triple::Win32: 231 switch (Triple.getEnvironment()) { 232 case llvm::Triple::Cygnus: 233 return std::make_unique<CygwinARMTargetInfo>(Triple, Opts); 234 case llvm::Triple::GNU: 235 return std::make_unique<MinGWARMTargetInfo>(Triple, Opts); 236 case llvm::Triple::Itanium: 237 return std::make_unique<ItaniumWindowsARMleTargetInfo>(Triple, Opts); 238 case llvm::Triple::MSVC: 239 default: // Assume MSVC for unknown environments 240 return std::make_unique<MicrosoftARMleTargetInfo>(Triple, Opts); 241 } 242 default: 243 return std::make_unique<ARMleTargetInfo>(Triple, Opts); 244 } 245 246 case llvm::Triple::armeb: 247 case llvm::Triple::thumbeb: 248 if (Triple.isOSDarwin()) 249 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts); 250 else if (Triple.isAppleMachO()) 251 return std::make_unique<AppleMachOARMTargetInfo>(Triple, Opts); 252 253 switch (os) { 254 case llvm::Triple::Linux: 255 return std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 256 case llvm::Triple::NetBSD: 257 return std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 258 case llvm::Triple::RTEMS: 259 return std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 260 case llvm::Triple::NaCl: 261 return std::make_unique<NaClTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 262 default: 263 return std::make_unique<ARMbeTargetInfo>(Triple, Opts); 264 } 265 266 case llvm::Triple::avr: 267 return std::make_unique<AVRTargetInfo>(Triple, Opts); 268 case llvm::Triple::bpfeb: 269 case llvm::Triple::bpfel: 270 return std::make_unique<BPFTargetInfo>(Triple, Opts); 271 272 case llvm::Triple::msp430: 273 return std::make_unique<MSP430TargetInfo>(Triple, Opts); 274 275 case llvm::Triple::mips: 276 switch (os) { 277 case llvm::Triple::Linux: 278 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 279 case llvm::Triple::RTEMS: 280 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 281 case llvm::Triple::FreeBSD: 282 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 283 case llvm::Triple::NetBSD: 284 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 285 default: 286 return std::make_unique<MipsTargetInfo>(Triple, Opts); 287 } 288 289 case llvm::Triple::mipsel: 290 switch (os) { 291 case llvm::Triple::Linux: 292 switch (Triple.getEnvironment()) { 293 default: 294 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 295 case llvm::Triple::OpenHOS: 296 return std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(Triple, Opts); 297 } 298 case llvm::Triple::RTEMS: 299 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 300 case llvm::Triple::FreeBSD: 301 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 302 case llvm::Triple::NetBSD: 303 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 304 case llvm::Triple::NaCl: 305 return std::make_unique<NaClTargetInfo<NaClMips32TargetInfo>>(Triple, 306 Opts); 307 case llvm::Triple::Win32: 308 switch (Triple.getEnvironment()) { 309 case llvm::Triple::GNU: 310 return std::make_unique<MinGWMipsTargetInfo>(Triple, Opts); 311 case llvm::Triple::MSVC: 312 default: // Assume MSVC for unknown environments 313 return std::make_unique<MicrosoftMipsTargetInfo>(Triple, Opts); 314 } 315 default: 316 return std::make_unique<MipsTargetInfo>(Triple, Opts); 317 } 318 319 case llvm::Triple::mips64: 320 switch (os) { 321 case llvm::Triple::Linux: 322 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 323 case llvm::Triple::RTEMS: 324 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 325 case llvm::Triple::FreeBSD: 326 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 327 case llvm::Triple::NetBSD: 328 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 329 case llvm::Triple::OpenBSD: 330 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 331 default: 332 return std::make_unique<MipsTargetInfo>(Triple, Opts); 333 } 334 335 case llvm::Triple::mips64el: 336 switch (os) { 337 case llvm::Triple::Linux: 338 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 339 case llvm::Triple::RTEMS: 340 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 341 case llvm::Triple::FreeBSD: 342 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 343 case llvm::Triple::NetBSD: 344 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 345 case llvm::Triple::OpenBSD: 346 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 347 default: 348 return std::make_unique<MipsTargetInfo>(Triple, Opts); 349 } 350 351 case llvm::Triple::m68k: 352 switch (os) { 353 case llvm::Triple::Linux: 354 return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(Triple, Opts); 355 case llvm::Triple::NetBSD: 356 return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(Triple, Opts); 357 default: 358 return std::make_unique<M68kTargetInfo>(Triple, Opts); 359 } 360 361 case llvm::Triple::ppc: 362 switch (os) { 363 case llvm::Triple::Linux: 364 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts); 365 case llvm::Triple::FreeBSD: 366 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 367 case llvm::Triple::NetBSD: 368 return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 369 case llvm::Triple::OpenBSD: 370 return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 371 case llvm::Triple::RTEMS: 372 return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(Triple, Opts); 373 case llvm::Triple::AIX: 374 return std::make_unique<AIXPPC32TargetInfo>(Triple, Opts); 375 default: 376 return std::make_unique<PPC32TargetInfo>(Triple, Opts); 377 } 378 379 case llvm::Triple::ppcle: 380 switch (os) { 381 case llvm::Triple::Linux: 382 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts); 383 case llvm::Triple::FreeBSD: 384 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 385 default: 386 return std::make_unique<PPC32TargetInfo>(Triple, Opts); 387 } 388 389 case llvm::Triple::ppc64: 390 switch (os) { 391 case llvm::Triple::Linux: 392 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts); 393 case llvm::Triple::Lv2: 394 return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(Triple, Opts); 395 case llvm::Triple::FreeBSD: 396 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 397 case llvm::Triple::NetBSD: 398 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 399 case llvm::Triple::OpenBSD: 400 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 401 case llvm::Triple::AIX: 402 return std::make_unique<AIXPPC64TargetInfo>(Triple, Opts); 403 default: 404 return std::make_unique<PPC64TargetInfo>(Triple, Opts); 405 } 406 407 case llvm::Triple::ppc64le: 408 switch (os) { 409 case llvm::Triple::Linux: 410 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts); 411 case llvm::Triple::FreeBSD: 412 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 413 case llvm::Triple::NetBSD: 414 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 415 case llvm::Triple::OpenBSD: 416 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 417 default: 418 return std::make_unique<PPC64TargetInfo>(Triple, Opts); 419 } 420 421 case llvm::Triple::nvptx: 422 return std::make_unique<NVPTXTargetInfo>(Triple, Opts, 423 /*TargetPointerWidth=*/32); 424 case llvm::Triple::nvptx64: 425 return std::make_unique<NVPTXTargetInfo>(Triple, Opts, 426 /*TargetPointerWidth=*/64); 427 428 case llvm::Triple::amdgcn: 429 case llvm::Triple::r600: 430 return std::make_unique<AMDGPUTargetInfo>(Triple, Opts); 431 432 case llvm::Triple::riscv32: 433 switch (os) { 434 case llvm::Triple::NetBSD: 435 return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(Triple, 436 Opts); 437 case llvm::Triple::Linux: 438 return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(Triple, Opts); 439 default: 440 return std::make_unique<RISCV32TargetInfo>(Triple, Opts); 441 } 442 443 case llvm::Triple::riscv64: 444 switch (os) { 445 case llvm::Triple::FreeBSD: 446 return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(Triple, 447 Opts); 448 case llvm::Triple::NetBSD: 449 return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(Triple, 450 Opts); 451 case llvm::Triple::OpenBSD: 452 return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(Triple, 453 Opts); 454 case llvm::Triple::Fuchsia: 455 return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(Triple, 456 Opts); 457 case llvm::Triple::Haiku: 458 return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(Triple, 459 Opts); 460 case llvm::Triple::Linux: 461 switch (Triple.getEnvironment()) { 462 default: 463 return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(Triple, 464 Opts); 465 case llvm::Triple::OpenHOS: 466 return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple, 467 Opts); 468 } 469 default: 470 return std::make_unique<RISCV64TargetInfo>(Triple, Opts); 471 } 472 473 case llvm::Triple::sparc: 474 switch (os) { 475 case llvm::Triple::Linux: 476 return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(Triple, Opts); 477 case llvm::Triple::Solaris: 478 return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(Triple, 479 Opts); 480 case llvm::Triple::NetBSD: 481 return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(Triple, 482 Opts); 483 case llvm::Triple::RTEMS: 484 return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(Triple, Opts); 485 default: 486 return std::make_unique<SparcV8TargetInfo>(Triple, Opts); 487 } 488 489 case llvm::Triple::sparcel: 490 switch (os) { 491 case llvm::Triple::Linux: 492 return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(Triple, 493 Opts); 494 case llvm::Triple::RTEMS: 495 return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(Triple, 496 Opts); 497 default: 498 return std::make_unique<SparcV8elTargetInfo>(Triple, Opts); 499 } 500 501 case llvm::Triple::sparcv9: 502 switch (os) { 503 case llvm::Triple::Linux: 504 return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(Triple, Opts); 505 case llvm::Triple::Solaris: 506 return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(Triple, 507 Opts); 508 case llvm::Triple::NetBSD: 509 return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(Triple, 510 Opts); 511 case llvm::Triple::OpenBSD: 512 return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(Triple, 513 Opts); 514 case llvm::Triple::FreeBSD: 515 return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(Triple, 516 Opts); 517 default: 518 return std::make_unique<SparcV9TargetInfo>(Triple, Opts); 519 } 520 521 case llvm::Triple::systemz: 522 switch (os) { 523 case llvm::Triple::Linux: 524 return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(Triple, Opts); 525 case llvm::Triple::ZOS: 526 return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(Triple, Opts); 527 default: 528 return std::make_unique<SystemZTargetInfo>(Triple, Opts); 529 } 530 531 case llvm::Triple::tce: 532 return std::make_unique<TCETargetInfo>(Triple, Opts); 533 534 case llvm::Triple::tcele: 535 return std::make_unique<TCELETargetInfo>(Triple, Opts); 536 537 case llvm::Triple::x86: 538 if (Triple.isOSDarwin()) 539 return std::make_unique<DarwinI386TargetInfo>(Triple, Opts); 540 else if (Triple.isAppleMachO()) 541 return std::make_unique<AppleMachOI386TargetInfo>(Triple, Opts); 542 543 switch (os) { 544 case llvm::Triple::Linux: { 545 switch (Triple.getEnvironment()) { 546 default: 547 return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(Triple, 548 Opts); 549 case llvm::Triple::Android: 550 return std::make_unique<AndroidX86_32TargetInfo>(Triple, Opts); 551 } 552 } 553 case llvm::Triple::DragonFly: 554 return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(Triple, 555 Opts); 556 case llvm::Triple::NetBSD: 557 return std::make_unique<NetBSDI386TargetInfo>(Triple, Opts); 558 case llvm::Triple::OpenBSD: 559 return std::make_unique<OpenBSDI386TargetInfo>(Triple, Opts); 560 case llvm::Triple::FreeBSD: 561 return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(Triple, 562 Opts); 563 case llvm::Triple::Fuchsia: 564 return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(Triple, 565 Opts); 566 case llvm::Triple::KFreeBSD: 567 return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(Triple, 568 Opts); 569 case llvm::Triple::Solaris: 570 return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(Triple, 571 Opts); 572 case llvm::Triple::Win32: { 573 switch (Triple.getEnvironment()) { 574 case llvm::Triple::Cygnus: 575 return std::make_unique<CygwinX86_32TargetInfo>(Triple, Opts); 576 case llvm::Triple::GNU: 577 return std::make_unique<MinGWX86_32TargetInfo>(Triple, Opts); 578 case llvm::Triple::Itanium: 579 case llvm::Triple::MSVC: 580 default: // Assume MSVC for unknown environments 581 return std::make_unique<MicrosoftX86_32TargetInfo>(Triple, Opts); 582 } 583 } 584 case llvm::Triple::Haiku: 585 return std::make_unique<HaikuX86_32TargetInfo>(Triple, Opts); 586 case llvm::Triple::RTEMS: 587 return std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts); 588 case llvm::Triple::NaCl: 589 return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(Triple, Opts); 590 case llvm::Triple::ELFIAMCU: 591 return std::make_unique<MCUX86_32TargetInfo>(Triple, Opts); 592 case llvm::Triple::Hurd: 593 return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts); 594 default: 595 return std::make_unique<X86_32TargetInfo>(Triple, Opts); 596 } 597 598 case llvm::Triple::x86_64: 599 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) 600 return std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts); 601 602 switch (os) { 603 case llvm::Triple::Linux: { 604 switch (Triple.getEnvironment()) { 605 default: 606 return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(Triple, 607 Opts); 608 case llvm::Triple::Android: 609 return std::make_unique<AndroidX86_64TargetInfo>(Triple, Opts); 610 case llvm::Triple::OpenHOS: 611 return std::make_unique<OHOSX86_64TargetInfo>(Triple, Opts); 612 } 613 } 614 case llvm::Triple::DragonFly: 615 return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(Triple, 616 Opts); 617 case llvm::Triple::NetBSD: 618 return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(Triple, Opts); 619 case llvm::Triple::OpenBSD: 620 return std::make_unique<OpenBSDX86_64TargetInfo>(Triple, Opts); 621 case llvm::Triple::FreeBSD: 622 return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(Triple, 623 Opts); 624 case llvm::Triple::Fuchsia: 625 return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(Triple, 626 Opts); 627 case llvm::Triple::KFreeBSD: 628 return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(Triple, 629 Opts); 630 case llvm::Triple::Solaris: 631 return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(Triple, 632 Opts); 633 case llvm::Triple::UEFI: 634 return std::make_unique<UEFIX86_64TargetInfo>(Triple, Opts); 635 636 case llvm::Triple::Win32: { 637 switch (Triple.getEnvironment()) { 638 case llvm::Triple::Cygnus: 639 return std::make_unique<CygwinX86_64TargetInfo>(Triple, Opts); 640 case llvm::Triple::GNU: 641 return std::make_unique<MinGWX86_64TargetInfo>(Triple, Opts); 642 case llvm::Triple::MSVC: 643 default: // Assume MSVC for unknown environments 644 return std::make_unique<MicrosoftX86_64TargetInfo>(Triple, Opts); 645 } 646 } 647 case llvm::Triple::Haiku: 648 return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(Triple, Opts); 649 case llvm::Triple::NaCl: 650 return std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(Triple, Opts); 651 case llvm::Triple::PS4: 652 return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(Triple, Opts); 653 case llvm::Triple::PS5: 654 return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts); 655 case llvm::Triple::Hurd: 656 return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(Triple, Opts); 657 default: 658 return std::make_unique<X86_64TargetInfo>(Triple, Opts); 659 } 660 661 case llvm::Triple::spir: { 662 if (os != llvm::Triple::UnknownOS || 663 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 664 return nullptr; 665 return std::make_unique<SPIR32TargetInfo>(Triple, Opts); 666 } 667 case llvm::Triple::spir64: { 668 if (os != llvm::Triple::UnknownOS || 669 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 670 return nullptr; 671 return std::make_unique<SPIR64TargetInfo>(Triple, Opts); 672 } 673 case llvm::Triple::spirv: { 674 return std::make_unique<SPIRVTargetInfo>(Triple, Opts); 675 } 676 case llvm::Triple::spirv32: { 677 if (os != llvm::Triple::UnknownOS || 678 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 679 return nullptr; 680 return std::make_unique<SPIRV32TargetInfo>(Triple, Opts); 681 } 682 case llvm::Triple::spirv64: { 683 if (os != llvm::Triple::UnknownOS || 684 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) { 685 if (os == llvm::Triple::OSType::AMDHSA) 686 return std::make_unique<SPIRV64AMDGCNTargetInfo>(Triple, Opts); 687 return nullptr; 688 } 689 return std::make_unique<SPIRV64TargetInfo>(Triple, Opts); 690 } 691 case llvm::Triple::wasm32: 692 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 693 Triple.getVendor() != llvm::Triple::UnknownVendor || 694 !Triple.isOSBinFormatWasm()) 695 return nullptr; 696 switch (os) { 697 case llvm::Triple::WASI: 698 return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(Triple, 699 Opts); 700 case llvm::Triple::Emscripten: 701 return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>( 702 Triple, Opts); 703 case llvm::Triple::UnknownOS: 704 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>( 705 Triple, Opts); 706 default: 707 return nullptr; 708 } 709 case llvm::Triple::wasm64: 710 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 711 Triple.getVendor() != llvm::Triple::UnknownVendor || 712 !Triple.isOSBinFormatWasm()) 713 return nullptr; 714 switch (os) { 715 case llvm::Triple::WASI: 716 return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(Triple, 717 Opts); 718 case llvm::Triple::Emscripten: 719 return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>( 720 Triple, Opts); 721 case llvm::Triple::UnknownOS: 722 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>( 723 Triple, Opts); 724 default: 725 return nullptr; 726 } 727 728 case llvm::Triple::dxil: 729 return std::make_unique<DirectXTargetInfo>(Triple, Opts); 730 731 case llvm::Triple::ve: 732 return std::make_unique<LinuxTargetInfo<VETargetInfo>>(Triple, Opts); 733 734 case llvm::Triple::csky: 735 switch (os) { 736 case llvm::Triple::Linux: 737 return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(Triple, Opts); 738 default: 739 return std::make_unique<CSKYTargetInfo>(Triple, Opts); 740 } 741 case llvm::Triple::loongarch32: 742 switch (os) { 743 case llvm::Triple::Linux: 744 return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple, 745 Opts); 746 default: 747 return std::make_unique<LoongArch32TargetInfo>(Triple, Opts); 748 } 749 case llvm::Triple::loongarch64: 750 switch (os) { 751 case llvm::Triple::Linux: 752 return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple, 753 Opts); 754 case llvm::Triple::FreeBSD: 755 return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(Triple, 756 Opts); 757 default: 758 return std::make_unique<LoongArch64TargetInfo>(Triple, Opts); 759 } 760 761 case llvm::Triple::xtensa: 762 return std::make_unique<XtensaTargetInfo>(Triple, Opts); 763 } 764 } 765 } // namespace targets 766 } // namespace clang 767 768 using namespace clang::targets; 769 /// CreateTargetInfo - Return the target info object for the specified target 770 /// options. 771 TargetInfo * 772 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 773 const std::shared_ptr<TargetOptions> &Opts) { 774 llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple)); 775 776 // Construct the target 777 std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, *Opts); 778 if (!Target) { 779 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 780 return nullptr; 781 } 782 Target->TargetOpts = Opts; 783 784 // Set the target CPU if specified. 785 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 786 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 787 SmallVector<StringRef, 32> ValidList; 788 Target->fillValidCPUList(ValidList); 789 if (!ValidList.empty()) 790 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 791 return nullptr; 792 } 793 794 // Check the TuneCPU name if specified. 795 if (!Opts->TuneCPU.empty() && 796 !Target->isValidTuneCPUName(Opts->TuneCPU)) { 797 Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU; 798 SmallVector<StringRef, 32> ValidList; 799 Target->fillValidTuneCPUList(ValidList); 800 if (!ValidList.empty()) 801 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 802 return nullptr; 803 } 804 805 // Set the target ABI if specified. 806 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 807 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 808 return nullptr; 809 } 810 811 // Set the fp math unit. 812 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { 813 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; 814 return nullptr; 815 } 816 817 // Compute the default target features, we need the target to handle this 818 // because features may have dependencies on one another. 819 llvm::erase_if(Opts->FeaturesAsWritten, [&](StringRef Name) { 820 if (Target->isReadOnlyFeature(Name.substr(1))) { 821 Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name; 822 return true; 823 } 824 return false; 825 }); 826 if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU, 827 Opts->FeaturesAsWritten)) 828 return nullptr; 829 830 // Add the features to the compile options. 831 Opts->Features.clear(); 832 for (const auto &F : Opts->FeatureMap) 833 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str()); 834 // Sort here, so we handle the features in a predictable order. (This matters 835 // when we're dealing with features that overlap.) 836 llvm::sort(Opts->Features); 837 838 if (!Target->handleTargetFeatures(Opts->Features, Diags)) 839 return nullptr; 840 841 Target->setSupportedOpenCLOpts(); 842 Target->setCommandLineOpenCLOpts(); 843 Target->setMaxAtomicWidth(); 844 845 if (!Opts->DarwinTargetVariantTriple.empty()) 846 Target->DarwinTargetVariantTriple = 847 llvm::Triple(Opts->DarwinTargetVariantTriple); 848 849 if (!Target->validateTarget(Diags)) 850 return nullptr; 851 852 Target->CheckFixedPointBits(); 853 854 return Target.release(); 855 } 856 /// validateOpenCLTarget - Check that OpenCL target has valid 857 /// options setting based on OpenCL version. 858 bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts, 859 DiagnosticsEngine &Diags) const { 860 const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts(); 861 862 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) { 863 if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && 864 !hasFeatureEnabled(OpenCLFeaturesMap, Name)) 865 Diags.Report(diag::warn_opencl_unsupported_core_feature) 866 << Name << Opts.OpenCLCPlusPlus 867 << Opts.getOpenCLVersionTuple().getAsString(); 868 }; 869 #define OPENCL_GENERIC_EXTENSION(Ext, ...) \ 870 diagnoseNotSupportedCore(#Ext, __VA_ARGS__); 871 #include "clang/Basic/OpenCLExtensions.def" 872 873 // Validate that feature macros are set properly for OpenCL C 3.0. 874 // In other cases assume that target is always valid. 875 if (Opts.getOpenCLCompatibleVersion() < 300) 876 return true; 877 878 return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(*this, Diags) && 879 OpenCLOptions::diagnoseFeatureExtensionDifferences(*this, Diags); 880 } 881