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