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