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