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