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/M68k.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/VE.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 //===----------------------------------------------------------------------===// 103 // Driver code 104 //===----------------------------------------------------------------------===// 105 106 TargetInfo *AllocateTarget(const llvm::Triple &Triple, 107 const TargetOptions &Opts) { 108 llvm::Triple::OSType os = Triple.getOS(); 109 110 switch (Triple.getArch()) { 111 default: 112 return nullptr; 113 114 case llvm::Triple::arc: 115 return new ARCTargetInfo(Triple, Opts); 116 117 case llvm::Triple::xcore: 118 return new XCoreTargetInfo(Triple, Opts); 119 120 case llvm::Triple::hexagon: 121 if (os == llvm::Triple::Linux && 122 Triple.getEnvironment() == llvm::Triple::Musl) 123 return new LinuxTargetInfo<HexagonTargetInfo>(Triple, Opts); 124 return new HexagonTargetInfo(Triple, Opts); 125 126 case llvm::Triple::lanai: 127 return new LanaiTargetInfo(Triple, Opts); 128 129 case llvm::Triple::aarch64_32: 130 if (Triple.isOSDarwin()) 131 return new DarwinAArch64TargetInfo(Triple, Opts); 132 133 return nullptr; 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::mips: 245 switch (os) { 246 case llvm::Triple::Linux: 247 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 248 case llvm::Triple::RTEMS: 249 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 250 case llvm::Triple::FreeBSD: 251 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 252 case llvm::Triple::NetBSD: 253 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 254 default: 255 return new MipsTargetInfo(Triple, Opts); 256 } 257 258 case llvm::Triple::mipsel: 259 switch (os) { 260 case llvm::Triple::Linux: 261 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 262 case llvm::Triple::RTEMS: 263 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 264 case llvm::Triple::FreeBSD: 265 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 266 case llvm::Triple::NetBSD: 267 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 268 case llvm::Triple::NaCl: 269 return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts); 270 default: 271 return new MipsTargetInfo(Triple, Opts); 272 } 273 274 case llvm::Triple::mips64: 275 switch (os) { 276 case llvm::Triple::Linux: 277 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 278 case llvm::Triple::RTEMS: 279 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 280 case llvm::Triple::FreeBSD: 281 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 282 case llvm::Triple::NetBSD: 283 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 284 case llvm::Triple::OpenBSD: 285 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 286 default: 287 return new MipsTargetInfo(Triple, Opts); 288 } 289 290 case llvm::Triple::mips64el: 291 switch (os) { 292 case llvm::Triple::Linux: 293 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); 294 case llvm::Triple::RTEMS: 295 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); 296 case llvm::Triple::FreeBSD: 297 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 298 case llvm::Triple::NetBSD: 299 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 300 case llvm::Triple::OpenBSD: 301 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); 302 default: 303 return new MipsTargetInfo(Triple, Opts); 304 } 305 306 case llvm::Triple::m68k: 307 switch (os) { 308 case llvm::Triple::Linux: 309 return new LinuxTargetInfo<M68kTargetInfo>(Triple, Opts); 310 case llvm::Triple::NetBSD: 311 return new NetBSDTargetInfo<M68kTargetInfo>(Triple, Opts); 312 default: 313 return new M68kTargetInfo(Triple, Opts); 314 } 315 316 case llvm::Triple::ppc: 317 if (Triple.isOSDarwin()) 318 return new DarwinPPC32TargetInfo(Triple, Opts); 319 switch (os) { 320 case llvm::Triple::Linux: 321 return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts); 322 case llvm::Triple::FreeBSD: 323 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 324 case llvm::Triple::NetBSD: 325 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 326 case llvm::Triple::OpenBSD: 327 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 328 case llvm::Triple::RTEMS: 329 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts); 330 case llvm::Triple::AIX: 331 return new AIXPPC32TargetInfo(Triple, Opts); 332 default: 333 return new PPC32TargetInfo(Triple, Opts); 334 } 335 336 case llvm::Triple::ppcle: 337 switch (os) { 338 case llvm::Triple::Linux: 339 return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts); 340 case llvm::Triple::FreeBSD: 341 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); 342 default: 343 return new PPC32TargetInfo(Triple, Opts); 344 } 345 346 case llvm::Triple::ppc64: 347 if (Triple.isOSDarwin()) 348 return new DarwinPPC64TargetInfo(Triple, Opts); 349 switch (os) { 350 case llvm::Triple::Linux: 351 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 352 case llvm::Triple::Lv2: 353 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts); 354 case llvm::Triple::FreeBSD: 355 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 356 case llvm::Triple::NetBSD: 357 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 358 case llvm::Triple::OpenBSD: 359 return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 360 case llvm::Triple::AIX: 361 return new AIXPPC64TargetInfo(Triple, Opts); 362 default: 363 return new PPC64TargetInfo(Triple, Opts); 364 } 365 366 case llvm::Triple::ppc64le: 367 switch (os) { 368 case llvm::Triple::Linux: 369 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); 370 case llvm::Triple::FreeBSD: 371 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 372 case llvm::Triple::NetBSD: 373 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 374 case llvm::Triple::OpenBSD: 375 return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); 376 default: 377 return new PPC64TargetInfo(Triple, Opts); 378 } 379 380 case llvm::Triple::nvptx: 381 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32); 382 case llvm::Triple::nvptx64: 383 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64); 384 385 case llvm::Triple::amdgcn: 386 case llvm::Triple::r600: 387 return new AMDGPUTargetInfo(Triple, Opts); 388 389 case llvm::Triple::riscv32: 390 // TODO: add cases for NetBSD, RTEMS once tested. 391 switch (os) { 392 case llvm::Triple::FreeBSD: 393 return new FreeBSDTargetInfo<RISCV32TargetInfo>(Triple, Opts); 394 case llvm::Triple::Linux: 395 return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts); 396 default: 397 return new RISCV32TargetInfo(Triple, Opts); 398 } 399 400 case llvm::Triple::riscv64: 401 // TODO: add cases for NetBSD, RTEMS once tested. 402 switch (os) { 403 case llvm::Triple::FreeBSD: 404 return new FreeBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts); 405 case llvm::Triple::OpenBSD: 406 return new OpenBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts); 407 case llvm::Triple::Fuchsia: 408 return new FuchsiaTargetInfo<RISCV64TargetInfo>(Triple, Opts); 409 case llvm::Triple::Linux: 410 return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts); 411 default: 412 return new RISCV64TargetInfo(Triple, Opts); 413 } 414 415 case llvm::Triple::sparc: 416 switch (os) { 417 case llvm::Triple::Linux: 418 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts); 419 case llvm::Triple::Solaris: 420 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts); 421 case llvm::Triple::NetBSD: 422 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); 423 case llvm::Triple::RTEMS: 424 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts); 425 default: 426 return new SparcV8TargetInfo(Triple, Opts); 427 } 428 429 // The 'sparcel' architecture copies all the above cases except for Solaris. 430 case llvm::Triple::sparcel: 431 switch (os) { 432 case llvm::Triple::Linux: 433 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 434 case llvm::Triple::NetBSD: 435 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 436 case llvm::Triple::RTEMS: 437 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts); 438 default: 439 return new SparcV8elTargetInfo(Triple, Opts); 440 } 441 442 case llvm::Triple::sparcv9: 443 switch (os) { 444 case llvm::Triple::Linux: 445 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts); 446 case llvm::Triple::Solaris: 447 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts); 448 case llvm::Triple::NetBSD: 449 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 450 case llvm::Triple::OpenBSD: 451 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 452 case llvm::Triple::FreeBSD: 453 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); 454 default: 455 return new SparcV9TargetInfo(Triple, Opts); 456 } 457 458 case llvm::Triple::systemz: 459 switch (os) { 460 case llvm::Triple::Linux: 461 return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts); 462 case llvm::Triple::ZOS: 463 return new ZOSTargetInfo<SystemZTargetInfo>(Triple, Opts); 464 default: 465 return new SystemZTargetInfo(Triple, Opts); 466 } 467 468 case llvm::Triple::tce: 469 return new TCETargetInfo(Triple, Opts); 470 471 case llvm::Triple::tcele: 472 return new TCELETargetInfo(Triple, Opts); 473 474 case llvm::Triple::x86: 475 if (Triple.isOSDarwin()) 476 return new DarwinI386TargetInfo(Triple, Opts); 477 478 switch (os) { 479 case llvm::Triple::Ananas: 480 return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts); 481 case llvm::Triple::CloudABI: 482 return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts); 483 case llvm::Triple::Linux: { 484 switch (Triple.getEnvironment()) { 485 default: 486 return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts); 487 case llvm::Triple::Android: 488 return new AndroidX86_32TargetInfo(Triple, Opts); 489 } 490 } 491 case llvm::Triple::DragonFly: 492 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 493 case llvm::Triple::NetBSD: 494 return new NetBSDI386TargetInfo(Triple, Opts); 495 case llvm::Triple::OpenBSD: 496 return new OpenBSDI386TargetInfo(Triple, Opts); 497 case llvm::Triple::FreeBSD: 498 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 499 case llvm::Triple::Fuchsia: 500 return new FuchsiaTargetInfo<X86_32TargetInfo>(Triple, Opts); 501 case llvm::Triple::KFreeBSD: 502 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); 503 case llvm::Triple::Minix: 504 return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts); 505 case llvm::Triple::Solaris: 506 return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts); 507 case llvm::Triple::Win32: { 508 switch (Triple.getEnvironment()) { 509 case llvm::Triple::Cygnus: 510 return new CygwinX86_32TargetInfo(Triple, Opts); 511 case llvm::Triple::GNU: 512 return new MinGWX86_32TargetInfo(Triple, Opts); 513 case llvm::Triple::Itanium: 514 case llvm::Triple::MSVC: 515 default: // Assume MSVC for unknown environments 516 return new MicrosoftX86_32TargetInfo(Triple, Opts); 517 } 518 } 519 case llvm::Triple::Haiku: 520 return new HaikuX86_32TargetInfo(Triple, Opts); 521 case llvm::Triple::RTEMS: 522 return new RTEMSX86_32TargetInfo(Triple, Opts); 523 case llvm::Triple::NaCl: 524 return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts); 525 case llvm::Triple::ELFIAMCU: 526 return new MCUX86_32TargetInfo(Triple, Opts); 527 case llvm::Triple::Hurd: 528 return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts); 529 default: 530 return new X86_32TargetInfo(Triple, Opts); 531 } 532 533 case llvm::Triple::x86_64: 534 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) 535 return new DarwinX86_64TargetInfo(Triple, Opts); 536 537 switch (os) { 538 case llvm::Triple::Ananas: 539 return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts); 540 case llvm::Triple::CloudABI: 541 return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts); 542 case llvm::Triple::Linux: { 543 switch (Triple.getEnvironment()) { 544 default: 545 return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts); 546 case llvm::Triple::Android: 547 return new AndroidX86_64TargetInfo(Triple, Opts); 548 } 549 } 550 case llvm::Triple::DragonFly: 551 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 552 case llvm::Triple::NetBSD: 553 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 554 case llvm::Triple::OpenBSD: 555 return new OpenBSDX86_64TargetInfo(Triple, Opts); 556 case llvm::Triple::FreeBSD: 557 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 558 case llvm::Triple::Fuchsia: 559 return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts); 560 case llvm::Triple::KFreeBSD: 561 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); 562 case llvm::Triple::Solaris: 563 return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts); 564 case llvm::Triple::Win32: { 565 switch (Triple.getEnvironment()) { 566 case llvm::Triple::Cygnus: 567 return new CygwinX86_64TargetInfo(Triple, Opts); 568 case llvm::Triple::GNU: 569 return new MinGWX86_64TargetInfo(Triple, Opts); 570 case llvm::Triple::MSVC: 571 default: // Assume MSVC for unknown environments 572 return new MicrosoftX86_64TargetInfo(Triple, Opts); 573 } 574 } 575 case llvm::Triple::Haiku: 576 return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts); 577 case llvm::Triple::NaCl: 578 return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts); 579 case llvm::Triple::PS4: 580 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts); 581 default: 582 return new X86_64TargetInfo(Triple, Opts); 583 } 584 585 case llvm::Triple::spir: { 586 if (os != llvm::Triple::UnknownOS || 587 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 588 return nullptr; 589 return new SPIR32TargetInfo(Triple, Opts); 590 } 591 case llvm::Triple::spir64: { 592 if (os != llvm::Triple::UnknownOS || 593 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 594 return nullptr; 595 return new SPIR64TargetInfo(Triple, Opts); 596 } 597 case llvm::Triple::wasm32: 598 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 599 Triple.getVendor() != llvm::Triple::UnknownVendor || 600 !Triple.isOSBinFormatWasm()) 601 return nullptr; 602 switch (os) { 603 case llvm::Triple::WASI: 604 return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts); 605 case llvm::Triple::Emscripten: 606 return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts); 607 case llvm::Triple::UnknownOS: 608 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts); 609 default: 610 return nullptr; 611 } 612 case llvm::Triple::wasm64: 613 if (Triple.getSubArch() != llvm::Triple::NoSubArch || 614 Triple.getVendor() != llvm::Triple::UnknownVendor || 615 !Triple.isOSBinFormatWasm()) 616 return nullptr; 617 switch (os) { 618 case llvm::Triple::WASI: 619 return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts); 620 case llvm::Triple::Emscripten: 621 return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts); 622 case llvm::Triple::UnknownOS: 623 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts); 624 default: 625 return nullptr; 626 } 627 628 case llvm::Triple::renderscript32: 629 return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts); 630 case llvm::Triple::renderscript64: 631 return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts); 632 633 case llvm::Triple::ve: 634 return new LinuxTargetInfo<VETargetInfo>(Triple, Opts); 635 } 636 } 637 } // namespace targets 638 } // namespace clang 639 640 using namespace clang::targets; 641 /// CreateTargetInfo - Return the target info object for the specified target 642 /// options. 643 TargetInfo * 644 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 645 const std::shared_ptr<TargetOptions> &Opts) { 646 llvm::Triple Triple(Opts->Triple); 647 648 // Construct the target 649 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts)); 650 if (!Target) { 651 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 652 return nullptr; 653 } 654 Target->TargetOpts = Opts; 655 656 // Set the target CPU if specified. 657 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 658 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 659 SmallVector<StringRef, 32> ValidList; 660 Target->fillValidCPUList(ValidList); 661 if (!ValidList.empty()) 662 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 663 return nullptr; 664 } 665 666 // Check the TuneCPU name if specified. 667 if (!Opts->TuneCPU.empty() && 668 !Target->isValidTuneCPUName(Opts->TuneCPU)) { 669 Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU; 670 SmallVector<StringRef, 32> ValidList; 671 Target->fillValidTuneCPUList(ValidList); 672 if (!ValidList.empty()) 673 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); 674 return nullptr; 675 } 676 677 // Set the target ABI if specified. 678 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 679 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 680 return nullptr; 681 } 682 683 // Set the fp math unit. 684 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { 685 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; 686 return nullptr; 687 } 688 689 // Compute the default target features, we need the target to handle this 690 // because features may have dependencies on one another. 691 if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU, 692 Opts->FeaturesAsWritten)) 693 return nullptr; 694 695 // Add the features to the compile options. 696 Opts->Features.clear(); 697 for (const auto &F : Opts->FeatureMap) 698 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str()); 699 // Sort here, so we handle the features in a predictable order. (This matters 700 // when we're dealing with features that overlap.) 701 llvm::sort(Opts->Features); 702 703 if (!Target->handleTargetFeatures(Opts->Features, Diags)) 704 return nullptr; 705 706 Target->setSupportedOpenCLOpts(); 707 Target->setCommandLineOpenCLOpts(); 708 Target->setMaxAtomicWidth(); 709 710 if (!Target->validateTarget(Diags)) 711 return nullptr; 712 713 Target->CheckFixedPointBits(); 714 715 return Target.release(); 716 } 717 718 /// getOpenCLFeatureDefines - Define OpenCL macros based on target settings 719 /// and language version 720 void TargetInfo::getOpenCLFeatureDefines(const LangOptions &Opts, 721 MacroBuilder &Builder) const { 722 // FIXME: OpenCL options which affect language semantics/syntax 723 // should be moved into LangOptions, thus macro definitions of 724 // such options is better to be done in clang::InitializePreprocessor. 725 auto defineOpenCLExtMacro = [&](llvm::StringRef Name, unsigned AvailVer, 726 unsigned CoreVersions, 727 unsigned OptionalVersions) { 728 // Check if extension is supported by target and is available in this 729 // OpenCL version 730 auto It = getTargetOpts().OpenCLFeaturesMap.find(Name); 731 if ((It != getTargetOpts().OpenCLFeaturesMap.end()) && It->getValue() && 732 OpenCLOptions::OpenCLOptionInfo(false, AvailVer, CoreVersions, 733 OptionalVersions) 734 .isAvailableIn(Opts)) 735 Builder.defineMacro(Name); 736 }; 737 #define OPENCL_GENERIC_EXTENSION(Ext, WithPragma, Avail, Core, Opt) \ 738 defineOpenCLExtMacro(#Ext, Avail, Core, Opt); 739 #include "clang/Basic/OpenCLExtensions.def" 740 741 // Assume compiling for FULL profile 742 Builder.defineMacro("__opencl_c_int64"); 743 } 744