1 //===--- Targets.cpp - Implement target feature support -------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements construction of a TargetInfo object from a 11 // target triple. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "Targets.h" 16 17 #include "Targets/AArch64.h" 18 #include "Targets/AMDGPU.h" 19 #include "Targets/ARM.h" 20 #include "Targets/AVR.h" 21 #include "Targets/BPF.h" 22 #include "Targets/Hexagon.h" 23 #include "Targets/Lanai.h" 24 #include "Targets/Le64.h" 25 #include "Targets/MSP430.h" 26 #include "Targets/Mips.h" 27 #include "Targets/NVPTX.h" 28 #include "Targets/Nios2.h" 29 #include "Targets/OSTargets.h" 30 #include "Targets/PNaCl.h" 31 #include "Targets/PPC.h" 32 #include "Targets/RISCV.h" 33 #include "Targets/SPIR.h" 34 #include "Targets/Sparc.h" 35 #include "Targets/SystemZ.h" 36 #include "Targets/TCE.h" 37 #include "Targets/WebAssembly.h" 38 #include "Targets/X86.h" 39 #include "Targets/XCore.h" 40 #include "clang/Basic/Diagnostic.h" 41 #include "llvm/ADT/StringExtras.h" 42 #include "llvm/ADT/Triple.h" 43 44 using namespace clang; 45 46 namespace clang { 47 namespace targets { 48 //===----------------------------------------------------------------------===// 49 // Common code shared among targets. 50 //===----------------------------------------------------------------------===// 51 52 /// DefineStd - Define a macro name and standard variants. For example if 53 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix" 54 /// when in GNU mode. 55 void DefineStd(MacroBuilder &Builder, StringRef MacroName, 56 const LangOptions &Opts) { 57 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace"); 58 59 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier 60 // in the user's namespace. 61 if (Opts.GNUMode) 62 Builder.defineMacro(MacroName); 63 64 // Define __unix. 65 Builder.defineMacro("__" + MacroName); 66 67 // Define __unix__. 68 Builder.defineMacro("__" + MacroName + "__"); 69 } 70 71 void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) { 72 Builder.defineMacro("__" + CPUName); 73 Builder.defineMacro("__" + CPUName + "__"); 74 if (Tuning) 75 Builder.defineMacro("__tune_" + CPUName + "__"); 76 } 77 78 void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) { 79 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang 80 // supports __declspec natively under -fms-extensions, but we define a no-op 81 // __declspec macro anyway for pre-processor compatibility. 82 if (Opts.MicrosoftExt) 83 Builder.defineMacro("__declspec", "__declspec"); 84 else 85 Builder.defineMacro("__declspec(a)", "__attribute__((a))"); 86 87 if (!Opts.MicrosoftExt) { 88 // Provide macros for all the calling convention keywords. Provide both 89 // single and double underscore prefixed variants. These are available on 90 // x64 as well as x86, even though they have no effect. 91 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"}; 92 for (const char *CC : CCs) { 93 std::string GCCSpelling = "__attribute__((__"; 94 GCCSpelling += CC; 95 GCCSpelling += "__))"; 96 Builder.defineMacro(Twine("_") + CC, GCCSpelling); 97 Builder.defineMacro(Twine("__") + CC, GCCSpelling); 98 } 99 } 100 } 101 102 void addMinGWDefines(const llvm::Triple &Triple, const LangOptions &Opts, 103 MacroBuilder &Builder) { 104 DefineStd(Builder, "WIN32", Opts); 105 DefineStd(Builder, "WINNT", Opts); 106 if (Triple.isArch64Bit()) { 107 DefineStd(Builder, "WIN64", Opts); 108 Builder.defineMacro("__MINGW64__"); 109 } 110 Builder.defineMacro("__MSVCRT__"); 111 Builder.defineMacro("__MINGW32__"); 112 addCygMingDefines(Opts, Builder); 113 } 114 115 void defineCudaArchMacro(CudaArch GPU, clang::MacroBuilder &Builder) { 116 std::string CUDAArchCode = [GPU] { 117 switch (GPU) { 118 case CudaArch::LAST: 119 break; 120 case CudaArch::SM_20: 121 return "200"; 122 case CudaArch::SM_21: 123 return "210"; 124 case CudaArch::SM_30: 125 return "300"; 126 case CudaArch::SM_32: 127 return "320"; 128 case CudaArch::SM_35: 129 return "350"; 130 case CudaArch::SM_37: 131 return "370"; 132 case CudaArch::SM_50: 133 return "500"; 134 case CudaArch::SM_52: 135 return "520"; 136 case CudaArch::SM_53: 137 return "530"; 138 case CudaArch::SM_60: 139 return "600"; 140 case CudaArch::SM_61: 141 return "610"; 142 case CudaArch::SM_62: 143 return "620"; 144 case CudaArch::SM_70: 145 return "700"; 146 case CudaArch::SM_72: 147 return "720"; 148 case CudaArch::GFX600: 149 case CudaArch::GFX601: 150 case CudaArch::GFX700: 151 case CudaArch::GFX701: 152 case CudaArch::GFX702: 153 case CudaArch::GFX703: 154 case CudaArch::GFX704: 155 case CudaArch::GFX801: 156 case CudaArch::GFX802: 157 case CudaArch::GFX803: 158 case CudaArch::GFX810: 159 case CudaArch::GFX900: 160 case CudaArch::GFX902: 161 return "320"; 162 case CudaArch::UNKNOWN: 163 llvm_unreachable("unhandled Cuda/HIP Arch"); 164 } 165 llvm_unreachable("unhandled Cuda/HIP Arch"); 166 }(); 167 Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode); 168 } 169 170 //===----------------------------------------------------------------------===// 171 // Driver code 172 //===----------------------------------------------------------------------===// 173 174 TargetInfo *AllocateTarget(const llvm::Triple &Triple, 175 const TargetOptions &Opts) { 176 llvm::Triple::OSType os = Triple.getOS(); 177 178 switch (Triple.getArch()) { 179 default: 180 return nullptr; 181 182 case llvm::Triple::xcore: 183 return new XCoreTargetInfo(Triple, Opts); 184 185 case llvm::Triple::hexagon: 186 return new HexagonTargetInfo(Triple, Opts); 187 188 case llvm::Triple::lanai: 189 return new LanaiTargetInfo(Triple, Opts); 190 191 case llvm::Triple::aarch64: 192 if (Triple.isOSDarwin()) 193 return new DarwinAArch64TargetInfo(Triple, Opts); 194 195 switch (os) { 196 case llvm::Triple::CloudABI: 197 return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts); 198 case llvm::Triple::FreeBSD: 199 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 200 case llvm::Triple::Fuchsia: 201 return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts); 202 case llvm::Triple::Linux: 203 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts); 204 case llvm::Triple::NetBSD: 205 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 206 case llvm::Triple::OpenBSD: 207 return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 208 case llvm::Triple::Win32: 209 switch (Triple.getEnvironment()) { 210 case llvm::Triple::GNU: 211 return new MinGWARM64TargetInfo(Triple, Opts); 212 case llvm::Triple::MSVC: 213 default: // Assume MSVC for unknown environments 214 return new MicrosoftARM64TargetInfo(Triple, Opts); 215 } 216 default: 217 return new AArch64leTargetInfo(Triple, Opts); 218 } 219 220 case llvm::Triple::aarch64_be: 221 switch (os) { 222 case llvm::Triple::FreeBSD: 223 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); 224 case llvm::Triple::Fuchsia: 225 return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts); 226 case llvm::Triple::Linux: 227 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts); 228 case llvm::Triple::NetBSD: 229 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); 230 default: 231 return new AArch64beTargetInfo(Triple, Opts); 232 } 233 234 case llvm::Triple::arm: 235 case llvm::Triple::thumb: 236 if (Triple.isOSBinFormatMachO()) 237 return new DarwinARMTargetInfo(Triple, Opts); 238 239 switch (os) { 240 case llvm::Triple::CloudABI: 241 return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts); 242 case llvm::Triple::Linux: 243 return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts); 244 case llvm::Triple::FreeBSD: 245 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 246 case llvm::Triple::NetBSD: 247 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 248 case llvm::Triple::OpenBSD: 249 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 250 case llvm::Triple::RTEMS: 251 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts); 252 case llvm::Triple::NaCl: 253 return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts); 254 case llvm::Triple::Win32: 255 switch (Triple.getEnvironment()) { 256 case llvm::Triple::Cygnus: 257 return new CygwinARMTargetInfo(Triple, Opts); 258 case llvm::Triple::GNU: 259 return new MinGWARMTargetInfo(Triple, Opts); 260 case llvm::Triple::Itanium: 261 return new ItaniumWindowsARMleTargetInfo(Triple, Opts); 262 case llvm::Triple::MSVC: 263 default: // Assume MSVC for unknown environments 264 return new MicrosoftARMleTargetInfo(Triple, Opts); 265 } 266 default: 267 return new ARMleTargetInfo(Triple, Opts); 268 } 269 270 case llvm::Triple::armeb: 271 case llvm::Triple::thumbeb: 272 if (Triple.isOSDarwin()) 273 return new DarwinARMTargetInfo(Triple, Opts); 274 275 switch (os) { 276 case llvm::Triple::Linux: 277 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts); 278 case llvm::Triple::FreeBSD: 279 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 280 case llvm::Triple::NetBSD: 281 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 282 case llvm::Triple::OpenBSD: 283 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 284 case llvm::Triple::RTEMS: 285 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts); 286 case llvm::Triple::NaCl: 287 return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts); 288 default: 289 return new ARMbeTargetInfo(Triple, Opts); 290 } 291 292 case llvm::Triple::avr: 293 return new AVRTargetInfo(Triple, Opts); 294 case llvm::Triple::bpfeb: 295 case llvm::Triple::bpfel: 296 return new BPFTargetInfo(Triple, Opts); 297 298 case llvm::Triple::msp430: 299 return new MSP430TargetInfo(Triple, Opts); 300 301 case llvm::Triple::nios2: 302 return new LinuxTargetInfo<Nios2TargetInfo>(Triple, Opts); 303 304 case llvm::Triple::mips: 305 switch (os) { 306 case llvm::Triple::Linux: 307 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 308 case llvm::Triple::RTEMS: 309 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 310 case llvm::Triple::FreeBSD: 311 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 312 case llvm::Triple::NetBSD: 313 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 314 default: 315 return new MipsTargetInfo(Triple, Opts); 316 } 317 318 case llvm::Triple::mipsel: 319 switch (os) { 320 case llvm::Triple::Linux: 321 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 322 case llvm::Triple::RTEMS: 323 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 324 case llvm::Triple::FreeBSD: 325 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 326 case llvm::Triple::NetBSD: 327 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 328 case llvm::Triple::NaCl: 329 return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts); 330 default: 331 return new MipsTargetInfo(Triple, Opts); 332 } 333 334 case llvm::Triple::mips64: 335 switch (os) { 336 case llvm::Triple::Linux: 337 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 338 case llvm::Triple::RTEMS: 339 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 340 case llvm::Triple::FreeBSD: 341 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 342 case llvm::Triple::NetBSD: 343 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 344 case llvm::Triple::OpenBSD: 345 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 346 default: 347 return new MipsTargetInfo(Triple, Opts); 348 } 349 350 case llvm::Triple::mips64el: 351 switch (os) { 352 case llvm::Triple::Linux: 353 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 354 case llvm::Triple::RTEMS: 355 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 356 case llvm::Triple::FreeBSD: 357 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 358 case llvm::Triple::NetBSD: 359 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 360 case llvm::Triple::OpenBSD: 361 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 362 default: 363 return new MipsTargetInfo(Triple, Opts); 364 } 365 366 case llvm::Triple::le32: 367 switch (os) { 368 case llvm::Triple::NaCl: 369 return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts); 370 default: 371 return nullptr; 372 } 373 374 case llvm::Triple::le64: 375 return new Le64TargetInfo(Triple, Opts); 376 377 case llvm::Triple::ppc: 378 if (Triple.isOSDarwin()) 379 return new DarwinPPC32TargetInfo(Triple, Opts); 380 switch (os) { 381 case llvm::Triple::Linux: 382 return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts); 383 case llvm::Triple::FreeBSD: 384 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 385 case llvm::Triple::NetBSD: 386 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 387 case llvm::Triple::OpenBSD: 388 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 389 case llvm::Triple::RTEMS: 390 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts); 391 default: 392 return new PPC32TargetInfo(Triple, Opts); 393 } 394 395 case llvm::Triple::ppc64: 396 if (Triple.isOSDarwin()) 397 return new DarwinPPC64TargetInfo(Triple, Opts); 398 switch (os) { 399 case llvm::Triple::Linux: 400 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 401 case llvm::Triple::Lv2: 402 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts); 403 case llvm::Triple::FreeBSD: 404 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 405 case llvm::Triple::NetBSD: 406 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 407 default: 408 return new PPC64TargetInfo(Triple, Opts); 409 } 410 411 case llvm::Triple::ppc64le: 412 switch (os) { 413 case llvm::Triple::Linux: 414 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 415 case llvm::Triple::NetBSD: 416 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 417 default: 418 return new PPC64TargetInfo(Triple, Opts); 419 } 420 421 case llvm::Triple::nvptx: 422 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32); 423 case llvm::Triple::nvptx64: 424 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64); 425 426 case llvm::Triple::amdgcn: 427 case llvm::Triple::r600: 428 return new AMDGPUTargetInfo(Triple, Opts); 429 430 case llvm::Triple::riscv32: 431 // TODO: add cases for FreeBSD, NetBSD, RTEMS once tested. 432 if (os == llvm::Triple::Linux) 433 return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts); 434 return new RISCV32TargetInfo(Triple, Opts); 435 case llvm::Triple::riscv64: 436 // TODO: add cases for FreeBSD, NetBSD, RTEMS once tested. 437 if (os == llvm::Triple::Linux) 438 return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts); 439 return new RISCV64TargetInfo(Triple, Opts); 440 441 case llvm::Triple::sparc: 442 switch (os) { 443 case llvm::Triple::Linux: 444 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts); 445 case llvm::Triple::Solaris: 446 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts); 447 case llvm::Triple::NetBSD: 448 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); 449 case llvm::Triple::OpenBSD: 450 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); 451 case llvm::Triple::RTEMS: 452 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts); 453 default: 454 return new SparcV8TargetInfo(Triple, Opts); 455 } 456 457 // The 'sparcel' architecture copies all the above cases except for Solaris. 458 case llvm::Triple::sparcel: 459 switch (os) { 460 case llvm::Triple::Linux: 461 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 462 case llvm::Triple::NetBSD: 463 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 464 case llvm::Triple::OpenBSD: 465 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 466 case llvm::Triple::RTEMS: 467 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 468 default: 469 return new SparcV8elTargetInfo(Triple, Opts); 470 } 471 472 case llvm::Triple::sparcv9: 473 switch (os) { 474 case llvm::Triple::Linux: 475 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts); 476 case llvm::Triple::Solaris: 477 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts); 478 case llvm::Triple::NetBSD: 479 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 480 case llvm::Triple::OpenBSD: 481 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 482 case llvm::Triple::FreeBSD: 483 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 484 default: 485 return new SparcV9TargetInfo(Triple, Opts); 486 } 487 488 case llvm::Triple::systemz: 489 switch (os) { 490 case llvm::Triple::Linux: 491 return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts); 492 default: 493 return new SystemZTargetInfo(Triple, Opts); 494 } 495 496 case llvm::Triple::tce: 497 return new TCETargetInfo(Triple, Opts); 498 499 case llvm::Triple::tcele: 500 return new TCELETargetInfo(Triple, Opts); 501 502 case llvm::Triple::x86: 503 if (Triple.isOSDarwin()) 504 return new DarwinI386TargetInfo(Triple, Opts); 505 506 switch (os) { 507 case llvm::Triple::Ananas: 508 return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts); 509 case llvm::Triple::CloudABI: 510 return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts); 511 case llvm::Triple::Linux: { 512 switch (Triple.getEnvironment()) { 513 default: 514 return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts); 515 case llvm::Triple::Android: 516 return new AndroidX86_32TargetInfo(Triple, Opts); 517 } 518 } 519 case llvm::Triple::DragonFly: 520 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 521 case llvm::Triple::NetBSD: 522 return new NetBSDI386TargetInfo(Triple, Opts); 523 case llvm::Triple::OpenBSD: 524 return new OpenBSDI386TargetInfo(Triple, Opts); 525 case llvm::Triple::FreeBSD: 526 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 527 case llvm::Triple::KFreeBSD: 528 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 529 case llvm::Triple::Minix: 530 return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts); 531 case llvm::Triple::Solaris: 532 return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts); 533 case llvm::Triple::Win32: { 534 switch (Triple.getEnvironment()) { 535 case llvm::Triple::Cygnus: 536 return new CygwinX86_32TargetInfo(Triple, Opts); 537 case llvm::Triple::GNU: 538 return new MinGWX86_32TargetInfo(Triple, Opts); 539 case llvm::Triple::Itanium: 540 case llvm::Triple::MSVC: 541 default: // Assume MSVC for unknown environments 542 return new MicrosoftX86_32TargetInfo(Triple, Opts); 543 } 544 } 545 case llvm::Triple::Haiku: 546 return new HaikuX86_32TargetInfo(Triple, Opts); 547 case llvm::Triple::RTEMS: 548 return new RTEMSX86_32TargetInfo(Triple, Opts); 549 case llvm::Triple::NaCl: 550 return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts); 551 case llvm::Triple::ELFIAMCU: 552 return new MCUX86_32TargetInfo(Triple, Opts); 553 default: 554 return new X86_32TargetInfo(Triple, Opts); 555 } 556 557 case llvm::Triple::x86_64: 558 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) 559 return new DarwinX86_64TargetInfo(Triple, Opts); 560 561 switch (os) { 562 case llvm::Triple::Ananas: 563 return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts); 564 case llvm::Triple::CloudABI: 565 return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts); 566 case llvm::Triple::Linux: { 567 switch (Triple.getEnvironment()) { 568 default: 569 return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts); 570 case llvm::Triple::Android: 571 return new AndroidX86_64TargetInfo(Triple, Opts); 572 } 573 } 574 case llvm::Triple::DragonFly: 575 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 576 case llvm::Triple::NetBSD: 577 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 578 case llvm::Triple::OpenBSD: 579 return new OpenBSDX86_64TargetInfo(Triple, Opts); 580 case llvm::Triple::FreeBSD: 581 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 582 case llvm::Triple::Fuchsia: 583 return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts); 584 case llvm::Triple::KFreeBSD: 585 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 586 case llvm::Triple::Solaris: 587 return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts); 588 case llvm::Triple::Win32: { 589 switch (Triple.getEnvironment()) { 590 case llvm::Triple::Cygnus: 591 return new CygwinX86_64TargetInfo(Triple, Opts); 592 case llvm::Triple::GNU: 593 return new MinGWX86_64TargetInfo(Triple, Opts); 594 case llvm::Triple::MSVC: 595 default: // Assume MSVC for unknown environments 596 return new MicrosoftX86_64TargetInfo(Triple, Opts); 597 } 598 } 599 case llvm::Triple::Haiku: 600 return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts); 601 case llvm::Triple::NaCl: 602 return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts); 603 case llvm::Triple::PS4: 604 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts); 605 default: 606 return new X86_64TargetInfo(Triple, Opts); 607 } 608 609 case llvm::Triple::spir: { 610 if (Triple.getOS() != llvm::Triple::UnknownOS || 611 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 612 return nullptr; 613 return new SPIR32TargetInfo(Triple, Opts); 614 } 615 case llvm::Triple::spir64: { 616 if (Triple.getOS() != llvm::Triple::UnknownOS || 617 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 618 return nullptr; 619 return new SPIR64TargetInfo(Triple, Opts); 620 } 621 case llvm::Triple::wasm32: 622 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 623 Triple.getVendor() != llvm::Triple::UnknownVendor || 624 Triple.getOS() != llvm::Triple::UnknownOS || 625 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment || 626 !(Triple.isOSBinFormatELF() || Triple.isOSBinFormatWasm())) 627 return nullptr; 628 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts); 629 case llvm::Triple::wasm64: 630 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 631 Triple.getVendor() != llvm::Triple::UnknownVendor || 632 Triple.getOS() != llvm::Triple::UnknownOS || 633 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment || 634 !(Triple.isOSBinFormatELF() || Triple.isOSBinFormatWasm())) 635 return nullptr; 636 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts); 637 638 case llvm::Triple::renderscript32: 639 return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts); 640 case llvm::Triple::renderscript64: 641 return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts); 642 } 643 } 644 } // namespace targets 645 } // namespace clang 646 647 using namespace clang::targets; 648 /// CreateTargetInfo - Return the target info object for the specified target 649 /// options. 650 TargetInfo * 651 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 652 const std::shared_ptr<TargetOptions> &Opts) { 653 llvm::Triple Triple(Opts->Triple); 654 655 // Construct the target 656 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts)); 657 if (!Target) { 658 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 659 return nullptr; 660 } 661 Target->TargetOpts = Opts; 662 663 // Set the target CPU if specified. 664 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 665 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 666 SmallVector<StringRef, 32> ValidList; 667 Target->fillValidCPUList(ValidList); 668 if (!ValidList.empty()) 669 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 670 return nullptr; 671 } 672 673 // Set the target ABI if specified. 674 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 675 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 676 return nullptr; 677 } 678 679 // Set the fp math unit. 680 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { 681 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; 682 return nullptr; 683 } 684 685 // Compute the default target features, we need the target to handle this 686 // because features may have dependencies on one another. 687 llvm::StringMap<bool> Features; 688 if (!Target->initFeatureMap(Features, Diags, Opts->CPU, 689 Opts->FeaturesAsWritten)) 690 return nullptr; 691 692 // Add the features to the compile options. 693 Opts->Features.clear(); 694 for (const auto &F : Features) 695 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str()); 696 697 if (!Target->handleTargetFeatures(Opts->Features, Diags)) 698 return nullptr; 699 700 Target->setSupportedOpenCLOpts(); 701 Target->setOpenCLExtensionOpts(); 702 Target->setMaxAtomicWidth(); 703 704 if (!Target->validateTarget(Diags)) 705 return nullptr; 706 707 return Target.release(); 708 } 709