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/ARC.h" 20 #include "Targets/ARM.h" 21 #include "Targets/AVR.h" 22 #include "Targets/BPF.h" 23 #include "Targets/Hexagon.h" 24 #include "Targets/Lanai.h" 25 #include "Targets/Le64.h" 26 #include "Targets/MSP430.h" 27 #include "Targets/Mips.h" 28 #include "Targets/NVPTX.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 //===----------------------------------------------------------------------===// 116 // Driver code 117 //===----------------------------------------------------------------------===// 118 119 TargetInfo *AllocateTarget(const llvm::Triple &Triple, 120 const TargetOptions &Opts) { 121 llvm::Triple::OSType os = Triple.getOS(); 122 123 switch (Triple.getArch()) { 124 default: 125 return nullptr; 126 127 case llvm::Triple::arc: 128 return new ARCTargetInfo(Triple, Opts); 129 130 case llvm::Triple::xcore: 131 return new XCoreTargetInfo(Triple, Opts); 132 133 case llvm::Triple::hexagon: 134 return new HexagonTargetInfo(Triple, Opts); 135 136 case llvm::Triple::lanai: 137 return new LanaiTargetInfo(Triple, Opts); 138 139 case llvm::Triple::aarch64: 140 if (Triple.isOSDarwin()) 141 return new DarwinAArch64TargetInfo(Triple, Opts); 142 143 switch (os) { 144 case llvm::Triple::CloudABI: 145 return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts); 146 case llvm::Triple::FreeBSD: 147 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 148 case llvm::Triple::Fuchsia: 149 return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts); 150 case llvm::Triple::Linux: 151 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts); 152 case llvm::Triple::NetBSD: 153 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 154 case llvm::Triple::OpenBSD: 155 return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); 156 case llvm::Triple::Win32: 157 switch (Triple.getEnvironment()) { 158 case llvm::Triple::GNU: 159 return new MinGWARM64TargetInfo(Triple, Opts); 160 case llvm::Triple::MSVC: 161 default: // Assume MSVC for unknown environments 162 return new MicrosoftARM64TargetInfo(Triple, Opts); 163 } 164 default: 165 return new AArch64leTargetInfo(Triple, Opts); 166 } 167 168 case llvm::Triple::aarch64_be: 169 switch (os) { 170 case llvm::Triple::FreeBSD: 171 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); 172 case llvm::Triple::Fuchsia: 173 return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts); 174 case llvm::Triple::Linux: 175 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts); 176 case llvm::Triple::NetBSD: 177 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); 178 default: 179 return new AArch64beTargetInfo(Triple, Opts); 180 } 181 182 case llvm::Triple::arm: 183 case llvm::Triple::thumb: 184 if (Triple.isOSBinFormatMachO()) 185 return new DarwinARMTargetInfo(Triple, Opts); 186 187 switch (os) { 188 case llvm::Triple::CloudABI: 189 return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts); 190 case llvm::Triple::Linux: 191 return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts); 192 case llvm::Triple::FreeBSD: 193 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 194 case llvm::Triple::NetBSD: 195 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 196 case llvm::Triple::OpenBSD: 197 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); 198 case llvm::Triple::RTEMS: 199 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts); 200 case llvm::Triple::NaCl: 201 return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts); 202 case llvm::Triple::Win32: 203 switch (Triple.getEnvironment()) { 204 case llvm::Triple::Cygnus: 205 return new CygwinARMTargetInfo(Triple, Opts); 206 case llvm::Triple::GNU: 207 return new MinGWARMTargetInfo(Triple, Opts); 208 case llvm::Triple::Itanium: 209 return new ItaniumWindowsARMleTargetInfo(Triple, Opts); 210 case llvm::Triple::MSVC: 211 default: // Assume MSVC for unknown environments 212 return new MicrosoftARMleTargetInfo(Triple, Opts); 213 } 214 default: 215 return new ARMleTargetInfo(Triple, Opts); 216 } 217 218 case llvm::Triple::armeb: 219 case llvm::Triple::thumbeb: 220 if (Triple.isOSDarwin()) 221 return new DarwinARMTargetInfo(Triple, Opts); 222 223 switch (os) { 224 case llvm::Triple::Linux: 225 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts); 226 case llvm::Triple::FreeBSD: 227 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 228 case llvm::Triple::NetBSD: 229 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 230 case llvm::Triple::OpenBSD: 231 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); 232 case llvm::Triple::RTEMS: 233 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts); 234 case llvm::Triple::NaCl: 235 return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts); 236 default: 237 return new ARMbeTargetInfo(Triple, Opts); 238 } 239 240 case llvm::Triple::avr: 241 return new AVRTargetInfo(Triple, Opts); 242 case llvm::Triple::bpfeb: 243 case llvm::Triple::bpfel: 244 return new BPFTargetInfo(Triple, Opts); 245 246 case llvm::Triple::msp430: 247 return new MSP430TargetInfo(Triple, Opts); 248 249 case llvm::Triple::mips: 250 switch (os) { 251 case llvm::Triple::Linux: 252 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 253 case llvm::Triple::RTEMS: 254 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 255 case llvm::Triple::FreeBSD: 256 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 257 case llvm::Triple::NetBSD: 258 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 259 default: 260 return new MipsTargetInfo(Triple, Opts); 261 } 262 263 case llvm::Triple::mipsel: 264 switch (os) { 265 case llvm::Triple::Linux: 266 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 267 case llvm::Triple::RTEMS: 268 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 269 case llvm::Triple::FreeBSD: 270 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 271 case llvm::Triple::NetBSD: 272 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 273 case llvm::Triple::NaCl: 274 return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts); 275 default: 276 return new MipsTargetInfo(Triple, Opts); 277 } 278 279 case llvm::Triple::mips64: 280 switch (os) { 281 case llvm::Triple::Linux: 282 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 283 case llvm::Triple::RTEMS: 284 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 285 case llvm::Triple::FreeBSD: 286 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 287 case llvm::Triple::NetBSD: 288 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 289 case llvm::Triple::OpenBSD: 290 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 291 default: 292 return new MipsTargetInfo(Triple, Opts); 293 } 294 295 case llvm::Triple::mips64el: 296 switch (os) { 297 case llvm::Triple::Linux: 298 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 299 case llvm::Triple::RTEMS: 300 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 301 case llvm::Triple::FreeBSD: 302 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 303 case llvm::Triple::NetBSD: 304 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 305 case llvm::Triple::OpenBSD: 306 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 307 default: 308 return new MipsTargetInfo(Triple, Opts); 309 } 310 311 case llvm::Triple::le32: 312 switch (os) { 313 case llvm::Triple::NaCl: 314 return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts); 315 default: 316 return nullptr; 317 } 318 319 case llvm::Triple::le64: 320 return new Le64TargetInfo(Triple, Opts); 321 322 case llvm::Triple::ppc: 323 if (Triple.isOSDarwin()) 324 return new DarwinPPC32TargetInfo(Triple, Opts); 325 switch (os) { 326 case llvm::Triple::Linux: 327 return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts); 328 case llvm::Triple::FreeBSD: 329 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 330 case llvm::Triple::NetBSD: 331 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 332 case llvm::Triple::OpenBSD: 333 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 334 case llvm::Triple::RTEMS: 335 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts); 336 default: 337 return new PPC32TargetInfo(Triple, Opts); 338 } 339 340 case llvm::Triple::ppc64: 341 if (Triple.isOSDarwin()) 342 return new DarwinPPC64TargetInfo(Triple, Opts); 343 switch (os) { 344 case llvm::Triple::Linux: 345 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 346 case llvm::Triple::Lv2: 347 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts); 348 case llvm::Triple::FreeBSD: 349 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 350 case llvm::Triple::NetBSD: 351 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 352 default: 353 return new PPC64TargetInfo(Triple, Opts); 354 } 355 356 case llvm::Triple::ppc64le: 357 switch (os) { 358 case llvm::Triple::Linux: 359 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 360 case llvm::Triple::NetBSD: 361 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 362 default: 363 return new PPC64TargetInfo(Triple, Opts); 364 } 365 366 case llvm::Triple::nvptx: 367 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32); 368 case llvm::Triple::nvptx64: 369 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64); 370 371 case llvm::Triple::amdgcn: 372 case llvm::Triple::r600: 373 return new AMDGPUTargetInfo(Triple, Opts); 374 375 case llvm::Triple::riscv32: 376 // TODO: add cases for FreeBSD, NetBSD, RTEMS once tested. 377 if (os == llvm::Triple::Linux) 378 return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts); 379 return new RISCV32TargetInfo(Triple, Opts); 380 case llvm::Triple::riscv64: 381 // TODO: add cases for FreeBSD, NetBSD, RTEMS once tested. 382 if (os == llvm::Triple::Linux) 383 return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts); 384 return new RISCV64TargetInfo(Triple, Opts); 385 386 case llvm::Triple::sparc: 387 switch (os) { 388 case llvm::Triple::Linux: 389 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts); 390 case llvm::Triple::Solaris: 391 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts); 392 case llvm::Triple::NetBSD: 393 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); 394 case llvm::Triple::OpenBSD: 395 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); 396 case llvm::Triple::RTEMS: 397 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts); 398 default: 399 return new SparcV8TargetInfo(Triple, Opts); 400 } 401 402 // The 'sparcel' architecture copies all the above cases except for Solaris. 403 case llvm::Triple::sparcel: 404 switch (os) { 405 case llvm::Triple::Linux: 406 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 407 case llvm::Triple::NetBSD: 408 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 409 case llvm::Triple::OpenBSD: 410 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 411 case llvm::Triple::RTEMS: 412 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 413 default: 414 return new SparcV8elTargetInfo(Triple, Opts); 415 } 416 417 case llvm::Triple::sparcv9: 418 switch (os) { 419 case llvm::Triple::Linux: 420 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts); 421 case llvm::Triple::Solaris: 422 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts); 423 case llvm::Triple::NetBSD: 424 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 425 case llvm::Triple::OpenBSD: 426 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 427 case llvm::Triple::FreeBSD: 428 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 429 default: 430 return new SparcV9TargetInfo(Triple, Opts); 431 } 432 433 case llvm::Triple::systemz: 434 switch (os) { 435 case llvm::Triple::Linux: 436 return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts); 437 default: 438 return new SystemZTargetInfo(Triple, Opts); 439 } 440 441 case llvm::Triple::tce: 442 return new TCETargetInfo(Triple, Opts); 443 444 case llvm::Triple::tcele: 445 return new TCELETargetInfo(Triple, Opts); 446 447 case llvm::Triple::x86: 448 if (Triple.isOSDarwin()) 449 return new DarwinI386TargetInfo(Triple, Opts); 450 451 switch (os) { 452 case llvm::Triple::Ananas: 453 return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts); 454 case llvm::Triple::CloudABI: 455 return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts); 456 case llvm::Triple::Linux: { 457 switch (Triple.getEnvironment()) { 458 default: 459 return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts); 460 case llvm::Triple::Android: 461 return new AndroidX86_32TargetInfo(Triple, Opts); 462 } 463 } 464 case llvm::Triple::DragonFly: 465 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 466 case llvm::Triple::NetBSD: 467 return new NetBSDI386TargetInfo(Triple, Opts); 468 case llvm::Triple::OpenBSD: 469 return new OpenBSDI386TargetInfo(Triple, Opts); 470 case llvm::Triple::FreeBSD: 471 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 472 case llvm::Triple::KFreeBSD: 473 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 474 case llvm::Triple::Minix: 475 return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts); 476 case llvm::Triple::Solaris: 477 return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts); 478 case llvm::Triple::Win32: { 479 switch (Triple.getEnvironment()) { 480 case llvm::Triple::Cygnus: 481 return new CygwinX86_32TargetInfo(Triple, Opts); 482 case llvm::Triple::GNU: 483 return new MinGWX86_32TargetInfo(Triple, Opts); 484 case llvm::Triple::Itanium: 485 case llvm::Triple::MSVC: 486 default: // Assume MSVC for unknown environments 487 return new MicrosoftX86_32TargetInfo(Triple, Opts); 488 } 489 } 490 case llvm::Triple::Haiku: 491 return new HaikuX86_32TargetInfo(Triple, Opts); 492 case llvm::Triple::RTEMS: 493 return new RTEMSX86_32TargetInfo(Triple, Opts); 494 case llvm::Triple::NaCl: 495 return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts); 496 case llvm::Triple::ELFIAMCU: 497 return new MCUX86_32TargetInfo(Triple, Opts); 498 case llvm::Triple::Hurd: 499 return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts); 500 default: 501 return new X86_32TargetInfo(Triple, Opts); 502 } 503 504 case llvm::Triple::x86_64: 505 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) 506 return new DarwinX86_64TargetInfo(Triple, Opts); 507 508 switch (os) { 509 case llvm::Triple::Ananas: 510 return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts); 511 case llvm::Triple::CloudABI: 512 return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts); 513 case llvm::Triple::Linux: { 514 switch (Triple.getEnvironment()) { 515 default: 516 return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts); 517 case llvm::Triple::Android: 518 return new AndroidX86_64TargetInfo(Triple, Opts); 519 } 520 } 521 case llvm::Triple::DragonFly: 522 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 523 case llvm::Triple::NetBSD: 524 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 525 case llvm::Triple::OpenBSD: 526 return new OpenBSDX86_64TargetInfo(Triple, Opts); 527 case llvm::Triple::FreeBSD: 528 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 529 case llvm::Triple::Fuchsia: 530 return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts); 531 case llvm::Triple::KFreeBSD: 532 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 533 case llvm::Triple::Solaris: 534 return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts); 535 case llvm::Triple::Win32: { 536 switch (Triple.getEnvironment()) { 537 case llvm::Triple::Cygnus: 538 return new CygwinX86_64TargetInfo(Triple, Opts); 539 case llvm::Triple::GNU: 540 return new MinGWX86_64TargetInfo(Triple, Opts); 541 case llvm::Triple::MSVC: 542 default: // Assume MSVC for unknown environments 543 return new MicrosoftX86_64TargetInfo(Triple, Opts); 544 } 545 } 546 case llvm::Triple::Haiku: 547 return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts); 548 case llvm::Triple::NaCl: 549 return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts); 550 case llvm::Triple::PS4: 551 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts); 552 default: 553 return new X86_64TargetInfo(Triple, Opts); 554 } 555 556 case llvm::Triple::spir: { 557 if (Triple.getOS() != llvm::Triple::UnknownOS || 558 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 559 return nullptr; 560 return new SPIR32TargetInfo(Triple, Opts); 561 } 562 case llvm::Triple::spir64: { 563 if (Triple.getOS() != llvm::Triple::UnknownOS || 564 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 565 return nullptr; 566 return new SPIR64TargetInfo(Triple, Opts); 567 } 568 case llvm::Triple::wasm32: 569 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 570 Triple.getVendor() != llvm::Triple::UnknownVendor || 571 !Triple.isOSBinFormatWasm()) 572 return nullptr; 573 switch (Triple.getOS()) { 574 case llvm::Triple::WASI: 575 return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts); 576 case llvm::Triple::UnknownOS: 577 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts); 578 default: 579 return nullptr; 580 } 581 case llvm::Triple::wasm64: 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<WebAssembly64TargetInfo>(Triple, Opts); 589 case llvm::Triple::UnknownOS: 590 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts); 591 default: 592 return nullptr; 593 } 594 595 case llvm::Triple::renderscript32: 596 return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts); 597 case llvm::Triple::renderscript64: 598 return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts); 599 } 600 } 601 } // namespace targets 602 } // namespace clang 603 604 using namespace clang::targets; 605 /// CreateTargetInfo - Return the target info object for the specified target 606 /// options. 607 TargetInfo * 608 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 609 const std::shared_ptr<TargetOptions> &Opts) { 610 llvm::Triple Triple(Opts->Triple); 611 612 // Construct the target 613 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts)); 614 if (!Target) { 615 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 616 return nullptr; 617 } 618 Target->TargetOpts = Opts; 619 620 // Set the target CPU if specified. 621 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 622 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 623 SmallVector<StringRef, 32> ValidList; 624 Target->fillValidCPUList(ValidList); 625 if (!ValidList.empty()) 626 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 627 return nullptr; 628 } 629 630 // Set the target ABI if specified. 631 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 632 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 633 return nullptr; 634 } 635 636 // Set the fp math unit. 637 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { 638 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; 639 return nullptr; 640 } 641 642 // Compute the default target features, we need the target to handle this 643 // because features may have dependencies on one another. 644 llvm::StringMap<bool> Features; 645 if (!Target->initFeatureMap(Features, Diags, Opts->CPU, 646 Opts->FeaturesAsWritten)) 647 return nullptr; 648 649 // Add the features to the compile options. 650 Opts->Features.clear(); 651 for (const auto &F : Features) 652 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str()); 653 // Sort here, so we handle the features in a predictable order. (This matters 654 // when we're dealing with features that overlap.) 655 llvm::sort(Opts->Features); 656 657 if (!Target->handleTargetFeatures(Opts->Features, Diags)) 658 return nullptr; 659 660 Target->setSupportedOpenCLOpts(); 661 Target->setOpenCLExtensionOpts(); 662 Target->setMaxAtomicWidth(); 663 664 if (!Target->validateTarget(Diags)) 665 return nullptr; 666 667 Target->CheckFixedPointBits(); 668 669 return Target.release(); 670 } 671