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::Managarm: 168 return std::make_unique<ManagarmTargetInfo<AArch64leTargetInfo>>(Triple, 169 Opts); 170 case llvm::Triple::NetBSD: 171 return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple, 172 Opts); 173 case llvm::Triple::OpenBSD: 174 return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(Triple, 175 Opts); 176 case llvm::Triple::Win32: 177 switch (Triple.getEnvironment()) { 178 case llvm::Triple::GNU: 179 return std::make_unique<MinGWARM64TargetInfo>(Triple, Opts); 180 case llvm::Triple::MSVC: 181 default: // Assume MSVC for unknown environments 182 return std::make_unique<MicrosoftARM64TargetInfo>(Triple, Opts); 183 } 184 default: 185 return std::make_unique<AArch64leTargetInfo>(Triple, Opts); 186 } 187 188 case llvm::Triple::aarch64_be: 189 switch (os) { 190 case llvm::Triple::FreeBSD: 191 return std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(Triple, 192 Opts); 193 case llvm::Triple::Fuchsia: 194 return std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(Triple, 195 Opts); 196 case llvm::Triple::Linux: 197 return std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(Triple, 198 Opts); 199 case llvm::Triple::NetBSD: 200 return std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(Triple, 201 Opts); 202 default: 203 return std::make_unique<AArch64beTargetInfo>(Triple, Opts); 204 } 205 206 case llvm::Triple::arm: 207 case llvm::Triple::thumb: 208 if (Triple.isOSBinFormatMachO()) 209 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts); 210 211 switch (os) { 212 case llvm::Triple::Linux: 213 switch (Triple.getEnvironment()) { 214 default: 215 return std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(Triple, Opts); 216 case llvm::Triple::OpenHOS: 217 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts); 218 } 219 case llvm::Triple::LiteOS: 220 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts); 221 case llvm::Triple::FreeBSD: 222 return std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts); 223 case llvm::Triple::NetBSD: 224 return std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts); 225 case llvm::Triple::OpenBSD: 226 return std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts); 227 case llvm::Triple::RTEMS: 228 return std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(Triple, Opts); 229 case llvm::Triple::Haiku: 230 return std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(Triple, Opts); 231 case llvm::Triple::NaCl: 232 return std::make_unique<NaClTargetInfo<ARMleTargetInfo>>(Triple, Opts); 233 case llvm::Triple::Win32: 234 switch (Triple.getEnvironment()) { 235 case llvm::Triple::Cygnus: 236 return std::make_unique<CygwinARMTargetInfo>(Triple, Opts); 237 case llvm::Triple::GNU: 238 return std::make_unique<MinGWARMTargetInfo>(Triple, Opts); 239 case llvm::Triple::Itanium: 240 return std::make_unique<ItaniumWindowsARMleTargetInfo>(Triple, Opts); 241 case llvm::Triple::MSVC: 242 default: // Assume MSVC for unknown environments 243 return std::make_unique<MicrosoftARMleTargetInfo>(Triple, Opts); 244 } 245 default: 246 return std::make_unique<ARMleTargetInfo>(Triple, Opts); 247 } 248 249 case llvm::Triple::armeb: 250 case llvm::Triple::thumbeb: 251 if (Triple.isOSDarwin()) 252 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts); 253 else if (Triple.isAppleMachO()) 254 return std::make_unique<AppleMachOARMTargetInfo>(Triple, Opts); 255 256 switch (os) { 257 case llvm::Triple::Linux: 258 return std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 259 case llvm::Triple::NetBSD: 260 return std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 261 case llvm::Triple::RTEMS: 262 return std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 263 case llvm::Triple::NaCl: 264 return std::make_unique<NaClTargetInfo<ARMbeTargetInfo>>(Triple, Opts); 265 default: 266 return std::make_unique<ARMbeTargetInfo>(Triple, Opts); 267 } 268 269 case llvm::Triple::avr: 270 return std::make_unique<AVRTargetInfo>(Triple, Opts); 271 case llvm::Triple::bpfeb: 272 case llvm::Triple::bpfel: 273 return std::make_unique<BPFTargetInfo>(Triple, Opts); 274 275 case llvm::Triple::msp430: 276 return std::make_unique<MSP430TargetInfo>(Triple, Opts); 277 278 case llvm::Triple::mips: 279 switch (os) { 280 case llvm::Triple::Linux: 281 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 282 case llvm::Triple::RTEMS: 283 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 284 case llvm::Triple::FreeBSD: 285 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 286 case llvm::Triple::NetBSD: 287 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 288 default: 289 return std::make_unique<MipsTargetInfo>(Triple, Opts); 290 } 291 292 case llvm::Triple::mipsel: 293 switch (os) { 294 case llvm::Triple::Linux: 295 switch (Triple.getEnvironment()) { 296 default: 297 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 298 case llvm::Triple::OpenHOS: 299 return std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(Triple, Opts); 300 } 301 case llvm::Triple::RTEMS: 302 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 303 case llvm::Triple::FreeBSD: 304 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 305 case llvm::Triple::NetBSD: 306 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 307 case llvm::Triple::NaCl: 308 return std::make_unique<NaClTargetInfo<NaClMips32TargetInfo>>(Triple, 309 Opts); 310 case llvm::Triple::Win32: 311 switch (Triple.getEnvironment()) { 312 case llvm::Triple::GNU: 313 return std::make_unique<MinGWMipsTargetInfo>(Triple, Opts); 314 case llvm::Triple::MSVC: 315 default: // Assume MSVC for unknown environments 316 return std::make_unique<MicrosoftMipsTargetInfo>(Triple, Opts); 317 } 318 default: 319 return std::make_unique<MipsTargetInfo>(Triple, Opts); 320 } 321 322 case llvm::Triple::mips64: 323 switch (os) { 324 case llvm::Triple::Linux: 325 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 326 case llvm::Triple::RTEMS: 327 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 328 case llvm::Triple::FreeBSD: 329 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 330 case llvm::Triple::NetBSD: 331 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 332 case llvm::Triple::OpenBSD: 333 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 334 default: 335 return std::make_unique<MipsTargetInfo>(Triple, Opts); 336 } 337 338 case llvm::Triple::mips64el: 339 switch (os) { 340 case llvm::Triple::Linux: 341 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts); 342 case llvm::Triple::RTEMS: 343 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts); 344 case llvm::Triple::FreeBSD: 345 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 346 case llvm::Triple::NetBSD: 347 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 348 case llvm::Triple::OpenBSD: 349 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts); 350 default: 351 return std::make_unique<MipsTargetInfo>(Triple, Opts); 352 } 353 354 case llvm::Triple::m68k: 355 switch (os) { 356 case llvm::Triple::Linux: 357 return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(Triple, Opts); 358 case llvm::Triple::NetBSD: 359 return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(Triple, Opts); 360 default: 361 return std::make_unique<M68kTargetInfo>(Triple, Opts); 362 } 363 364 case llvm::Triple::ppc: 365 switch (os) { 366 case llvm::Triple::Linux: 367 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts); 368 case llvm::Triple::FreeBSD: 369 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 370 case llvm::Triple::NetBSD: 371 return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 372 case llvm::Triple::OpenBSD: 373 return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 374 case llvm::Triple::RTEMS: 375 return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(Triple, Opts); 376 case llvm::Triple::AIX: 377 return std::make_unique<AIXPPC32TargetInfo>(Triple, Opts); 378 default: 379 return std::make_unique<PPC32TargetInfo>(Triple, Opts); 380 } 381 382 case llvm::Triple::ppcle: 383 switch (os) { 384 case llvm::Triple::Linux: 385 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts); 386 case llvm::Triple::FreeBSD: 387 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); 388 default: 389 return std::make_unique<PPC32TargetInfo>(Triple, Opts); 390 } 391 392 case llvm::Triple::ppc64: 393 switch (os) { 394 case llvm::Triple::Linux: 395 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts); 396 case llvm::Triple::Lv2: 397 return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(Triple, Opts); 398 case llvm::Triple::FreeBSD: 399 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 400 case llvm::Triple::NetBSD: 401 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 402 case llvm::Triple::OpenBSD: 403 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 404 case llvm::Triple::AIX: 405 return std::make_unique<AIXPPC64TargetInfo>(Triple, Opts); 406 default: 407 return std::make_unique<PPC64TargetInfo>(Triple, Opts); 408 } 409 410 case llvm::Triple::ppc64le: 411 switch (os) { 412 case llvm::Triple::Linux: 413 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts); 414 case llvm::Triple::FreeBSD: 415 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 416 case llvm::Triple::NetBSD: 417 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 418 case llvm::Triple::OpenBSD: 419 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts); 420 default: 421 return std::make_unique<PPC64TargetInfo>(Triple, Opts); 422 } 423 424 case llvm::Triple::nvptx: 425 return std::make_unique<NVPTXTargetInfo>(Triple, Opts, 426 /*TargetPointerWidth=*/32); 427 case llvm::Triple::nvptx64: 428 return std::make_unique<NVPTXTargetInfo>(Triple, Opts, 429 /*TargetPointerWidth=*/64); 430 431 case llvm::Triple::amdgcn: 432 case llvm::Triple::r600: 433 return std::make_unique<AMDGPUTargetInfo>(Triple, Opts); 434 435 case llvm::Triple::riscv32: 436 switch (os) { 437 case llvm::Triple::NetBSD: 438 return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(Triple, 439 Opts); 440 case llvm::Triple::Linux: 441 return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(Triple, Opts); 442 default: 443 return std::make_unique<RISCV32TargetInfo>(Triple, Opts); 444 } 445 446 case llvm::Triple::riscv64: 447 switch (os) { 448 case llvm::Triple::FreeBSD: 449 return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(Triple, 450 Opts); 451 case llvm::Triple::NetBSD: 452 return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(Triple, 453 Opts); 454 case llvm::Triple::OpenBSD: 455 return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(Triple, 456 Opts); 457 case llvm::Triple::Fuchsia: 458 return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(Triple, 459 Opts); 460 case llvm::Triple::Haiku: 461 return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(Triple, 462 Opts); 463 case llvm::Triple::Linux: 464 switch (Triple.getEnvironment()) { 465 default: 466 return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(Triple, 467 Opts); 468 case llvm::Triple::OpenHOS: 469 return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple, 470 Opts); 471 } 472 case llvm::Triple::Managarm: 473 return std::make_unique<ManagarmTargetInfo<RISCV64TargetInfo>>(Triple, 474 Opts); 475 default: 476 return std::make_unique<RISCV64TargetInfo>(Triple, Opts); 477 } 478 479 case llvm::Triple::sparc: 480 switch (os) { 481 case llvm::Triple::Linux: 482 return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(Triple, Opts); 483 case llvm::Triple::Solaris: 484 return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(Triple, 485 Opts); 486 case llvm::Triple::NetBSD: 487 return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(Triple, 488 Opts); 489 case llvm::Triple::RTEMS: 490 return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(Triple, Opts); 491 default: 492 return std::make_unique<SparcV8TargetInfo>(Triple, Opts); 493 } 494 495 case llvm::Triple::sparcel: 496 switch (os) { 497 case llvm::Triple::Linux: 498 return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(Triple, 499 Opts); 500 case llvm::Triple::RTEMS: 501 return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(Triple, 502 Opts); 503 default: 504 return std::make_unique<SparcV8elTargetInfo>(Triple, Opts); 505 } 506 507 case llvm::Triple::sparcv9: 508 switch (os) { 509 case llvm::Triple::Linux: 510 return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(Triple, Opts); 511 case llvm::Triple::Solaris: 512 return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(Triple, 513 Opts); 514 case llvm::Triple::NetBSD: 515 return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(Triple, 516 Opts); 517 case llvm::Triple::OpenBSD: 518 return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(Triple, 519 Opts); 520 case llvm::Triple::FreeBSD: 521 return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(Triple, 522 Opts); 523 default: 524 return std::make_unique<SparcV9TargetInfo>(Triple, Opts); 525 } 526 527 case llvm::Triple::systemz: 528 switch (os) { 529 case llvm::Triple::Linux: 530 return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(Triple, Opts); 531 case llvm::Triple::ZOS: 532 return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(Triple, Opts); 533 default: 534 return std::make_unique<SystemZTargetInfo>(Triple, Opts); 535 } 536 537 case llvm::Triple::tce: 538 return std::make_unique<TCETargetInfo>(Triple, Opts); 539 540 case llvm::Triple::tcele: 541 return std::make_unique<TCELETargetInfo>(Triple, Opts); 542 543 case llvm::Triple::x86: 544 if (Triple.isOSDarwin()) 545 return std::make_unique<DarwinI386TargetInfo>(Triple, Opts); 546 else if (Triple.isAppleMachO()) 547 return std::make_unique<AppleMachOI386TargetInfo>(Triple, Opts); 548 549 switch (os) { 550 case llvm::Triple::Linux: { 551 switch (Triple.getEnvironment()) { 552 default: 553 return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(Triple, 554 Opts); 555 case llvm::Triple::Android: 556 return std::make_unique<AndroidX86_32TargetInfo>(Triple, Opts); 557 } 558 } 559 case llvm::Triple::DragonFly: 560 return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(Triple, 561 Opts); 562 case llvm::Triple::NetBSD: 563 return std::make_unique<NetBSDI386TargetInfo>(Triple, Opts); 564 case llvm::Triple::OpenBSD: 565 return std::make_unique<OpenBSDI386TargetInfo>(Triple, Opts); 566 case llvm::Triple::FreeBSD: 567 return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(Triple, 568 Opts); 569 case llvm::Triple::Fuchsia: 570 return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(Triple, 571 Opts); 572 case llvm::Triple::KFreeBSD: 573 return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(Triple, 574 Opts); 575 case llvm::Triple::Solaris: 576 return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(Triple, 577 Opts); 578 case llvm::Triple::Win32: { 579 switch (Triple.getEnvironment()) { 580 case llvm::Triple::Cygnus: 581 return std::make_unique<CygwinX86_32TargetInfo>(Triple, Opts); 582 case llvm::Triple::GNU: 583 return std::make_unique<MinGWX86_32TargetInfo>(Triple, Opts); 584 case llvm::Triple::Itanium: 585 case llvm::Triple::MSVC: 586 default: // Assume MSVC for unknown environments 587 return std::make_unique<MicrosoftX86_32TargetInfo>(Triple, Opts); 588 } 589 } 590 case llvm::Triple::Haiku: 591 return std::make_unique<HaikuX86_32TargetInfo>(Triple, Opts); 592 case llvm::Triple::RTEMS: 593 return std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts); 594 case llvm::Triple::NaCl: 595 return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(Triple, Opts); 596 case llvm::Triple::ELFIAMCU: 597 return std::make_unique<MCUX86_32TargetInfo>(Triple, Opts); 598 case llvm::Triple::Hurd: 599 return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts); 600 default: 601 return std::make_unique<X86_32TargetInfo>(Triple, Opts); 602 } 603 604 case llvm::Triple::x86_64: 605 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) 606 return std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts); 607 608 switch (os) { 609 case llvm::Triple::Linux: { 610 switch (Triple.getEnvironment()) { 611 default: 612 return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(Triple, 613 Opts); 614 case llvm::Triple::Android: 615 return std::make_unique<AndroidX86_64TargetInfo>(Triple, Opts); 616 case llvm::Triple::OpenHOS: 617 return std::make_unique<OHOSX86_64TargetInfo>(Triple, Opts); 618 } 619 } 620 case llvm::Triple::DragonFly: 621 return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(Triple, 622 Opts); 623 case llvm::Triple::NetBSD: 624 return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(Triple, Opts); 625 case llvm::Triple::OpenBSD: 626 return std::make_unique<OpenBSDX86_64TargetInfo>(Triple, Opts); 627 case llvm::Triple::FreeBSD: 628 return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(Triple, 629 Opts); 630 case llvm::Triple::Fuchsia: 631 return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(Triple, 632 Opts); 633 case llvm::Triple::KFreeBSD: 634 return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(Triple, 635 Opts); 636 case llvm::Triple::Solaris: 637 return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(Triple, 638 Opts); 639 case llvm::Triple::UEFI: 640 return std::make_unique<UEFIX86_64TargetInfo>(Triple, Opts); 641 642 case llvm::Triple::Win32: { 643 switch (Triple.getEnvironment()) { 644 case llvm::Triple::Cygnus: 645 return std::make_unique<CygwinX86_64TargetInfo>(Triple, Opts); 646 case llvm::Triple::GNU: 647 return std::make_unique<MinGWX86_64TargetInfo>(Triple, Opts); 648 case llvm::Triple::MSVC: 649 default: // Assume MSVC for unknown environments 650 return std::make_unique<MicrosoftX86_64TargetInfo>(Triple, Opts); 651 } 652 } 653 case llvm::Triple::Haiku: 654 return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(Triple, Opts); 655 case llvm::Triple::NaCl: 656 return std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(Triple, Opts); 657 case llvm::Triple::PS4: 658 return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(Triple, Opts); 659 case llvm::Triple::PS5: 660 return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts); 661 case llvm::Triple::Hurd: 662 return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(Triple, Opts); 663 case llvm::Triple::Managarm: 664 return std::make_unique<ManagarmTargetInfo<X86_64TargetInfo>>(Triple, 665 Opts); 666 default: 667 return std::make_unique<X86_64TargetInfo>(Triple, Opts); 668 } 669 670 case llvm::Triple::spir: { 671 if (os != llvm::Triple::UnknownOS || 672 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 673 return nullptr; 674 return std::make_unique<SPIR32TargetInfo>(Triple, Opts); 675 } 676 case llvm::Triple::spir64: { 677 if (os != llvm::Triple::UnknownOS || 678 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 679 return nullptr; 680 return std::make_unique<SPIR64TargetInfo>(Triple, Opts); 681 } 682 case llvm::Triple::spirv: { 683 return std::make_unique<SPIRVTargetInfo>(Triple, Opts); 684 } 685 case llvm::Triple::spirv32: { 686 if (os != llvm::Triple::UnknownOS || 687 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 688 return nullptr; 689 return std::make_unique<SPIRV32TargetInfo>(Triple, Opts); 690 } 691 case llvm::Triple::spirv64: { 692 if (os != llvm::Triple::UnknownOS || 693 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) { 694 if (os == llvm::Triple::OSType::AMDHSA) 695 return std::make_unique<SPIRV64AMDGCNTargetInfo>(Triple, Opts); 696 return nullptr; 697 } 698 return std::make_unique<SPIRV64TargetInfo>(Triple, Opts); 699 } 700 case llvm::Triple::wasm32: 701 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 702 Triple.getVendor() != llvm::Triple::UnknownVendor || 703 !Triple.isOSBinFormatWasm()) 704 return nullptr; 705 switch (os) { 706 case llvm::Triple::WASI: 707 return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(Triple, 708 Opts); 709 case llvm::Triple::Emscripten: 710 return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>( 711 Triple, Opts); 712 case llvm::Triple::UnknownOS: 713 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>( 714 Triple, Opts); 715 default: 716 return nullptr; 717 } 718 case llvm::Triple::wasm64: 719 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 720 Triple.getVendor() != llvm::Triple::UnknownVendor || 721 !Triple.isOSBinFormatWasm()) 722 return nullptr; 723 switch (os) { 724 case llvm::Triple::WASI: 725 return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(Triple, 726 Opts); 727 case llvm::Triple::Emscripten: 728 return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>( 729 Triple, Opts); 730 case llvm::Triple::UnknownOS: 731 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>( 732 Triple, Opts); 733 default: 734 return nullptr; 735 } 736 737 case llvm::Triple::dxil: 738 return std::make_unique<DirectXTargetInfo>(Triple, Opts); 739 740 case llvm::Triple::ve: 741 return std::make_unique<LinuxTargetInfo<VETargetInfo>>(Triple, Opts); 742 743 case llvm::Triple::csky: 744 switch (os) { 745 case llvm::Triple::Linux: 746 return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(Triple, Opts); 747 default: 748 return std::make_unique<CSKYTargetInfo>(Triple, Opts); 749 } 750 case llvm::Triple::loongarch32: 751 switch (os) { 752 case llvm::Triple::Linux: 753 return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple, 754 Opts); 755 default: 756 return std::make_unique<LoongArch32TargetInfo>(Triple, Opts); 757 } 758 case llvm::Triple::loongarch64: 759 switch (os) { 760 case llvm::Triple::Linux: 761 switch (Triple.getEnvironment()) { 762 default: 763 return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple, 764 Opts); 765 case llvm::Triple::OpenHOS: 766 return std::make_unique<OHOSTargetInfo<LoongArch64TargetInfo>>(Triple, 767 Opts); 768 } 769 case llvm::Triple::FreeBSD: 770 return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(Triple, 771 Opts); 772 case llvm::Triple::OpenBSD: 773 return std::make_unique<OpenBSDTargetInfo<LoongArch64TargetInfo>>(Triple, 774 Opts); 775 default: 776 return std::make_unique<LoongArch64TargetInfo>(Triple, Opts); 777 } 778 779 case llvm::Triple::xtensa: 780 return std::make_unique<XtensaTargetInfo>(Triple, Opts); 781 } 782 } 783 } // namespace targets 784 } // namespace clang 785 786 using namespace clang::targets; 787 /// CreateTargetInfo - Return the target info object for the specified target 788 /// options. 789 TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 790 TargetOptions &OptsRef) { 791 TargetOptions *Opts = &OptsRef; 792 793 llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple)); 794 795 // Construct the target 796 std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, *Opts); 797 if (!Target) { 798 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 799 return nullptr; 800 } 801 Target->TargetOpts = Opts; 802 803 // Set the target CPU if specified. 804 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 805 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 806 SmallVector<StringRef, 32> ValidList; 807 Target->fillValidCPUList(ValidList); 808 if (!ValidList.empty()) 809 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 810 return nullptr; 811 } 812 813 // Check the TuneCPU name if specified. 814 if (!Opts->TuneCPU.empty() && 815 !Target->isValidTuneCPUName(Opts->TuneCPU)) { 816 Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU; 817 SmallVector<StringRef, 32> ValidList; 818 Target->fillValidTuneCPUList(ValidList); 819 if (!ValidList.empty()) 820 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 821 return nullptr; 822 } 823 824 // Set the target ABI if specified. 825 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 826 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 827 return nullptr; 828 } 829 830 // Set the fp math unit. 831 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { 832 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; 833 return nullptr; 834 } 835 836 // Compute the default target features, we need the target to handle this 837 // because features may have dependencies on one another. 838 llvm::erase_if(Opts->FeaturesAsWritten, [&](StringRef Name) { 839 if (Target->isReadOnlyFeature(Name.substr(1))) { 840 Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name; 841 return true; 842 } 843 return false; 844 }); 845 if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU, 846 Opts->FeaturesAsWritten)) 847 return nullptr; 848 849 // Add the features to the compile options. 850 Opts->Features.clear(); 851 for (const auto &F : Opts->FeatureMap) 852 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str()); 853 // Sort here, so we handle the features in a predictable order. (This matters 854 // when we're dealing with features that overlap.) 855 llvm::sort(Opts->Features); 856 857 if (!Target->handleTargetFeatures(Opts->Features, Diags)) 858 return nullptr; 859 860 Target->setSupportedOpenCLOpts(); 861 Target->setCommandLineOpenCLOpts(); 862 Target->setMaxAtomicWidth(); 863 864 if (!Opts->DarwinTargetVariantTriple.empty()) 865 Target->DarwinTargetVariantTriple = 866 llvm::Triple(Opts->DarwinTargetVariantTriple); 867 868 if (!Target->validateTarget(Diags)) 869 return nullptr; 870 871 Target->CheckFixedPointBits(); 872 873 return Target.release(); 874 } 875 /// validateOpenCLTarget - Check that OpenCL target has valid 876 /// options setting based on OpenCL version. 877 bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts, 878 DiagnosticsEngine &Diags) const { 879 const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts(); 880 881 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) { 882 if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && 883 !hasFeatureEnabled(OpenCLFeaturesMap, Name)) 884 Diags.Report(diag::warn_opencl_unsupported_core_feature) 885 << Name << Opts.OpenCLCPlusPlus 886 << Opts.getOpenCLVersionTuple().getAsString(); 887 }; 888 #define OPENCL_GENERIC_EXTENSION(Ext, ...) \ 889 diagnoseNotSupportedCore(#Ext, __VA_ARGS__); 890 #include "clang/Basic/OpenCLExtensions.def" 891 892 // Validate that feature macros are set properly for OpenCL C 3.0. 893 // In other cases assume that target is always valid. 894 if (Opts.getOpenCLCompatibleVersion() < 300) 895 return true; 896 897 return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(*this, Diags) && 898 OpenCLOptions::diagnoseFeatureExtensionDifferences(*this, Diags); 899 } 900