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