1 //===--- Targets.cpp - Implement -arch option and targets -----------------===// 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 "clang/Basic/TargetInfo.h" 16 #include "clang/Basic/Builtins.h" 17 #include "clang/Basic/Diagnostic.h" 18 #include "clang/Basic/LangOptions.h" 19 #include "clang/Basic/MacroBuilder.h" 20 #include "clang/Basic/TargetBuiltins.h" 21 #include "clang/Basic/TargetOptions.h" 22 #include "llvm/ADT/APFloat.h" 23 #include "llvm/ADT/STLExtras.h" 24 #include "llvm/ADT/StringExtras.h" 25 #include "llvm/ADT/StringRef.h" 26 #include "llvm/ADT/StringSwitch.h" 27 #include "llvm/ADT/Triple.h" 28 #include "llvm/MC/MCSectionMachO.h" 29 #include "llvm/Support/ErrorHandling.h" 30 #include "llvm/Support/TargetParser.h" 31 #include <algorithm> 32 #include <memory> 33 using namespace clang; 34 35 //===----------------------------------------------------------------------===// 36 // Common code shared among targets. 37 //===----------------------------------------------------------------------===// 38 39 /// DefineStd - Define a macro name and standard variants. For example if 40 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix" 41 /// when in GNU mode. 42 static void DefineStd(MacroBuilder &Builder, StringRef MacroName, 43 const LangOptions &Opts) { 44 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace"); 45 46 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier 47 // in the user's namespace. 48 if (Opts.GNUMode) 49 Builder.defineMacro(MacroName); 50 51 // Define __unix. 52 Builder.defineMacro("__" + MacroName); 53 54 // Define __unix__. 55 Builder.defineMacro("__" + MacroName + "__"); 56 } 57 58 static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, 59 bool Tuning = true) { 60 Builder.defineMacro("__" + CPUName); 61 Builder.defineMacro("__" + CPUName + "__"); 62 if (Tuning) 63 Builder.defineMacro("__tune_" + CPUName + "__"); 64 } 65 66 //===----------------------------------------------------------------------===// 67 // Defines specific to certain operating systems. 68 //===----------------------------------------------------------------------===// 69 70 namespace { 71 template<typename TgtInfo> 72 class OSTargetInfo : public TgtInfo { 73 protected: 74 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 75 MacroBuilder &Builder) const=0; 76 public: 77 OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {} 78 void getTargetDefines(const LangOptions &Opts, 79 MacroBuilder &Builder) const override { 80 TgtInfo::getTargetDefines(Opts, Builder); 81 getOSDefines(Opts, TgtInfo::getTriple(), Builder); 82 } 83 84 }; 85 } // end anonymous namespace 86 87 88 static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, 89 const llvm::Triple &Triple, 90 StringRef &PlatformName, 91 VersionTuple &PlatformMinVersion) { 92 Builder.defineMacro("__APPLE_CC__", "6000"); 93 Builder.defineMacro("__APPLE__"); 94 Builder.defineMacro("OBJC_NEW_PROPERTIES"); 95 // AddressSanitizer doesn't play well with source fortification, which is on 96 // by default on Darwin. 97 if (Opts.Sanitize.has(SanitizerKind::Address)) 98 Builder.defineMacro("_FORTIFY_SOURCE", "0"); 99 100 if (!Opts.ObjCAutoRefCount) { 101 // __weak is always defined, for use in blocks and with objc pointers. 102 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))"); 103 104 // Darwin defines __strong even in C mode (just to nothing). 105 if (Opts.getGC() != LangOptions::NonGC) 106 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))"); 107 else 108 Builder.defineMacro("__strong", ""); 109 110 // __unsafe_unretained is defined to nothing in non-ARC mode. We even 111 // allow this in C, since one might have block pointers in structs that 112 // are used in pure C code and in Objective-C ARC. 113 Builder.defineMacro("__unsafe_unretained", ""); 114 } 115 116 if (Opts.Static) 117 Builder.defineMacro("__STATIC__"); 118 else 119 Builder.defineMacro("__DYNAMIC__"); 120 121 if (Opts.POSIXThreads) 122 Builder.defineMacro("_REENTRANT"); 123 124 // Get the platform type and version number from the triple. 125 unsigned Maj, Min, Rev; 126 if (Triple.isMacOSX()) { 127 Triple.getMacOSXVersion(Maj, Min, Rev); 128 PlatformName = "macosx"; 129 } else { 130 Triple.getOSVersion(Maj, Min, Rev); 131 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS()); 132 } 133 134 // If -target arch-pc-win32-macho option specified, we're 135 // generating code for Win32 ABI. No need to emit 136 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__. 137 if (PlatformName == "win32") { 138 PlatformMinVersion = VersionTuple(Maj, Min, Rev); 139 return; 140 } 141 142 // Set the appropriate OS version define. 143 if (Triple.isiOS()) { 144 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!"); 145 char Str[6]; 146 Str[0] = '0' + Maj; 147 Str[1] = '0' + (Min / 10); 148 Str[2] = '0' + (Min % 10); 149 Str[3] = '0' + (Rev / 10); 150 Str[4] = '0' + (Rev % 10); 151 Str[5] = '\0'; 152 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", 153 Str); 154 } else if (Triple.isMacOSX()) { 155 // Note that the Driver allows versions which aren't representable in the 156 // define (because we only get a single digit for the minor and micro 157 // revision numbers). So, we limit them to the maximum representable 158 // version. 159 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!"); 160 char Str[7]; 161 if (Maj < 10 || (Maj == 10 && Min < 10)) { 162 Str[0] = '0' + (Maj / 10); 163 Str[1] = '0' + (Maj % 10); 164 Str[2] = '0' + std::min(Min, 9U); 165 Str[3] = '0' + std::min(Rev, 9U); 166 Str[4] = '\0'; 167 } else { 168 // Handle versions > 10.9. 169 Str[0] = '0' + (Maj / 10); 170 Str[1] = '0' + (Maj % 10); 171 Str[2] = '0' + (Min / 10); 172 Str[3] = '0' + (Min % 10); 173 Str[4] = '0' + (Rev / 10); 174 Str[5] = '0' + (Rev % 10); 175 Str[6] = '\0'; 176 } 177 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str); 178 } 179 180 // Tell users about the kernel if there is one. 181 if (Triple.isOSDarwin()) 182 Builder.defineMacro("__MACH__"); 183 184 PlatformMinVersion = VersionTuple(Maj, Min, Rev); 185 } 186 187 namespace { 188 // CloudABI Target 189 template <typename Target> 190 class CloudABITargetInfo : public OSTargetInfo<Target> { 191 protected: 192 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 193 MacroBuilder &Builder) const override { 194 Builder.defineMacro("__CloudABI__"); 195 Builder.defineMacro("__ELF__"); 196 197 // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t. 198 Builder.defineMacro("__STDC_ISO_10646__", "201206L"); 199 Builder.defineMacro("__STDC_UTF_16__"); 200 Builder.defineMacro("__STDC_UTF_32__"); 201 } 202 203 public: 204 CloudABITargetInfo(const llvm::Triple &Triple) 205 : OSTargetInfo<Target>(Triple) { 206 this->UserLabelPrefix = ""; 207 } 208 }; 209 210 template<typename Target> 211 class DarwinTargetInfo : public OSTargetInfo<Target> { 212 protected: 213 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 214 MacroBuilder &Builder) const override { 215 getDarwinDefines(Builder, Opts, Triple, this->PlatformName, 216 this->PlatformMinVersion); 217 } 218 219 public: 220 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 221 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7); 222 this->MCountName = "\01mcount"; 223 } 224 225 std::string isValidSectionSpecifier(StringRef SR) const override { 226 // Let MCSectionMachO validate this. 227 StringRef Segment, Section; 228 unsigned TAA, StubSize; 229 bool HasTAA; 230 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section, 231 TAA, HasTAA, StubSize); 232 } 233 234 const char *getStaticInitSectionSpecifier() const override { 235 // FIXME: We should return 0 when building kexts. 236 return "__TEXT,__StaticInit,regular,pure_instructions"; 237 } 238 239 /// Darwin does not support protected visibility. Darwin's "default" 240 /// is very similar to ELF's "protected"; Darwin requires a "weak" 241 /// attribute on declarations that can be dynamically replaced. 242 bool hasProtectedVisibility() const override { 243 return false; 244 } 245 }; 246 247 248 // DragonFlyBSD Target 249 template<typename Target> 250 class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> { 251 protected: 252 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 253 MacroBuilder &Builder) const override { 254 // DragonFly defines; list based off of gcc output 255 Builder.defineMacro("__DragonFly__"); 256 Builder.defineMacro("__DragonFly_cc_version", "100001"); 257 Builder.defineMacro("__ELF__"); 258 Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 259 Builder.defineMacro("__tune_i386__"); 260 DefineStd(Builder, "unix", Opts); 261 } 262 public: 263 DragonFlyBSDTargetInfo(const llvm::Triple &Triple) 264 : OSTargetInfo<Target>(Triple) { 265 this->UserLabelPrefix = ""; 266 267 switch (Triple.getArch()) { 268 default: 269 case llvm::Triple::x86: 270 case llvm::Triple::x86_64: 271 this->MCountName = ".mcount"; 272 break; 273 } 274 } 275 }; 276 277 // FreeBSD Target 278 template<typename Target> 279 class FreeBSDTargetInfo : public OSTargetInfo<Target> { 280 protected: 281 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 282 MacroBuilder &Builder) const override { 283 // FreeBSD defines; list based off of gcc output 284 285 unsigned Release = Triple.getOSMajorVersion(); 286 if (Release == 0U) 287 Release = 8; 288 289 Builder.defineMacro("__FreeBSD__", Twine(Release)); 290 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U)); 291 Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 292 DefineStd(Builder, "unix", Opts); 293 Builder.defineMacro("__ELF__"); 294 295 // On FreeBSD, wchar_t contains the number of the code point as 296 // used by the character set of the locale. These character sets are 297 // not necessarily a superset of ASCII. 298 // 299 // FIXME: This is wrong; the macro refers to the numerical values 300 // of wchar_t *literals*, which are not locale-dependent. However, 301 // FreeBSD systems apparently depend on us getting this wrong, and 302 // setting this to 1 is conforming even if all the basic source 303 // character literals have the same encoding as char and wchar_t. 304 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1"); 305 } 306 public: 307 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 308 this->UserLabelPrefix = ""; 309 310 switch (Triple.getArch()) { 311 default: 312 case llvm::Triple::x86: 313 case llvm::Triple::x86_64: 314 this->MCountName = ".mcount"; 315 break; 316 case llvm::Triple::mips: 317 case llvm::Triple::mipsel: 318 case llvm::Triple::ppc: 319 case llvm::Triple::ppc64: 320 case llvm::Triple::ppc64le: 321 this->MCountName = "_mcount"; 322 break; 323 case llvm::Triple::arm: 324 this->MCountName = "__mcount"; 325 break; 326 } 327 } 328 }; 329 330 // GNU/kFreeBSD Target 331 template<typename Target> 332 class KFreeBSDTargetInfo : public OSTargetInfo<Target> { 333 protected: 334 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 335 MacroBuilder &Builder) const override { 336 // GNU/kFreeBSD defines; list based off of gcc output 337 338 DefineStd(Builder, "unix", Opts); 339 Builder.defineMacro("__FreeBSD_kernel__"); 340 Builder.defineMacro("__GLIBC__"); 341 Builder.defineMacro("__ELF__"); 342 if (Opts.POSIXThreads) 343 Builder.defineMacro("_REENTRANT"); 344 if (Opts.CPlusPlus) 345 Builder.defineMacro("_GNU_SOURCE"); 346 } 347 public: 348 KFreeBSDTargetInfo(const llvm::Triple &Triple) 349 : OSTargetInfo<Target>(Triple) { 350 this->UserLabelPrefix = ""; 351 } 352 }; 353 354 // Minix Target 355 template<typename Target> 356 class MinixTargetInfo : public OSTargetInfo<Target> { 357 protected: 358 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 359 MacroBuilder &Builder) const override { 360 // Minix defines 361 362 Builder.defineMacro("__minix", "3"); 363 Builder.defineMacro("_EM_WSIZE", "4"); 364 Builder.defineMacro("_EM_PSIZE", "4"); 365 Builder.defineMacro("_EM_SSIZE", "2"); 366 Builder.defineMacro("_EM_LSIZE", "4"); 367 Builder.defineMacro("_EM_FSIZE", "4"); 368 Builder.defineMacro("_EM_DSIZE", "8"); 369 Builder.defineMacro("__ELF__"); 370 DefineStd(Builder, "unix", Opts); 371 } 372 public: 373 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 374 this->UserLabelPrefix = ""; 375 } 376 }; 377 378 // Linux target 379 template<typename Target> 380 class LinuxTargetInfo : public OSTargetInfo<Target> { 381 protected: 382 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 383 MacroBuilder &Builder) const override { 384 // Linux defines; list based off of gcc output 385 DefineStd(Builder, "unix", Opts); 386 DefineStd(Builder, "linux", Opts); 387 Builder.defineMacro("__gnu_linux__"); 388 Builder.defineMacro("__ELF__"); 389 if (Triple.getEnvironment() == llvm::Triple::Android) { 390 Builder.defineMacro("__ANDROID__", "1"); 391 unsigned Maj, Min, Rev; 392 Triple.getOSVersion(Maj, Min, Rev); 393 this->PlatformName = "android"; 394 this->PlatformMinVersion = VersionTuple(Maj, Min, Rev); 395 } 396 if (Opts.POSIXThreads) 397 Builder.defineMacro("_REENTRANT"); 398 if (Opts.CPlusPlus) 399 Builder.defineMacro("_GNU_SOURCE"); 400 } 401 public: 402 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 403 this->UserLabelPrefix = ""; 404 this->WIntType = TargetInfo::UnsignedInt; 405 406 switch (Triple.getArch()) { 407 default: 408 break; 409 case llvm::Triple::ppc: 410 case llvm::Triple::ppc64: 411 case llvm::Triple::ppc64le: 412 this->MCountName = "_mcount"; 413 break; 414 } 415 } 416 417 const char *getStaticInitSectionSpecifier() const override { 418 return ".text.startup"; 419 } 420 }; 421 422 // NetBSD Target 423 template<typename Target> 424 class NetBSDTargetInfo : public OSTargetInfo<Target> { 425 protected: 426 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 427 MacroBuilder &Builder) const override { 428 // NetBSD defines; list based off of gcc output 429 Builder.defineMacro("__NetBSD__"); 430 Builder.defineMacro("__unix__"); 431 Builder.defineMacro("__ELF__"); 432 if (Opts.POSIXThreads) 433 Builder.defineMacro("_POSIX_THREADS"); 434 435 switch (Triple.getArch()) { 436 default: 437 break; 438 case llvm::Triple::arm: 439 case llvm::Triple::armeb: 440 case llvm::Triple::thumb: 441 case llvm::Triple::thumbeb: 442 Builder.defineMacro("__ARM_DWARF_EH__"); 443 break; 444 } 445 } 446 public: 447 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 448 this->UserLabelPrefix = ""; 449 this->MCountName = "_mcount"; 450 } 451 }; 452 453 // OpenBSD Target 454 template<typename Target> 455 class OpenBSDTargetInfo : public OSTargetInfo<Target> { 456 protected: 457 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 458 MacroBuilder &Builder) const override { 459 // OpenBSD defines; list based off of gcc output 460 461 Builder.defineMacro("__OpenBSD__"); 462 DefineStd(Builder, "unix", Opts); 463 Builder.defineMacro("__ELF__"); 464 if (Opts.POSIXThreads) 465 Builder.defineMacro("_REENTRANT"); 466 } 467 public: 468 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 469 this->UserLabelPrefix = ""; 470 this->TLSSupported = false; 471 472 switch (Triple.getArch()) { 473 default: 474 case llvm::Triple::x86: 475 case llvm::Triple::x86_64: 476 case llvm::Triple::arm: 477 case llvm::Triple::sparc: 478 this->MCountName = "__mcount"; 479 break; 480 case llvm::Triple::mips64: 481 case llvm::Triple::mips64el: 482 case llvm::Triple::ppc: 483 case llvm::Triple::sparcv9: 484 this->MCountName = "_mcount"; 485 break; 486 } 487 } 488 }; 489 490 // Bitrig Target 491 template<typename Target> 492 class BitrigTargetInfo : public OSTargetInfo<Target> { 493 protected: 494 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 495 MacroBuilder &Builder) const override { 496 // Bitrig defines; list based off of gcc output 497 498 Builder.defineMacro("__Bitrig__"); 499 DefineStd(Builder, "unix", Opts); 500 Builder.defineMacro("__ELF__"); 501 if (Opts.POSIXThreads) 502 Builder.defineMacro("_REENTRANT"); 503 504 switch (Triple.getArch()) { 505 default: 506 break; 507 case llvm::Triple::arm: 508 case llvm::Triple::armeb: 509 case llvm::Triple::thumb: 510 case llvm::Triple::thumbeb: 511 Builder.defineMacro("__ARM_DWARF_EH__"); 512 break; 513 } 514 } 515 public: 516 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 517 this->UserLabelPrefix = ""; 518 this->MCountName = "__mcount"; 519 } 520 }; 521 522 // PSP Target 523 template<typename Target> 524 class PSPTargetInfo : public OSTargetInfo<Target> { 525 protected: 526 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 527 MacroBuilder &Builder) const override { 528 // PSP defines; list based on the output of the pspdev gcc toolchain. 529 Builder.defineMacro("PSP"); 530 Builder.defineMacro("_PSP"); 531 Builder.defineMacro("__psp__"); 532 Builder.defineMacro("__ELF__"); 533 } 534 public: 535 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 536 this->UserLabelPrefix = ""; 537 } 538 }; 539 540 // PS3 PPU Target 541 template<typename Target> 542 class PS3PPUTargetInfo : public OSTargetInfo<Target> { 543 protected: 544 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 545 MacroBuilder &Builder) const override { 546 // PS3 PPU defines. 547 Builder.defineMacro("__PPC__"); 548 Builder.defineMacro("__PPU__"); 549 Builder.defineMacro("__CELLOS_LV2__"); 550 Builder.defineMacro("__ELF__"); 551 Builder.defineMacro("__LP32__"); 552 Builder.defineMacro("_ARCH_PPC64"); 553 Builder.defineMacro("__powerpc64__"); 554 } 555 public: 556 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 557 this->UserLabelPrefix = ""; 558 this->LongWidth = this->LongAlign = 32; 559 this->PointerWidth = this->PointerAlign = 32; 560 this->IntMaxType = TargetInfo::SignedLongLong; 561 this->Int64Type = TargetInfo::SignedLongLong; 562 this->SizeType = TargetInfo::UnsignedInt; 563 this->DescriptionString = "E-m:e-p:32:32-i64:64-n32:64"; 564 } 565 }; 566 567 template <typename Target> 568 class PS4OSTargetInfo : public OSTargetInfo<Target> { 569 protected: 570 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 571 MacroBuilder &Builder) const override { 572 Builder.defineMacro("__FreeBSD__", "9"); 573 Builder.defineMacro("__FreeBSD_cc_version", "900001"); 574 Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 575 DefineStd(Builder, "unix", Opts); 576 Builder.defineMacro("__ELF__"); 577 Builder.defineMacro("__PS4__"); 578 } 579 public: 580 PS4OSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 581 this->WCharType = this->UnsignedShort; 582 583 this->UserLabelPrefix = ""; 584 585 switch (Triple.getArch()) { 586 default: 587 case llvm::Triple::x86_64: 588 this->MCountName = ".mcount"; 589 break; 590 } 591 } 592 }; 593 594 // Solaris target 595 template<typename Target> 596 class SolarisTargetInfo : public OSTargetInfo<Target> { 597 protected: 598 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 599 MacroBuilder &Builder) const override { 600 DefineStd(Builder, "sun", Opts); 601 DefineStd(Builder, "unix", Opts); 602 Builder.defineMacro("__ELF__"); 603 Builder.defineMacro("__svr4__"); 604 Builder.defineMacro("__SVR4"); 605 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and 606 // newer, but to 500 for everything else. feature_test.h has a check to 607 // ensure that you are not using C99 with an old version of X/Open or C89 608 // with a new version. 609 if (Opts.C99) 610 Builder.defineMacro("_XOPEN_SOURCE", "600"); 611 else 612 Builder.defineMacro("_XOPEN_SOURCE", "500"); 613 if (Opts.CPlusPlus) 614 Builder.defineMacro("__C99FEATURES__"); 615 Builder.defineMacro("_LARGEFILE_SOURCE"); 616 Builder.defineMacro("_LARGEFILE64_SOURCE"); 617 Builder.defineMacro("__EXTENSIONS__"); 618 Builder.defineMacro("_REENTRANT"); 619 } 620 public: 621 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 622 this->UserLabelPrefix = ""; 623 this->WCharType = this->SignedInt; 624 // FIXME: WIntType should be SignedLong 625 } 626 }; 627 628 // Windows target 629 template<typename Target> 630 class WindowsTargetInfo : public OSTargetInfo<Target> { 631 protected: 632 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 633 MacroBuilder &Builder) const override { 634 Builder.defineMacro("_WIN32"); 635 } 636 void getVisualStudioDefines(const LangOptions &Opts, 637 MacroBuilder &Builder) const { 638 if (Opts.CPlusPlus) { 639 if (Opts.RTTIData) 640 Builder.defineMacro("_CPPRTTI"); 641 642 if (Opts.CXXExceptions) 643 Builder.defineMacro("_CPPUNWIND"); 644 } 645 646 if (!Opts.CharIsSigned) 647 Builder.defineMacro("_CHAR_UNSIGNED"); 648 649 // FIXME: POSIXThreads isn't exactly the option this should be defined for, 650 // but it works for now. 651 if (Opts.POSIXThreads) 652 Builder.defineMacro("_MT"); 653 654 if (Opts.MSCompatibilityVersion) { 655 Builder.defineMacro("_MSC_VER", 656 Twine(Opts.MSCompatibilityVersion / 100000)); 657 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion)); 658 // FIXME We cannot encode the revision information into 32-bits 659 Builder.defineMacro("_MSC_BUILD", Twine(1)); 660 661 if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) 662 Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1)); 663 } 664 665 if (Opts.MicrosoftExt) { 666 Builder.defineMacro("_MSC_EXTENSIONS"); 667 668 if (Opts.CPlusPlus11) { 669 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED"); 670 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED"); 671 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED"); 672 } 673 } 674 675 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64"); 676 } 677 678 public: 679 WindowsTargetInfo(const llvm::Triple &Triple) 680 : OSTargetInfo<Target>(Triple) {} 681 }; 682 683 template <typename Target> 684 class NaClTargetInfo : public OSTargetInfo<Target> { 685 protected: 686 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 687 MacroBuilder &Builder) const override { 688 if (Opts.POSIXThreads) 689 Builder.defineMacro("_REENTRANT"); 690 if (Opts.CPlusPlus) 691 Builder.defineMacro("_GNU_SOURCE"); 692 693 DefineStd(Builder, "unix", Opts); 694 Builder.defineMacro("__ELF__"); 695 Builder.defineMacro("__native_client__"); 696 } 697 698 public: 699 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 700 this->UserLabelPrefix = ""; 701 this->LongAlign = 32; 702 this->LongWidth = 32; 703 this->PointerAlign = 32; 704 this->PointerWidth = 32; 705 this->IntMaxType = TargetInfo::SignedLongLong; 706 this->Int64Type = TargetInfo::SignedLongLong; 707 this->DoubleAlign = 64; 708 this->LongDoubleWidth = 64; 709 this->LongDoubleAlign = 64; 710 this->LongLongWidth = 64; 711 this->LongLongAlign = 64; 712 this->SizeType = TargetInfo::UnsignedInt; 713 this->PtrDiffType = TargetInfo::SignedInt; 714 this->IntPtrType = TargetInfo::SignedInt; 715 // RegParmMax is inherited from the underlying architecture 716 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble; 717 if (Triple.getArch() == llvm::Triple::arm) { 718 // Handled in ARM's setABI(). 719 } else if (Triple.getArch() == llvm::Triple::x86) { 720 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32-S128"; 721 } else if (Triple.getArch() == llvm::Triple::x86_64) { 722 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128"; 723 } else if (Triple.getArch() == llvm::Triple::mipsel) { 724 // Handled on mips' setDescriptionString. 725 } else { 726 assert(Triple.getArch() == llvm::Triple::le32); 727 this->DescriptionString = "e-p:32:32-i64:64"; 728 } 729 } 730 }; 731 732 //===----------------------------------------------------------------------===// 733 // Specific target implementations. 734 //===----------------------------------------------------------------------===// 735 736 // PPC abstract base class 737 class PPCTargetInfo : public TargetInfo { 738 static const Builtin::Info BuiltinInfo[]; 739 static const char * const GCCRegNames[]; 740 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 741 std::string CPU; 742 743 // Target cpu features. 744 bool HasVSX; 745 bool HasP8Vector; 746 bool HasP8Crypto; 747 bool HasDirectMove; 748 bool HasQPX; 749 bool HasHTM; 750 bool HasBPERMD; 751 bool HasExtDiv; 752 753 protected: 754 std::string ABI; 755 756 public: 757 PPCTargetInfo(const llvm::Triple &Triple) 758 : TargetInfo(Triple), HasVSX(false), HasP8Vector(false), 759 HasP8Crypto(false), HasDirectMove(false), HasQPX(false), HasHTM(false), 760 HasBPERMD(false), HasExtDiv(false) { 761 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le); 762 LongDoubleWidth = LongDoubleAlign = 128; 763 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble; 764 } 765 766 /// \brief Flags for architecture specific defines. 767 typedef enum { 768 ArchDefineNone = 0, 769 ArchDefineName = 1 << 0, // <name> is substituted for arch name. 770 ArchDefinePpcgr = 1 << 1, 771 ArchDefinePpcsq = 1 << 2, 772 ArchDefine440 = 1 << 3, 773 ArchDefine603 = 1 << 4, 774 ArchDefine604 = 1 << 5, 775 ArchDefinePwr4 = 1 << 6, 776 ArchDefinePwr5 = 1 << 7, 777 ArchDefinePwr5x = 1 << 8, 778 ArchDefinePwr6 = 1 << 9, 779 ArchDefinePwr6x = 1 << 10, 780 ArchDefinePwr7 = 1 << 11, 781 ArchDefinePwr8 = 1 << 12, 782 ArchDefineA2 = 1 << 13, 783 ArchDefineA2q = 1 << 14 784 } ArchDefineTypes; 785 786 // Note: GCC recognizes the following additional cpus: 787 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801, 788 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell, 789 // titan, rs64. 790 bool setCPU(const std::string &Name) override { 791 bool CPUKnown = llvm::StringSwitch<bool>(Name) 792 .Case("generic", true) 793 .Case("440", true) 794 .Case("450", true) 795 .Case("601", true) 796 .Case("602", true) 797 .Case("603", true) 798 .Case("603e", true) 799 .Case("603ev", true) 800 .Case("604", true) 801 .Case("604e", true) 802 .Case("620", true) 803 .Case("630", true) 804 .Case("g3", true) 805 .Case("7400", true) 806 .Case("g4", true) 807 .Case("7450", true) 808 .Case("g4+", true) 809 .Case("750", true) 810 .Case("970", true) 811 .Case("g5", true) 812 .Case("a2", true) 813 .Case("a2q", true) 814 .Case("e500mc", true) 815 .Case("e5500", true) 816 .Case("power3", true) 817 .Case("pwr3", true) 818 .Case("power4", true) 819 .Case("pwr4", true) 820 .Case("power5", true) 821 .Case("pwr5", true) 822 .Case("power5x", true) 823 .Case("pwr5x", true) 824 .Case("power6", true) 825 .Case("pwr6", true) 826 .Case("power6x", true) 827 .Case("pwr6x", true) 828 .Case("power7", true) 829 .Case("pwr7", true) 830 .Case("power8", true) 831 .Case("pwr8", true) 832 .Case("powerpc", true) 833 .Case("ppc", true) 834 .Case("powerpc64", true) 835 .Case("ppc64", true) 836 .Case("powerpc64le", true) 837 .Case("ppc64le", true) 838 .Default(false); 839 840 if (CPUKnown) 841 CPU = Name; 842 843 return CPUKnown; 844 } 845 846 847 StringRef getABI() const override { return ABI; } 848 849 void getTargetBuiltins(const Builtin::Info *&Records, 850 unsigned &NumRecords) const override { 851 Records = BuiltinInfo; 852 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin; 853 } 854 855 bool isCLZForZeroUndef() const override { return false; } 856 857 void getTargetDefines(const LangOptions &Opts, 858 MacroBuilder &Builder) const override; 859 860 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override; 861 862 bool handleTargetFeatures(std::vector<std::string> &Features, 863 DiagnosticsEngine &Diags) override; 864 bool hasFeature(StringRef Feature) const override; 865 866 void getGCCRegNames(const char * const *&Names, 867 unsigned &NumNames) const override; 868 void getGCCRegAliases(const GCCRegAlias *&Aliases, 869 unsigned &NumAliases) const override; 870 bool validateAsmConstraint(const char *&Name, 871 TargetInfo::ConstraintInfo &Info) const override { 872 switch (*Name) { 873 default: return false; 874 case 'O': // Zero 875 break; 876 case 'b': // Base register 877 case 'f': // Floating point register 878 Info.setAllowsRegister(); 879 break; 880 // FIXME: The following are added to allow parsing. 881 // I just took a guess at what the actions should be. 882 // Also, is more specific checking needed? I.e. specific registers? 883 case 'd': // Floating point register (containing 64-bit value) 884 case 'v': // Altivec vector register 885 Info.setAllowsRegister(); 886 break; 887 case 'w': 888 switch (Name[1]) { 889 case 'd':// VSX vector register to hold vector double data 890 case 'f':// VSX vector register to hold vector float data 891 case 's':// VSX vector register to hold scalar float data 892 case 'a':// Any VSX register 893 case 'c':// An individual CR bit 894 break; 895 default: 896 return false; 897 } 898 Info.setAllowsRegister(); 899 Name++; // Skip over 'w'. 900 break; 901 case 'h': // `MQ', `CTR', or `LINK' register 902 case 'q': // `MQ' register 903 case 'c': // `CTR' register 904 case 'l': // `LINK' register 905 case 'x': // `CR' register (condition register) number 0 906 case 'y': // `CR' register (condition register) 907 case 'z': // `XER[CA]' carry bit (part of the XER register) 908 Info.setAllowsRegister(); 909 break; 910 case 'I': // Signed 16-bit constant 911 case 'J': // Unsigned 16-bit constant shifted left 16 bits 912 // (use `L' instead for SImode constants) 913 case 'K': // Unsigned 16-bit constant 914 case 'L': // Signed 16-bit constant shifted left 16 bits 915 case 'M': // Constant larger than 31 916 case 'N': // Exact power of 2 917 case 'P': // Constant whose negation is a signed 16-bit constant 918 case 'G': // Floating point constant that can be loaded into a 919 // register with one instruction per word 920 case 'H': // Integer/Floating point constant that can be loaded 921 // into a register using three instructions 922 break; 923 case 'm': // Memory operand. Note that on PowerPC targets, m can 924 // include addresses that update the base register. It 925 // is therefore only safe to use `m' in an asm statement 926 // if that asm statement accesses the operand exactly once. 927 // The asm statement must also use `%U<opno>' as a 928 // placeholder for the "update" flag in the corresponding 929 // load or store instruction. For example: 930 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val)); 931 // is correct but: 932 // asm ("st %1,%0" : "=m" (mem) : "r" (val)); 933 // is not. Use es rather than m if you don't want the base 934 // register to be updated. 935 case 'e': 936 if (Name[1] != 's') 937 return false; 938 // es: A "stable" memory operand; that is, one which does not 939 // include any automodification of the base register. Unlike 940 // `m', this constraint can be used in asm statements that 941 // might access the operand several times, or that might not 942 // access it at all. 943 Info.setAllowsMemory(); 944 Name++; // Skip over 'e'. 945 break; 946 case 'Q': // Memory operand that is an offset from a register (it is 947 // usually better to use `m' or `es' in asm statements) 948 case 'Z': // Memory operand that is an indexed or indirect from a 949 // register (it is usually better to use `m' or `es' in 950 // asm statements) 951 Info.setAllowsMemory(); 952 Info.setAllowsRegister(); 953 break; 954 case 'R': // AIX TOC entry 955 case 'a': // Address operand that is an indexed or indirect from a 956 // register (`p' is preferable for asm statements) 957 case 'S': // Constant suitable as a 64-bit mask operand 958 case 'T': // Constant suitable as a 32-bit mask operand 959 case 'U': // System V Release 4 small data area reference 960 case 't': // AND masks that can be performed by two rldic{l, r} 961 // instructions 962 case 'W': // Vector constant that does not require memory 963 case 'j': // Vector constant that is all zeros. 964 break; 965 // End FIXME. 966 } 967 return true; 968 } 969 std::string convertConstraint(const char *&Constraint) const override { 970 std::string R; 971 switch (*Constraint) { 972 case 'e': 973 case 'w': 974 // Two-character constraint; add "^" hint for later parsing. 975 R = std::string("^") + std::string(Constraint, 2); 976 Constraint++; 977 break; 978 default: 979 return TargetInfo::convertConstraint(Constraint); 980 } 981 return R; 982 } 983 const char *getClobbers() const override { 984 return ""; 985 } 986 int getEHDataRegisterNumber(unsigned RegNo) const override { 987 if (RegNo == 0) return 3; 988 if (RegNo == 1) return 4; 989 return -1; 990 } 991 992 bool hasSjLjLowering() const override { 993 return true; 994 } 995 }; 996 997 const Builtin::Info PPCTargetInfo::BuiltinInfo[] = { 998 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 999 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 1000 ALL_LANGUAGES }, 1001 #include "clang/Basic/BuiltinsPPC.def" 1002 }; 1003 1004 /// handleTargetFeatures - Perform initialization based on the user 1005 /// configured set of features. 1006 bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, 1007 DiagnosticsEngine &Diags) { 1008 for (unsigned i = 0, e = Features.size(); i !=e; ++i) { 1009 // Ignore disabled features. 1010 if (Features[i][0] == '-') 1011 continue; 1012 1013 StringRef Feature = StringRef(Features[i]).substr(1); 1014 1015 if (Feature == "vsx") { 1016 HasVSX = true; 1017 continue; 1018 } 1019 1020 if (Feature == "bpermd") { 1021 HasBPERMD = true; 1022 continue; 1023 } 1024 1025 if (Feature == "extdiv") { 1026 HasExtDiv = true; 1027 continue; 1028 } 1029 1030 if (Feature == "power8-vector") { 1031 HasP8Vector = true; 1032 HasVSX = true; 1033 continue; 1034 } 1035 1036 if (Feature == "crypto") { 1037 HasP8Crypto = true; 1038 continue; 1039 } 1040 1041 if (Feature == "direct-move") { 1042 HasDirectMove = true; 1043 HasVSX = true; 1044 continue; 1045 } 1046 1047 if (Feature == "qpx") { 1048 HasQPX = true; 1049 continue; 1050 } 1051 1052 if (Feature == "htm") { 1053 HasHTM = true; 1054 continue; 1055 } 1056 1057 // TODO: Finish this list and add an assert that we've handled them 1058 // all. 1059 } 1060 1061 return true; 1062 } 1063 1064 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific 1065 /// #defines that are not tied to a specific subtarget. 1066 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts, 1067 MacroBuilder &Builder) const { 1068 // Target identification. 1069 Builder.defineMacro("__ppc__"); 1070 Builder.defineMacro("__PPC__"); 1071 Builder.defineMacro("_ARCH_PPC"); 1072 Builder.defineMacro("__powerpc__"); 1073 Builder.defineMacro("__POWERPC__"); 1074 if (PointerWidth == 64) { 1075 Builder.defineMacro("_ARCH_PPC64"); 1076 Builder.defineMacro("__powerpc64__"); 1077 Builder.defineMacro("__ppc64__"); 1078 Builder.defineMacro("__PPC64__"); 1079 } 1080 1081 // Target properties. 1082 if (getTriple().getArch() == llvm::Triple::ppc64le) { 1083 Builder.defineMacro("_LITTLE_ENDIAN"); 1084 } else { 1085 if (getTriple().getOS() != llvm::Triple::NetBSD && 1086 getTriple().getOS() != llvm::Triple::OpenBSD) 1087 Builder.defineMacro("_BIG_ENDIAN"); 1088 } 1089 1090 // ABI options. 1091 if (ABI == "elfv1" || ABI == "elfv1-qpx") 1092 Builder.defineMacro("_CALL_ELF", "1"); 1093 if (ABI == "elfv2") 1094 Builder.defineMacro("_CALL_ELF", "2"); 1095 1096 // Subtarget options. 1097 Builder.defineMacro("__NATURAL_ALIGNMENT__"); 1098 Builder.defineMacro("__REGISTER_PREFIX__", ""); 1099 1100 // FIXME: Should be controlled by command line option. 1101 if (LongDoubleWidth == 128) 1102 Builder.defineMacro("__LONG_DOUBLE_128__"); 1103 1104 if (Opts.AltiVec) { 1105 Builder.defineMacro("__VEC__", "10206"); 1106 Builder.defineMacro("__ALTIVEC__"); 1107 } 1108 1109 // CPU identification. 1110 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU) 1111 .Case("440", ArchDefineName) 1112 .Case("450", ArchDefineName | ArchDefine440) 1113 .Case("601", ArchDefineName) 1114 .Case("602", ArchDefineName | ArchDefinePpcgr) 1115 .Case("603", ArchDefineName | ArchDefinePpcgr) 1116 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr) 1117 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr) 1118 .Case("604", ArchDefineName | ArchDefinePpcgr) 1119 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr) 1120 .Case("620", ArchDefineName | ArchDefinePpcgr) 1121 .Case("630", ArchDefineName | ArchDefinePpcgr) 1122 .Case("7400", ArchDefineName | ArchDefinePpcgr) 1123 .Case("7450", ArchDefineName | ArchDefinePpcgr) 1124 .Case("750", ArchDefineName | ArchDefinePpcgr) 1125 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr 1126 | ArchDefinePpcsq) 1127 .Case("a2", ArchDefineA2) 1128 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q) 1129 .Case("pwr3", ArchDefinePpcgr) 1130 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq) 1131 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr 1132 | ArchDefinePpcsq) 1133 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4 1134 | ArchDefinePpcgr | ArchDefinePpcsq) 1135 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5 1136 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 1137 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x 1138 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr 1139 | ArchDefinePpcsq) 1140 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6 1141 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 1142 | ArchDefinePpcgr | ArchDefinePpcsq) 1143 .Case("pwr8", ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x 1144 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 1145 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 1146 .Case("power3", ArchDefinePpcgr) 1147 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 1148 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr 1149 | ArchDefinePpcsq) 1150 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 1151 | ArchDefinePpcgr | ArchDefinePpcsq) 1152 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 1153 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 1154 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x 1155 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr 1156 | ArchDefinePpcsq) 1157 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6 1158 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 1159 | ArchDefinePpcgr | ArchDefinePpcsq) 1160 .Case("power8", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x 1161 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 1162 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 1163 .Default(ArchDefineNone); 1164 1165 if (defs & ArchDefineName) 1166 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper())); 1167 if (defs & ArchDefinePpcgr) 1168 Builder.defineMacro("_ARCH_PPCGR"); 1169 if (defs & ArchDefinePpcsq) 1170 Builder.defineMacro("_ARCH_PPCSQ"); 1171 if (defs & ArchDefine440) 1172 Builder.defineMacro("_ARCH_440"); 1173 if (defs & ArchDefine603) 1174 Builder.defineMacro("_ARCH_603"); 1175 if (defs & ArchDefine604) 1176 Builder.defineMacro("_ARCH_604"); 1177 if (defs & ArchDefinePwr4) 1178 Builder.defineMacro("_ARCH_PWR4"); 1179 if (defs & ArchDefinePwr5) 1180 Builder.defineMacro("_ARCH_PWR5"); 1181 if (defs & ArchDefinePwr5x) 1182 Builder.defineMacro("_ARCH_PWR5X"); 1183 if (defs & ArchDefinePwr6) 1184 Builder.defineMacro("_ARCH_PWR6"); 1185 if (defs & ArchDefinePwr6x) 1186 Builder.defineMacro("_ARCH_PWR6X"); 1187 if (defs & ArchDefinePwr7) 1188 Builder.defineMacro("_ARCH_PWR7"); 1189 if (defs & ArchDefinePwr8) 1190 Builder.defineMacro("_ARCH_PWR8"); 1191 if (defs & ArchDefineA2) 1192 Builder.defineMacro("_ARCH_A2"); 1193 if (defs & ArchDefineA2q) { 1194 Builder.defineMacro("_ARCH_A2Q"); 1195 Builder.defineMacro("_ARCH_QP"); 1196 } 1197 1198 if (getTriple().getVendor() == llvm::Triple::BGQ) { 1199 Builder.defineMacro("__bg__"); 1200 Builder.defineMacro("__THW_BLUEGENE__"); 1201 Builder.defineMacro("__bgq__"); 1202 Builder.defineMacro("__TOS_BGQ__"); 1203 } 1204 1205 if (HasVSX) 1206 Builder.defineMacro("__VSX__"); 1207 if (HasP8Vector) 1208 Builder.defineMacro("__POWER8_VECTOR__"); 1209 if (HasP8Crypto) 1210 Builder.defineMacro("__CRYPTO__"); 1211 if (HasHTM) 1212 Builder.defineMacro("__HTM__"); 1213 if (getTriple().getArch() == llvm::Triple::ppc64le || 1214 (defs & ArchDefinePwr8) || (CPU == "pwr8")) { 1215 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); 1216 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); 1217 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); 1218 if (PointerWidth == 64) 1219 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); 1220 } 1221 1222 // FIXME: The following are not yet generated here by Clang, but are 1223 // generated by GCC: 1224 // 1225 // _SOFT_FLOAT_ 1226 // __RECIP_PRECISION__ 1227 // __APPLE_ALTIVEC__ 1228 // __RECIP__ 1229 // __RECIPF__ 1230 // __RSQRTE__ 1231 // __RSQRTEF__ 1232 // _SOFT_DOUBLE_ 1233 // __NO_LWSYNC__ 1234 // __HAVE_BSWAP__ 1235 // __LONGDOUBLE128 1236 // __CMODEL_MEDIUM__ 1237 // __CMODEL_LARGE__ 1238 // _CALL_SYSV 1239 // _CALL_DARWIN 1240 // __NO_FPRS__ 1241 } 1242 1243 void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const { 1244 Features["altivec"] = llvm::StringSwitch<bool>(CPU) 1245 .Case("7400", true) 1246 .Case("g4", true) 1247 .Case("7450", true) 1248 .Case("g4+", true) 1249 .Case("970", true) 1250 .Case("g5", true) 1251 .Case("pwr6", true) 1252 .Case("pwr7", true) 1253 .Case("pwr8", true) 1254 .Case("ppc64", true) 1255 .Case("ppc64le", true) 1256 .Default(false); 1257 1258 Features["qpx"] = (CPU == "a2q"); 1259 Features["crypto"] = llvm::StringSwitch<bool>(CPU) 1260 .Case("ppc64le", true) 1261 .Case("pwr8", true) 1262 .Default(false); 1263 Features["power8-vector"] = llvm::StringSwitch<bool>(CPU) 1264 .Case("ppc64le", true) 1265 .Case("pwr8", true) 1266 .Default(false); 1267 Features["bpermd"] = llvm::StringSwitch<bool>(CPU) 1268 .Case("ppc64le", true) 1269 .Case("pwr8", true) 1270 .Case("pwr7", true) 1271 .Default(false); 1272 Features["extdiv"] = llvm::StringSwitch<bool>(CPU) 1273 .Case("ppc64le", true) 1274 .Case("pwr8", true) 1275 .Case("pwr7", true) 1276 .Default(false); 1277 Features["direct-move"] = llvm::StringSwitch<bool>(CPU) 1278 .Case("ppc64le", true) 1279 .Case("pwr8", true) 1280 .Default(false); 1281 } 1282 1283 bool PPCTargetInfo::hasFeature(StringRef Feature) const { 1284 return llvm::StringSwitch<bool>(Feature) 1285 .Case("powerpc", true) 1286 .Case("vsx", HasVSX) 1287 .Case("power8-vector", HasP8Vector) 1288 .Case("crypto", HasP8Crypto) 1289 .Case("direct-move", HasDirectMove) 1290 .Case("qpx", HasQPX) 1291 .Case("htm", HasHTM) 1292 .Case("bpermd", HasBPERMD) 1293 .Case("extdiv", HasExtDiv) 1294 .Default(false); 1295 } 1296 1297 const char * const PPCTargetInfo::GCCRegNames[] = { 1298 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 1299 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 1300 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 1301 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 1302 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", 1303 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", 1304 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", 1305 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", 1306 "mq", "lr", "ctr", "ap", 1307 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", 1308 "xer", 1309 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", 1310 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", 1311 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", 1312 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", 1313 "vrsave", "vscr", 1314 "spe_acc", "spefscr", 1315 "sfp" 1316 }; 1317 1318 void PPCTargetInfo::getGCCRegNames(const char * const *&Names, 1319 unsigned &NumNames) const { 1320 Names = GCCRegNames; 1321 NumNames = llvm::array_lengthof(GCCRegNames); 1322 } 1323 1324 const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = { 1325 // While some of these aliases do map to different registers 1326 // they still share the same register name. 1327 { { "0" }, "r0" }, 1328 { { "1"}, "r1" }, 1329 { { "2" }, "r2" }, 1330 { { "3" }, "r3" }, 1331 { { "4" }, "r4" }, 1332 { { "5" }, "r5" }, 1333 { { "6" }, "r6" }, 1334 { { "7" }, "r7" }, 1335 { { "8" }, "r8" }, 1336 { { "9" }, "r9" }, 1337 { { "10" }, "r10" }, 1338 { { "11" }, "r11" }, 1339 { { "12" }, "r12" }, 1340 { { "13" }, "r13" }, 1341 { { "14" }, "r14" }, 1342 { { "15" }, "r15" }, 1343 { { "16" }, "r16" }, 1344 { { "17" }, "r17" }, 1345 { { "18" }, "r18" }, 1346 { { "19" }, "r19" }, 1347 { { "20" }, "r20" }, 1348 { { "21" }, "r21" }, 1349 { { "22" }, "r22" }, 1350 { { "23" }, "r23" }, 1351 { { "24" }, "r24" }, 1352 { { "25" }, "r25" }, 1353 { { "26" }, "r26" }, 1354 { { "27" }, "r27" }, 1355 { { "28" }, "r28" }, 1356 { { "29" }, "r29" }, 1357 { { "30" }, "r30" }, 1358 { { "31" }, "r31" }, 1359 { { "fr0" }, "f0" }, 1360 { { "fr1" }, "f1" }, 1361 { { "fr2" }, "f2" }, 1362 { { "fr3" }, "f3" }, 1363 { { "fr4" }, "f4" }, 1364 { { "fr5" }, "f5" }, 1365 { { "fr6" }, "f6" }, 1366 { { "fr7" }, "f7" }, 1367 { { "fr8" }, "f8" }, 1368 { { "fr9" }, "f9" }, 1369 { { "fr10" }, "f10" }, 1370 { { "fr11" }, "f11" }, 1371 { { "fr12" }, "f12" }, 1372 { { "fr13" }, "f13" }, 1373 { { "fr14" }, "f14" }, 1374 { { "fr15" }, "f15" }, 1375 { { "fr16" }, "f16" }, 1376 { { "fr17" }, "f17" }, 1377 { { "fr18" }, "f18" }, 1378 { { "fr19" }, "f19" }, 1379 { { "fr20" }, "f20" }, 1380 { { "fr21" }, "f21" }, 1381 { { "fr22" }, "f22" }, 1382 { { "fr23" }, "f23" }, 1383 { { "fr24" }, "f24" }, 1384 { { "fr25" }, "f25" }, 1385 { { "fr26" }, "f26" }, 1386 { { "fr27" }, "f27" }, 1387 { { "fr28" }, "f28" }, 1388 { { "fr29" }, "f29" }, 1389 { { "fr30" }, "f30" }, 1390 { { "fr31" }, "f31" }, 1391 { { "cc" }, "cr0" }, 1392 }; 1393 1394 void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 1395 unsigned &NumAliases) const { 1396 Aliases = GCCRegAliases; 1397 NumAliases = llvm::array_lengthof(GCCRegAliases); 1398 } 1399 1400 class PPC32TargetInfo : public PPCTargetInfo { 1401 public: 1402 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) { 1403 DescriptionString = "E-m:e-p:32:32-i64:64-n32"; 1404 1405 switch (getTriple().getOS()) { 1406 case llvm::Triple::Linux: 1407 case llvm::Triple::FreeBSD: 1408 case llvm::Triple::NetBSD: 1409 SizeType = UnsignedInt; 1410 PtrDiffType = SignedInt; 1411 IntPtrType = SignedInt; 1412 break; 1413 default: 1414 break; 1415 } 1416 1417 if (getTriple().getOS() == llvm::Triple::FreeBSD) { 1418 LongDoubleWidth = LongDoubleAlign = 64; 1419 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 1420 } 1421 1422 // PPC32 supports atomics up to 4 bytes. 1423 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32; 1424 } 1425 1426 BuiltinVaListKind getBuiltinVaListKind() const override { 1427 // This is the ELF definition, and is overridden by the Darwin sub-target 1428 return TargetInfo::PowerABIBuiltinVaList; 1429 } 1430 }; 1431 1432 // Note: ABI differences may eventually require us to have a separate 1433 // TargetInfo for little endian. 1434 class PPC64TargetInfo : public PPCTargetInfo { 1435 public: 1436 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) { 1437 LongWidth = LongAlign = PointerWidth = PointerAlign = 64; 1438 IntMaxType = SignedLong; 1439 Int64Type = SignedLong; 1440 1441 if ((Triple.getArch() == llvm::Triple::ppc64le)) { 1442 DescriptionString = "e-m:e-i64:64-n32:64"; 1443 ABI = "elfv2"; 1444 } else { 1445 DescriptionString = "E-m:e-i64:64-n32:64"; 1446 ABI = "elfv1"; 1447 } 1448 1449 switch (getTriple().getOS()) { 1450 case llvm::Triple::FreeBSD: 1451 LongDoubleWidth = LongDoubleAlign = 64; 1452 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 1453 break; 1454 case llvm::Triple::NetBSD: 1455 IntMaxType = SignedLongLong; 1456 Int64Type = SignedLongLong; 1457 break; 1458 default: 1459 break; 1460 } 1461 1462 // PPC64 supports atomics up to 8 bytes. 1463 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 1464 } 1465 BuiltinVaListKind getBuiltinVaListKind() const override { 1466 return TargetInfo::CharPtrBuiltinVaList; 1467 } 1468 // PPC64 Linux-specifc ABI options. 1469 bool setABI(const std::string &Name) override { 1470 if (Name == "elfv1" || Name == "elfv1-qpx" || Name == "elfv2") { 1471 ABI = Name; 1472 return true; 1473 } 1474 return false; 1475 } 1476 }; 1477 1478 class DarwinPPC32TargetInfo : 1479 public DarwinTargetInfo<PPC32TargetInfo> { 1480 public: 1481 DarwinPPC32TargetInfo(const llvm::Triple &Triple) 1482 : DarwinTargetInfo<PPC32TargetInfo>(Triple) { 1483 HasAlignMac68kSupport = true; 1484 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool? 1485 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726 1486 LongLongAlign = 32; 1487 SuitableAlign = 128; 1488 DescriptionString = "E-m:o-p:32:32-f64:32:64-n32"; 1489 } 1490 BuiltinVaListKind getBuiltinVaListKind() const override { 1491 return TargetInfo::CharPtrBuiltinVaList; 1492 } 1493 }; 1494 1495 class DarwinPPC64TargetInfo : 1496 public DarwinTargetInfo<PPC64TargetInfo> { 1497 public: 1498 DarwinPPC64TargetInfo(const llvm::Triple &Triple) 1499 : DarwinTargetInfo<PPC64TargetInfo>(Triple) { 1500 HasAlignMac68kSupport = true; 1501 SuitableAlign = 128; 1502 DescriptionString = "E-m:o-i64:64-n32:64"; 1503 } 1504 }; 1505 1506 static const unsigned NVPTXAddrSpaceMap[] = { 1507 1, // opencl_global 1508 3, // opencl_local 1509 4, // opencl_constant 1510 // FIXME: generic has to be added to the target 1511 0, // opencl_generic 1512 1, // cuda_device 1513 4, // cuda_constant 1514 3, // cuda_shared 1515 }; 1516 class NVPTXTargetInfo : public TargetInfo { 1517 static const char * const GCCRegNames[]; 1518 static const Builtin::Info BuiltinInfo[]; 1519 1520 // The GPU profiles supported by the NVPTX backend 1521 enum GPUKind { 1522 GK_NONE, 1523 GK_SM20, 1524 GK_SM21, 1525 GK_SM30, 1526 GK_SM35, 1527 GK_SM37, 1528 } GPU; 1529 1530 public: 1531 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 1532 BigEndian = false; 1533 TLSSupported = false; 1534 LongWidth = LongAlign = 64; 1535 AddrSpaceMap = &NVPTXAddrSpaceMap; 1536 UseAddrSpaceMapMangling = true; 1537 // Define available target features 1538 // These must be defined in sorted order! 1539 NoAsmVariants = true; 1540 // Set the default GPU to sm20 1541 GPU = GK_SM20; 1542 } 1543 void getTargetDefines(const LangOptions &Opts, 1544 MacroBuilder &Builder) const override { 1545 Builder.defineMacro("__PTX__"); 1546 Builder.defineMacro("__NVPTX__"); 1547 if (Opts.CUDAIsDevice) { 1548 // Set __CUDA_ARCH__ for the GPU specified. 1549 std::string CUDAArchCode; 1550 switch (GPU) { 1551 case GK_SM20: 1552 CUDAArchCode = "200"; 1553 break; 1554 case GK_SM21: 1555 CUDAArchCode = "210"; 1556 break; 1557 case GK_SM30: 1558 CUDAArchCode = "300"; 1559 break; 1560 case GK_SM35: 1561 CUDAArchCode = "350"; 1562 break; 1563 case GK_SM37: 1564 CUDAArchCode = "370"; 1565 break; 1566 default: 1567 llvm_unreachable("Unhandled target CPU"); 1568 } 1569 Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode); 1570 } 1571 } 1572 void getTargetBuiltins(const Builtin::Info *&Records, 1573 unsigned &NumRecords) const override { 1574 Records = BuiltinInfo; 1575 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin; 1576 } 1577 bool hasFeature(StringRef Feature) const override { 1578 return Feature == "ptx" || Feature == "nvptx"; 1579 } 1580 1581 void getGCCRegNames(const char * const *&Names, 1582 unsigned &NumNames) const override; 1583 void getGCCRegAliases(const GCCRegAlias *&Aliases, 1584 unsigned &NumAliases) const override { 1585 // No aliases. 1586 Aliases = nullptr; 1587 NumAliases = 0; 1588 } 1589 bool 1590 validateAsmConstraint(const char *&Name, 1591 TargetInfo::ConstraintInfo &Info) const override { 1592 switch (*Name) { 1593 default: return false; 1594 case 'c': 1595 case 'h': 1596 case 'r': 1597 case 'l': 1598 case 'f': 1599 case 'd': 1600 Info.setAllowsRegister(); 1601 return true; 1602 } 1603 } 1604 const char *getClobbers() const override { 1605 // FIXME: Is this really right? 1606 return ""; 1607 } 1608 BuiltinVaListKind getBuiltinVaListKind() const override { 1609 // FIXME: implement 1610 return TargetInfo::CharPtrBuiltinVaList; 1611 } 1612 bool setCPU(const std::string &Name) override { 1613 GPU = llvm::StringSwitch<GPUKind>(Name) 1614 .Case("sm_20", GK_SM20) 1615 .Case("sm_21", GK_SM21) 1616 .Case("sm_30", GK_SM30) 1617 .Case("sm_35", GK_SM35) 1618 .Case("sm_37", GK_SM37) 1619 .Default(GK_NONE); 1620 1621 return GPU != GK_NONE; 1622 } 1623 }; 1624 1625 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = { 1626 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 1627 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 1628 ALL_LANGUAGES }, 1629 #include "clang/Basic/BuiltinsNVPTX.def" 1630 }; 1631 1632 const char * const NVPTXTargetInfo::GCCRegNames[] = { 1633 "r0" 1634 }; 1635 1636 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names, 1637 unsigned &NumNames) const { 1638 Names = GCCRegNames; 1639 NumNames = llvm::array_lengthof(GCCRegNames); 1640 } 1641 1642 class NVPTX32TargetInfo : public NVPTXTargetInfo { 1643 public: 1644 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) { 1645 PointerWidth = PointerAlign = 32; 1646 SizeType = TargetInfo::UnsignedInt; 1647 PtrDiffType = TargetInfo::SignedInt; 1648 IntPtrType = TargetInfo::SignedInt; 1649 DescriptionString = "e-p:32:32-i64:64-v16:16-v32:32-n16:32:64"; 1650 } 1651 }; 1652 1653 class NVPTX64TargetInfo : public NVPTXTargetInfo { 1654 public: 1655 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) { 1656 PointerWidth = PointerAlign = 64; 1657 SizeType = TargetInfo::UnsignedLong; 1658 PtrDiffType = TargetInfo::SignedLong; 1659 IntPtrType = TargetInfo::SignedLong; 1660 DescriptionString = "e-i64:64-v16:16-v32:32-n16:32:64"; 1661 } 1662 }; 1663 1664 static const unsigned R600AddrSpaceMap[] = { 1665 1, // opencl_global 1666 3, // opencl_local 1667 2, // opencl_constant 1668 4, // opencl_generic 1669 1, // cuda_device 1670 2, // cuda_constant 1671 3 // cuda_shared 1672 }; 1673 1674 // If you edit the description strings, make sure you update 1675 // getPointerWidthV(). 1676 1677 static const char *DescriptionStringR600 = 1678 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128" 1679 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64"; 1680 1681 static const char *DescriptionStringR600DoubleOps = 1682 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128" 1683 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64"; 1684 1685 static const char *DescriptionStringSI = 1686 "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-p24:64:64" 1687 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128" 1688 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64"; 1689 1690 class R600TargetInfo : public TargetInfo { 1691 static const Builtin::Info BuiltinInfo[]; 1692 static const char * const GCCRegNames[]; 1693 1694 /// \brief The GPU profiles supported by the R600 target. 1695 enum GPUKind { 1696 GK_NONE, 1697 GK_R600, 1698 GK_R600_DOUBLE_OPS, 1699 GK_R700, 1700 GK_R700_DOUBLE_OPS, 1701 GK_EVERGREEN, 1702 GK_EVERGREEN_DOUBLE_OPS, 1703 GK_NORTHERN_ISLANDS, 1704 GK_CAYMAN, 1705 GK_SOUTHERN_ISLANDS, 1706 GK_SEA_ISLANDS 1707 } GPU; 1708 1709 bool hasFP64:1; 1710 bool hasFMAF:1; 1711 bool hasLDEXPF:1; 1712 1713 public: 1714 R600TargetInfo(const llvm::Triple &Triple) 1715 : TargetInfo(Triple) { 1716 1717 if (Triple.getArch() == llvm::Triple::amdgcn) { 1718 DescriptionString = DescriptionStringSI; 1719 GPU = GK_SOUTHERN_ISLANDS; 1720 hasFP64 = true; 1721 hasFMAF = true; 1722 hasLDEXPF = true; 1723 } else { 1724 DescriptionString = DescriptionStringR600; 1725 GPU = GK_R600; 1726 hasFP64 = false; 1727 hasFMAF = false; 1728 hasLDEXPF = false; 1729 } 1730 AddrSpaceMap = &R600AddrSpaceMap; 1731 UseAddrSpaceMapMangling = true; 1732 } 1733 1734 uint64_t getPointerWidthV(unsigned AddrSpace) const override { 1735 if (GPU <= GK_CAYMAN) 1736 return 32; 1737 1738 switch(AddrSpace) { 1739 default: 1740 return 64; 1741 case 0: 1742 case 3: 1743 case 5: 1744 return 32; 1745 } 1746 } 1747 1748 const char * getClobbers() const override { 1749 return ""; 1750 } 1751 1752 void getGCCRegNames(const char * const *&Names, 1753 unsigned &NumNames) const override; 1754 1755 void getGCCRegAliases(const GCCRegAlias *&Aliases, 1756 unsigned &NumAliases) const override { 1757 Aliases = nullptr; 1758 NumAliases = 0; 1759 } 1760 1761 bool validateAsmConstraint(const char *&Name, 1762 TargetInfo::ConstraintInfo &info) const override { 1763 return true; 1764 } 1765 1766 void getTargetBuiltins(const Builtin::Info *&Records, 1767 unsigned &NumRecords) const override { 1768 Records = BuiltinInfo; 1769 NumRecords = clang::R600::LastTSBuiltin - Builtin::FirstTSBuiltin; 1770 } 1771 1772 void getTargetDefines(const LangOptions &Opts, 1773 MacroBuilder &Builder) const override { 1774 Builder.defineMacro("__R600__"); 1775 if (hasFMAF) 1776 Builder.defineMacro("__HAS_FMAF__"); 1777 if (hasLDEXPF) 1778 Builder.defineMacro("__HAS_LDEXPF__"); 1779 if (hasFP64 && Opts.OpenCL) { 1780 Builder.defineMacro("cl_khr_fp64"); 1781 } 1782 } 1783 1784 BuiltinVaListKind getBuiltinVaListKind() const override { 1785 return TargetInfo::CharPtrBuiltinVaList; 1786 } 1787 1788 bool setCPU(const std::string &Name) override { 1789 GPU = llvm::StringSwitch<GPUKind>(Name) 1790 .Case("r600" , GK_R600) 1791 .Case("rv610", GK_R600) 1792 .Case("rv620", GK_R600) 1793 .Case("rv630", GK_R600) 1794 .Case("rv635", GK_R600) 1795 .Case("rs780", GK_R600) 1796 .Case("rs880", GK_R600) 1797 .Case("rv670", GK_R600_DOUBLE_OPS) 1798 .Case("rv710", GK_R700) 1799 .Case("rv730", GK_R700) 1800 .Case("rv740", GK_R700_DOUBLE_OPS) 1801 .Case("rv770", GK_R700_DOUBLE_OPS) 1802 .Case("palm", GK_EVERGREEN) 1803 .Case("cedar", GK_EVERGREEN) 1804 .Case("sumo", GK_EVERGREEN) 1805 .Case("sumo2", GK_EVERGREEN) 1806 .Case("redwood", GK_EVERGREEN) 1807 .Case("juniper", GK_EVERGREEN) 1808 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS) 1809 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS) 1810 .Case("barts", GK_NORTHERN_ISLANDS) 1811 .Case("turks", GK_NORTHERN_ISLANDS) 1812 .Case("caicos", GK_NORTHERN_ISLANDS) 1813 .Case("cayman", GK_CAYMAN) 1814 .Case("aruba", GK_CAYMAN) 1815 .Case("tahiti", GK_SOUTHERN_ISLANDS) 1816 .Case("pitcairn", GK_SOUTHERN_ISLANDS) 1817 .Case("verde", GK_SOUTHERN_ISLANDS) 1818 .Case("oland", GK_SOUTHERN_ISLANDS) 1819 .Case("hainan", GK_SOUTHERN_ISLANDS) 1820 .Case("bonaire", GK_SEA_ISLANDS) 1821 .Case("kabini", GK_SEA_ISLANDS) 1822 .Case("kaveri", GK_SEA_ISLANDS) 1823 .Case("hawaii", GK_SEA_ISLANDS) 1824 .Case("mullins", GK_SEA_ISLANDS) 1825 .Default(GK_NONE); 1826 1827 if (GPU == GK_NONE) { 1828 return false; 1829 } 1830 1831 // Set the correct data layout 1832 switch (GPU) { 1833 case GK_NONE: 1834 case GK_R600: 1835 case GK_R700: 1836 case GK_EVERGREEN: 1837 case GK_NORTHERN_ISLANDS: 1838 DescriptionString = DescriptionStringR600; 1839 hasFP64 = false; 1840 hasFMAF = false; 1841 hasLDEXPF = false; 1842 break; 1843 case GK_R600_DOUBLE_OPS: 1844 case GK_R700_DOUBLE_OPS: 1845 case GK_EVERGREEN_DOUBLE_OPS: 1846 case GK_CAYMAN: 1847 DescriptionString = DescriptionStringR600DoubleOps; 1848 hasFP64 = true; 1849 hasFMAF = true; 1850 hasLDEXPF = false; 1851 break; 1852 case GK_SOUTHERN_ISLANDS: 1853 case GK_SEA_ISLANDS: 1854 DescriptionString = DescriptionStringSI; 1855 hasFP64 = true; 1856 hasFMAF = true; 1857 hasLDEXPF = true; 1858 break; 1859 } 1860 1861 return true; 1862 } 1863 }; 1864 1865 const Builtin::Info R600TargetInfo::BuiltinInfo[] = { 1866 #define BUILTIN(ID, TYPE, ATTRS) \ 1867 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 1868 #include "clang/Basic/BuiltinsR600.def" 1869 }; 1870 const char * const R600TargetInfo::GCCRegNames[] = { 1871 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", 1872 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", 1873 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", 1874 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", 1875 "v32", "v33", "v34", "v35", "v36", "v37", "v38", "v39", 1876 "v40", "v41", "v42", "v43", "v44", "v45", "v46", "v47", 1877 "v48", "v49", "v50", "v51", "v52", "v53", "v54", "v55", 1878 "v56", "v57", "v58", "v59", "v60", "v61", "v62", "v63", 1879 "v64", "v65", "v66", "v67", "v68", "v69", "v70", "v71", 1880 "v72", "v73", "v74", "v75", "v76", "v77", "v78", "v79", 1881 "v80", "v81", "v82", "v83", "v84", "v85", "v86", "v87", 1882 "v88", "v89", "v90", "v91", "v92", "v93", "v94", "v95", 1883 "v96", "v97", "v98", "v99", "v100", "v101", "v102", "v103", 1884 "v104", "v105", "v106", "v107", "v108", "v109", "v110", "v111", 1885 "v112", "v113", "v114", "v115", "v116", "v117", "v118", "v119", 1886 "v120", "v121", "v122", "v123", "v124", "v125", "v126", "v127", 1887 "v128", "v129", "v130", "v131", "v132", "v133", "v134", "v135", 1888 "v136", "v137", "v138", "v139", "v140", "v141", "v142", "v143", 1889 "v144", "v145", "v146", "v147", "v148", "v149", "v150", "v151", 1890 "v152", "v153", "v154", "v155", "v156", "v157", "v158", "v159", 1891 "v160", "v161", "v162", "v163", "v164", "v165", "v166", "v167", 1892 "v168", "v169", "v170", "v171", "v172", "v173", "v174", "v175", 1893 "v176", "v177", "v178", "v179", "v180", "v181", "v182", "v183", 1894 "v184", "v185", "v186", "v187", "v188", "v189", "v190", "v191", 1895 "v192", "v193", "v194", "v195", "v196", "v197", "v198", "v199", 1896 "v200", "v201", "v202", "v203", "v204", "v205", "v206", "v207", 1897 "v208", "v209", "v210", "v211", "v212", "v213", "v214", "v215", 1898 "v216", "v217", "v218", "v219", "v220", "v221", "v222", "v223", 1899 "v224", "v225", "v226", "v227", "v228", "v229", "v230", "v231", 1900 "v232", "v233", "v234", "v235", "v236", "v237", "v238", "v239", 1901 "v240", "v241", "v242", "v243", "v244", "v245", "v246", "v247", 1902 "v248", "v249", "v250", "v251", "v252", "v253", "v254", "v255", 1903 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", 1904 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15", 1905 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23", 1906 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", 1907 "s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39", 1908 "s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47", 1909 "s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55", 1910 "s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63", 1911 "s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71", 1912 "s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79", 1913 "s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87", 1914 "s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95", 1915 "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103", 1916 "s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111", 1917 "s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119", 1918 "s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127" 1919 "exec", "vcc", "scc", "m0", "flat_scr", "exec_lo", "exec_hi", 1920 "vcc_lo", "vcc_hi", "flat_scr_lo", "flat_scr_hi" 1921 }; 1922 1923 void R600TargetInfo::getGCCRegNames(const char * const *&Names, 1924 unsigned &NumNames) const { 1925 Names = GCCRegNames; 1926 NumNames = llvm::array_lengthof(GCCRegNames); 1927 } 1928 1929 // Namespace for x86 abstract base class 1930 const Builtin::Info BuiltinInfo[] = { 1931 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 1932 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 1933 ALL_LANGUAGES }, 1934 #include "clang/Basic/BuiltinsX86.def" 1935 }; 1936 1937 static const char* const GCCRegNames[] = { 1938 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp", 1939 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)", 1940 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame", 1941 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", 1942 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7", 1943 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 1944 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15", 1945 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7", 1946 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15", 1947 }; 1948 1949 const TargetInfo::AddlRegName AddlRegNames[] = { 1950 { { "al", "ah", "eax", "rax" }, 0 }, 1951 { { "bl", "bh", "ebx", "rbx" }, 3 }, 1952 { { "cl", "ch", "ecx", "rcx" }, 2 }, 1953 { { "dl", "dh", "edx", "rdx" }, 1 }, 1954 { { "esi", "rsi" }, 4 }, 1955 { { "edi", "rdi" }, 5 }, 1956 { { "esp", "rsp" }, 7 }, 1957 { { "ebp", "rbp" }, 6 }, 1958 }; 1959 1960 // X86 target abstract base class; x86-32 and x86-64 are very close, so 1961 // most of the implementation can be shared. 1962 class X86TargetInfo : public TargetInfo { 1963 enum X86SSEEnum { 1964 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F 1965 } SSELevel; 1966 enum MMX3DNowEnum { 1967 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon 1968 } MMX3DNowLevel; 1969 enum XOPEnum { 1970 NoXOP, 1971 SSE4A, 1972 FMA4, 1973 XOP 1974 } XOPLevel; 1975 1976 bool HasAES; 1977 bool HasPCLMUL; 1978 bool HasLZCNT; 1979 bool HasRDRND; 1980 bool HasFSGSBASE; 1981 bool HasBMI; 1982 bool HasBMI2; 1983 bool HasPOPCNT; 1984 bool HasRTM; 1985 bool HasPRFCHW; 1986 bool HasRDSEED; 1987 bool HasADX; 1988 bool HasTBM; 1989 bool HasFMA; 1990 bool HasF16C; 1991 bool HasAVX512CD, HasAVX512ER, HasAVX512PF, HasAVX512DQ, HasAVX512BW, 1992 HasAVX512VL; 1993 bool HasSHA; 1994 bool HasCX16; 1995 1996 /// \brief Enumeration of all of the X86 CPUs supported by Clang. 1997 /// 1998 /// Each enumeration represents a particular CPU supported by Clang. These 1999 /// loosely correspond to the options passed to '-march' or '-mtune' flags. 2000 enum CPUKind { 2001 CK_Generic, 2002 2003 /// \name i386 2004 /// i386-generation processors. 2005 //@{ 2006 CK_i386, 2007 //@} 2008 2009 /// \name i486 2010 /// i486-generation processors. 2011 //@{ 2012 CK_i486, 2013 CK_WinChipC6, 2014 CK_WinChip2, 2015 CK_C3, 2016 //@} 2017 2018 /// \name i586 2019 /// i586-generation processors, P5 microarchitecture based. 2020 //@{ 2021 CK_i586, 2022 CK_Pentium, 2023 CK_PentiumMMX, 2024 //@} 2025 2026 /// \name i686 2027 /// i686-generation processors, P6 / Pentium M microarchitecture based. 2028 //@{ 2029 CK_i686, 2030 CK_PentiumPro, 2031 CK_Pentium2, 2032 CK_Pentium3, 2033 CK_Pentium3M, 2034 CK_PentiumM, 2035 CK_C3_2, 2036 2037 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah. 2038 /// Clang however has some logic to suport this. 2039 // FIXME: Warn, deprecate, and potentially remove this. 2040 CK_Yonah, 2041 //@} 2042 2043 /// \name Netburst 2044 /// Netburst microarchitecture based processors. 2045 //@{ 2046 CK_Pentium4, 2047 CK_Pentium4M, 2048 CK_Prescott, 2049 CK_Nocona, 2050 //@} 2051 2052 /// \name Core 2053 /// Core microarchitecture based processors. 2054 //@{ 2055 CK_Core2, 2056 2057 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another 2058 /// codename which GCC no longer accepts as an option to -march, but Clang 2059 /// has some logic for recognizing it. 2060 // FIXME: Warn, deprecate, and potentially remove this. 2061 CK_Penryn, 2062 //@} 2063 2064 /// \name Atom 2065 /// Atom processors 2066 //@{ 2067 CK_Bonnell, 2068 CK_Silvermont, 2069 //@} 2070 2071 /// \name Nehalem 2072 /// Nehalem microarchitecture based processors. 2073 CK_Nehalem, 2074 2075 /// \name Westmere 2076 /// Westmere microarchitecture based processors. 2077 CK_Westmere, 2078 2079 /// \name Sandy Bridge 2080 /// Sandy Bridge microarchitecture based processors. 2081 CK_SandyBridge, 2082 2083 /// \name Ivy Bridge 2084 /// Ivy Bridge microarchitecture based processors. 2085 CK_IvyBridge, 2086 2087 /// \name Haswell 2088 /// Haswell microarchitecture based processors. 2089 CK_Haswell, 2090 2091 /// \name Broadwell 2092 /// Broadwell microarchitecture based processors. 2093 CK_Broadwell, 2094 2095 /// \name Skylake 2096 /// Skylake microarchitecture based processors. 2097 CK_Skylake, 2098 2099 /// \name Knights Landing 2100 /// Knights Landing processor. 2101 CK_KNL, 2102 2103 /// \name K6 2104 /// K6 architecture processors. 2105 //@{ 2106 CK_K6, 2107 CK_K6_2, 2108 CK_K6_3, 2109 //@} 2110 2111 /// \name K7 2112 /// K7 architecture processors. 2113 //@{ 2114 CK_Athlon, 2115 CK_AthlonThunderbird, 2116 CK_Athlon4, 2117 CK_AthlonXP, 2118 CK_AthlonMP, 2119 //@} 2120 2121 /// \name K8 2122 /// K8 architecture processors. 2123 //@{ 2124 CK_Athlon64, 2125 CK_Athlon64SSE3, 2126 CK_AthlonFX, 2127 CK_K8, 2128 CK_K8SSE3, 2129 CK_Opteron, 2130 CK_OpteronSSE3, 2131 CK_AMDFAM10, 2132 //@} 2133 2134 /// \name Bobcat 2135 /// Bobcat architecture processors. 2136 //@{ 2137 CK_BTVER1, 2138 CK_BTVER2, 2139 //@} 2140 2141 /// \name Bulldozer 2142 /// Bulldozer architecture processors. 2143 //@{ 2144 CK_BDVER1, 2145 CK_BDVER2, 2146 CK_BDVER3, 2147 CK_BDVER4, 2148 //@} 2149 2150 /// This specification is deprecated and will be removed in the future. 2151 /// Users should prefer \see CK_K8. 2152 // FIXME: Warn on this when the CPU is set to it. 2153 //@{ 2154 CK_x86_64, 2155 //@} 2156 2157 /// \name Geode 2158 /// Geode processors. 2159 //@{ 2160 CK_Geode 2161 //@} 2162 } CPU; 2163 2164 enum FPMathKind { 2165 FP_Default, 2166 FP_SSE, 2167 FP_387 2168 } FPMath; 2169 2170 public: 2171 X86TargetInfo(const llvm::Triple &Triple) 2172 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow), 2173 XOPLevel(NoXOP), HasAES(false), HasPCLMUL(false), HasLZCNT(false), 2174 HasRDRND(false), HasFSGSBASE(false), HasBMI(false), HasBMI2(false), 2175 HasPOPCNT(false), HasRTM(false), HasPRFCHW(false), HasRDSEED(false), 2176 HasADX(false), HasTBM(false), HasFMA(false), HasF16C(false), 2177 HasAVX512CD(false), HasAVX512ER(false), HasAVX512PF(false), 2178 HasAVX512DQ(false), HasAVX512BW(false), HasAVX512VL(false), 2179 HasSHA(false), HasCX16(false), CPU(CK_Generic), FPMath(FP_Default) { 2180 BigEndian = false; 2181 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended; 2182 } 2183 unsigned getFloatEvalMethod() const override { 2184 // X87 evaluates with 80 bits "long double" precision. 2185 return SSELevel == NoSSE ? 2 : 0; 2186 } 2187 void getTargetBuiltins(const Builtin::Info *&Records, 2188 unsigned &NumRecords) const override { 2189 Records = BuiltinInfo; 2190 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin; 2191 } 2192 void getGCCRegNames(const char * const *&Names, 2193 unsigned &NumNames) const override { 2194 Names = GCCRegNames; 2195 NumNames = llvm::array_lengthof(GCCRegNames); 2196 } 2197 void getGCCRegAliases(const GCCRegAlias *&Aliases, 2198 unsigned &NumAliases) const override { 2199 Aliases = nullptr; 2200 NumAliases = 0; 2201 } 2202 void getGCCAddlRegNames(const AddlRegName *&Names, 2203 unsigned &NumNames) const override { 2204 Names = AddlRegNames; 2205 NumNames = llvm::array_lengthof(AddlRegNames); 2206 } 2207 bool validateAsmConstraint(const char *&Name, 2208 TargetInfo::ConstraintInfo &info) const override; 2209 2210 bool validateOutputSize(StringRef Constraint, unsigned Size) const override; 2211 2212 bool validateInputSize(StringRef Constraint, unsigned Size) const override; 2213 2214 virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const; 2215 2216 std::string convertConstraint(const char *&Constraint) const override; 2217 const char *getClobbers() const override { 2218 return "~{dirflag},~{fpsr},~{flags}"; 2219 } 2220 void getTargetDefines(const LangOptions &Opts, 2221 MacroBuilder &Builder) const override; 2222 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level, 2223 bool Enabled); 2224 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level, 2225 bool Enabled); 2226 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level, 2227 bool Enabled); 2228 void setFeatureEnabled(llvm::StringMap<bool> &Features, 2229 StringRef Name, bool Enabled) const override { 2230 setFeatureEnabledImpl(Features, Name, Enabled); 2231 } 2232 // This exists purely to cut down on the number of virtual calls in 2233 // getDefaultFeatures which calls this repeatedly. 2234 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features, 2235 StringRef Name, bool Enabled); 2236 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override; 2237 bool hasFeature(StringRef Feature) const override; 2238 bool handleTargetFeatures(std::vector<std::string> &Features, 2239 DiagnosticsEngine &Diags) override; 2240 StringRef getABI() const override { 2241 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX) 2242 return "avx"; 2243 else if (getTriple().getArch() == llvm::Triple::x86 && 2244 MMX3DNowLevel == NoMMX3DNow) 2245 return "no-mmx"; 2246 return ""; 2247 } 2248 bool setCPU(const std::string &Name) override { 2249 CPU = llvm::StringSwitch<CPUKind>(Name) 2250 .Case("i386", CK_i386) 2251 .Case("i486", CK_i486) 2252 .Case("winchip-c6", CK_WinChipC6) 2253 .Case("winchip2", CK_WinChip2) 2254 .Case("c3", CK_C3) 2255 .Case("i586", CK_i586) 2256 .Case("pentium", CK_Pentium) 2257 .Case("pentium-mmx", CK_PentiumMMX) 2258 .Case("i686", CK_i686) 2259 .Case("pentiumpro", CK_PentiumPro) 2260 .Case("pentium2", CK_Pentium2) 2261 .Case("pentium3", CK_Pentium3) 2262 .Case("pentium3m", CK_Pentium3M) 2263 .Case("pentium-m", CK_PentiumM) 2264 .Case("c3-2", CK_C3_2) 2265 .Case("yonah", CK_Yonah) 2266 .Case("pentium4", CK_Pentium4) 2267 .Case("pentium4m", CK_Pentium4M) 2268 .Case("prescott", CK_Prescott) 2269 .Case("nocona", CK_Nocona) 2270 .Case("core2", CK_Core2) 2271 .Case("penryn", CK_Penryn) 2272 .Case("bonnell", CK_Bonnell) 2273 .Case("atom", CK_Bonnell) // Legacy name. 2274 .Case("silvermont", CK_Silvermont) 2275 .Case("slm", CK_Silvermont) // Legacy name. 2276 .Case("nehalem", CK_Nehalem) 2277 .Case("corei7", CK_Nehalem) // Legacy name. 2278 .Case("westmere", CK_Westmere) 2279 .Case("sandybridge", CK_SandyBridge) 2280 .Case("corei7-avx", CK_SandyBridge) // Legacy name. 2281 .Case("ivybridge", CK_IvyBridge) 2282 .Case("core-avx-i", CK_IvyBridge) // Legacy name. 2283 .Case("haswell", CK_Haswell) 2284 .Case("core-avx2", CK_Haswell) // Legacy name. 2285 .Case("broadwell", CK_Broadwell) 2286 .Case("skylake", CK_Skylake) 2287 .Case("skx", CK_Skylake) // Legacy name. 2288 .Case("knl", CK_KNL) 2289 .Case("k6", CK_K6) 2290 .Case("k6-2", CK_K6_2) 2291 .Case("k6-3", CK_K6_3) 2292 .Case("athlon", CK_Athlon) 2293 .Case("athlon-tbird", CK_AthlonThunderbird) 2294 .Case("athlon-4", CK_Athlon4) 2295 .Case("athlon-xp", CK_AthlonXP) 2296 .Case("athlon-mp", CK_AthlonMP) 2297 .Case("athlon64", CK_Athlon64) 2298 .Case("athlon64-sse3", CK_Athlon64SSE3) 2299 .Case("athlon-fx", CK_AthlonFX) 2300 .Case("k8", CK_K8) 2301 .Case("k8-sse3", CK_K8SSE3) 2302 .Case("opteron", CK_Opteron) 2303 .Case("opteron-sse3", CK_OpteronSSE3) 2304 .Case("barcelona", CK_AMDFAM10) 2305 .Case("amdfam10", CK_AMDFAM10) 2306 .Case("btver1", CK_BTVER1) 2307 .Case("btver2", CK_BTVER2) 2308 .Case("bdver1", CK_BDVER1) 2309 .Case("bdver2", CK_BDVER2) 2310 .Case("bdver3", CK_BDVER3) 2311 .Case("bdver4", CK_BDVER4) 2312 .Case("x86-64", CK_x86_64) 2313 .Case("geode", CK_Geode) 2314 .Default(CK_Generic); 2315 2316 // Perform any per-CPU checks necessary to determine if this CPU is 2317 // acceptable. 2318 // FIXME: This results in terrible diagnostics. Clang just says the CPU is 2319 // invalid without explaining *why*. 2320 switch (CPU) { 2321 case CK_Generic: 2322 // No processor selected! 2323 return false; 2324 2325 case CK_i386: 2326 case CK_i486: 2327 case CK_WinChipC6: 2328 case CK_WinChip2: 2329 case CK_C3: 2330 case CK_i586: 2331 case CK_Pentium: 2332 case CK_PentiumMMX: 2333 case CK_i686: 2334 case CK_PentiumPro: 2335 case CK_Pentium2: 2336 case CK_Pentium3: 2337 case CK_Pentium3M: 2338 case CK_PentiumM: 2339 case CK_Yonah: 2340 case CK_C3_2: 2341 case CK_Pentium4: 2342 case CK_Pentium4M: 2343 case CK_Prescott: 2344 case CK_K6: 2345 case CK_K6_2: 2346 case CK_K6_3: 2347 case CK_Athlon: 2348 case CK_AthlonThunderbird: 2349 case CK_Athlon4: 2350 case CK_AthlonXP: 2351 case CK_AthlonMP: 2352 case CK_Geode: 2353 // Only accept certain architectures when compiling in 32-bit mode. 2354 if (getTriple().getArch() != llvm::Triple::x86) 2355 return false; 2356 2357 // Fallthrough 2358 case CK_Nocona: 2359 case CK_Core2: 2360 case CK_Penryn: 2361 case CK_Bonnell: 2362 case CK_Silvermont: 2363 case CK_Nehalem: 2364 case CK_Westmere: 2365 case CK_SandyBridge: 2366 case CK_IvyBridge: 2367 case CK_Haswell: 2368 case CK_Broadwell: 2369 case CK_Skylake: 2370 case CK_KNL: 2371 case CK_Athlon64: 2372 case CK_Athlon64SSE3: 2373 case CK_AthlonFX: 2374 case CK_K8: 2375 case CK_K8SSE3: 2376 case CK_Opteron: 2377 case CK_OpteronSSE3: 2378 case CK_AMDFAM10: 2379 case CK_BTVER1: 2380 case CK_BTVER2: 2381 case CK_BDVER1: 2382 case CK_BDVER2: 2383 case CK_BDVER3: 2384 case CK_BDVER4: 2385 case CK_x86_64: 2386 return true; 2387 } 2388 llvm_unreachable("Unhandled CPU kind"); 2389 } 2390 2391 bool setFPMath(StringRef Name) override; 2392 2393 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override { 2394 // We accept all non-ARM calling conventions 2395 return (CC == CC_X86ThisCall || 2396 CC == CC_X86FastCall || 2397 CC == CC_X86StdCall || 2398 CC == CC_X86VectorCall || 2399 CC == CC_C || 2400 CC == CC_X86Pascal || 2401 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning; 2402 } 2403 2404 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override { 2405 return MT == CCMT_Member ? CC_X86ThisCall : CC_C; 2406 } 2407 2408 bool hasSjLjLowering() const override { 2409 return true; 2410 } 2411 }; 2412 2413 bool X86TargetInfo::setFPMath(StringRef Name) { 2414 if (Name == "387") { 2415 FPMath = FP_387; 2416 return true; 2417 } 2418 if (Name == "sse") { 2419 FPMath = FP_SSE; 2420 return true; 2421 } 2422 return false; 2423 } 2424 2425 void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const { 2426 // FIXME: This *really* should not be here. 2427 2428 // X86_64 always has SSE2. 2429 if (getTriple().getArch() == llvm::Triple::x86_64) 2430 setFeatureEnabledImpl(Features, "sse2", true); 2431 2432 switch (CPU) { 2433 case CK_Generic: 2434 case CK_i386: 2435 case CK_i486: 2436 case CK_i586: 2437 case CK_Pentium: 2438 case CK_i686: 2439 case CK_PentiumPro: 2440 break; 2441 case CK_PentiumMMX: 2442 case CK_Pentium2: 2443 case CK_K6: 2444 case CK_WinChipC6: 2445 setFeatureEnabledImpl(Features, "mmx", true); 2446 break; 2447 case CK_Pentium3: 2448 case CK_Pentium3M: 2449 case CK_C3_2: 2450 setFeatureEnabledImpl(Features, "sse", true); 2451 break; 2452 case CK_PentiumM: 2453 case CK_Pentium4: 2454 case CK_Pentium4M: 2455 case CK_x86_64: 2456 setFeatureEnabledImpl(Features, "sse2", true); 2457 break; 2458 case CK_Yonah: 2459 case CK_Prescott: 2460 case CK_Nocona: 2461 setFeatureEnabledImpl(Features, "sse3", true); 2462 setFeatureEnabledImpl(Features, "cx16", true); 2463 break; 2464 case CK_Core2: 2465 case CK_Bonnell: 2466 setFeatureEnabledImpl(Features, "ssse3", true); 2467 setFeatureEnabledImpl(Features, "cx16", true); 2468 break; 2469 case CK_Penryn: 2470 setFeatureEnabledImpl(Features, "sse4.1", true); 2471 setFeatureEnabledImpl(Features, "cx16", true); 2472 break; 2473 case CK_Skylake: 2474 setFeatureEnabledImpl(Features, "avx512f", true); 2475 setFeatureEnabledImpl(Features, "avx512cd", true); 2476 setFeatureEnabledImpl(Features, "avx512dq", true); 2477 setFeatureEnabledImpl(Features, "avx512bw", true); 2478 setFeatureEnabledImpl(Features, "avx512vl", true); 2479 // FALLTHROUGH 2480 case CK_Broadwell: 2481 setFeatureEnabledImpl(Features, "rdseed", true); 2482 setFeatureEnabledImpl(Features, "adx", true); 2483 // FALLTHROUGH 2484 case CK_Haswell: 2485 setFeatureEnabledImpl(Features, "avx2", true); 2486 setFeatureEnabledImpl(Features, "lzcnt", true); 2487 setFeatureEnabledImpl(Features, "bmi", true); 2488 setFeatureEnabledImpl(Features, "bmi2", true); 2489 setFeatureEnabledImpl(Features, "rtm", true); 2490 setFeatureEnabledImpl(Features, "fma", true); 2491 // FALLTHROUGH 2492 case CK_IvyBridge: 2493 setFeatureEnabledImpl(Features, "rdrnd", true); 2494 setFeatureEnabledImpl(Features, "f16c", true); 2495 setFeatureEnabledImpl(Features, "fsgsbase", true); 2496 // FALLTHROUGH 2497 case CK_SandyBridge: 2498 setFeatureEnabledImpl(Features, "avx", true); 2499 // FALLTHROUGH 2500 case CK_Westmere: 2501 case CK_Silvermont: 2502 setFeatureEnabledImpl(Features, "aes", true); 2503 setFeatureEnabledImpl(Features, "pclmul", true); 2504 // FALLTHROUGH 2505 case CK_Nehalem: 2506 setFeatureEnabledImpl(Features, "sse4.2", true); 2507 setFeatureEnabledImpl(Features, "cx16", true); 2508 break; 2509 case CK_KNL: 2510 setFeatureEnabledImpl(Features, "avx512f", true); 2511 setFeatureEnabledImpl(Features, "avx512cd", true); 2512 setFeatureEnabledImpl(Features, "avx512er", true); 2513 setFeatureEnabledImpl(Features, "avx512pf", true); 2514 setFeatureEnabledImpl(Features, "rdseed", true); 2515 setFeatureEnabledImpl(Features, "adx", true); 2516 setFeatureEnabledImpl(Features, "lzcnt", true); 2517 setFeatureEnabledImpl(Features, "bmi", true); 2518 setFeatureEnabledImpl(Features, "bmi2", true); 2519 setFeatureEnabledImpl(Features, "rtm", true); 2520 setFeatureEnabledImpl(Features, "fma", true); 2521 setFeatureEnabledImpl(Features, "rdrnd", true); 2522 setFeatureEnabledImpl(Features, "f16c", true); 2523 setFeatureEnabledImpl(Features, "fsgsbase", true); 2524 setFeatureEnabledImpl(Features, "aes", true); 2525 setFeatureEnabledImpl(Features, "pclmul", true); 2526 setFeatureEnabledImpl(Features, "cx16", true); 2527 break; 2528 case CK_K6_2: 2529 case CK_K6_3: 2530 case CK_WinChip2: 2531 case CK_C3: 2532 setFeatureEnabledImpl(Features, "3dnow", true); 2533 break; 2534 case CK_Athlon: 2535 case CK_AthlonThunderbird: 2536 case CK_Geode: 2537 setFeatureEnabledImpl(Features, "3dnowa", true); 2538 break; 2539 case CK_Athlon4: 2540 case CK_AthlonXP: 2541 case CK_AthlonMP: 2542 setFeatureEnabledImpl(Features, "sse", true); 2543 setFeatureEnabledImpl(Features, "3dnowa", true); 2544 break; 2545 case CK_K8: 2546 case CK_Opteron: 2547 case CK_Athlon64: 2548 case CK_AthlonFX: 2549 setFeatureEnabledImpl(Features, "sse2", true); 2550 setFeatureEnabledImpl(Features, "3dnowa", true); 2551 break; 2552 case CK_AMDFAM10: 2553 setFeatureEnabledImpl(Features, "sse4a", true); 2554 setFeatureEnabledImpl(Features, "lzcnt", true); 2555 setFeatureEnabledImpl(Features, "popcnt", true); 2556 // FALLTHROUGH 2557 case CK_K8SSE3: 2558 case CK_OpteronSSE3: 2559 case CK_Athlon64SSE3: 2560 setFeatureEnabledImpl(Features, "sse3", true); 2561 setFeatureEnabledImpl(Features, "3dnowa", true); 2562 break; 2563 case CK_BTVER2: 2564 setFeatureEnabledImpl(Features, "avx", true); 2565 setFeatureEnabledImpl(Features, "aes", true); 2566 setFeatureEnabledImpl(Features, "pclmul", true); 2567 setFeatureEnabledImpl(Features, "bmi", true); 2568 setFeatureEnabledImpl(Features, "f16c", true); 2569 // FALLTHROUGH 2570 case CK_BTVER1: 2571 setFeatureEnabledImpl(Features, "ssse3", true); 2572 setFeatureEnabledImpl(Features, "sse4a", true); 2573 setFeatureEnabledImpl(Features, "lzcnt", true); 2574 setFeatureEnabledImpl(Features, "popcnt", true); 2575 setFeatureEnabledImpl(Features, "prfchw", true); 2576 setFeatureEnabledImpl(Features, "cx16", true); 2577 break; 2578 case CK_BDVER4: 2579 setFeatureEnabledImpl(Features, "avx2", true); 2580 setFeatureEnabledImpl(Features, "bmi2", true); 2581 // FALLTHROUGH 2582 case CK_BDVER3: 2583 setFeatureEnabledImpl(Features, "fsgsbase", true); 2584 // FALLTHROUGH 2585 case CK_BDVER2: 2586 setFeatureEnabledImpl(Features, "bmi", true); 2587 setFeatureEnabledImpl(Features, "fma", true); 2588 setFeatureEnabledImpl(Features, "f16c", true); 2589 setFeatureEnabledImpl(Features, "tbm", true); 2590 // FALLTHROUGH 2591 case CK_BDVER1: 2592 // xop implies avx, sse4a and fma4. 2593 setFeatureEnabledImpl(Features, "xop", true); 2594 setFeatureEnabledImpl(Features, "lzcnt", true); 2595 setFeatureEnabledImpl(Features, "aes", true); 2596 setFeatureEnabledImpl(Features, "pclmul", true); 2597 setFeatureEnabledImpl(Features, "prfchw", true); 2598 setFeatureEnabledImpl(Features, "cx16", true); 2599 break; 2600 } 2601 } 2602 2603 void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features, 2604 X86SSEEnum Level, bool Enabled) { 2605 if (Enabled) { 2606 switch (Level) { 2607 case AVX512F: 2608 Features["avx512f"] = true; 2609 case AVX2: 2610 Features["avx2"] = true; 2611 case AVX: 2612 Features["avx"] = true; 2613 case SSE42: 2614 Features["sse4.2"] = true; 2615 case SSE41: 2616 Features["sse4.1"] = true; 2617 case SSSE3: 2618 Features["ssse3"] = true; 2619 case SSE3: 2620 Features["sse3"] = true; 2621 case SSE2: 2622 Features["sse2"] = true; 2623 case SSE1: 2624 Features["sse"] = true; 2625 case NoSSE: 2626 break; 2627 } 2628 return; 2629 } 2630 2631 switch (Level) { 2632 case NoSSE: 2633 case SSE1: 2634 Features["sse"] = false; 2635 case SSE2: 2636 Features["sse2"] = Features["pclmul"] = Features["aes"] = 2637 Features["sha"] = false; 2638 case SSE3: 2639 Features["sse3"] = false; 2640 setXOPLevel(Features, NoXOP, false); 2641 case SSSE3: 2642 Features["ssse3"] = false; 2643 case SSE41: 2644 Features["sse4.1"] = false; 2645 case SSE42: 2646 Features["sse4.2"] = false; 2647 case AVX: 2648 Features["fma"] = Features["avx"] = Features["f16c"] = false; 2649 setXOPLevel(Features, FMA4, false); 2650 case AVX2: 2651 Features["avx2"] = false; 2652 case AVX512F: 2653 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] = 2654 Features["avx512pf"] = Features["avx512dq"] = Features["avx512bw"] = 2655 Features["avx512vl"] = false; 2656 } 2657 } 2658 2659 void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features, 2660 MMX3DNowEnum Level, bool Enabled) { 2661 if (Enabled) { 2662 switch (Level) { 2663 case AMD3DNowAthlon: 2664 Features["3dnowa"] = true; 2665 case AMD3DNow: 2666 Features["3dnow"] = true; 2667 case MMX: 2668 Features["mmx"] = true; 2669 case NoMMX3DNow: 2670 break; 2671 } 2672 return; 2673 } 2674 2675 switch (Level) { 2676 case NoMMX3DNow: 2677 case MMX: 2678 Features["mmx"] = false; 2679 case AMD3DNow: 2680 Features["3dnow"] = false; 2681 case AMD3DNowAthlon: 2682 Features["3dnowa"] = false; 2683 } 2684 } 2685 2686 void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level, 2687 bool Enabled) { 2688 if (Enabled) { 2689 switch (Level) { 2690 case XOP: 2691 Features["xop"] = true; 2692 case FMA4: 2693 Features["fma4"] = true; 2694 setSSELevel(Features, AVX, true); 2695 case SSE4A: 2696 Features["sse4a"] = true; 2697 setSSELevel(Features, SSE3, true); 2698 case NoXOP: 2699 break; 2700 } 2701 return; 2702 } 2703 2704 switch (Level) { 2705 case NoXOP: 2706 case SSE4A: 2707 Features["sse4a"] = false; 2708 case FMA4: 2709 Features["fma4"] = false; 2710 case XOP: 2711 Features["xop"] = false; 2712 } 2713 } 2714 2715 void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features, 2716 StringRef Name, bool Enabled) { 2717 Features[Name] = Enabled; 2718 2719 if (Name == "mmx") { 2720 setMMXLevel(Features, MMX, Enabled); 2721 } else if (Name == "sse") { 2722 setSSELevel(Features, SSE1, Enabled); 2723 } else if (Name == "sse2") { 2724 setSSELevel(Features, SSE2, Enabled); 2725 } else if (Name == "sse3") { 2726 setSSELevel(Features, SSE3, Enabled); 2727 } else if (Name == "ssse3") { 2728 setSSELevel(Features, SSSE3, Enabled); 2729 } else if (Name == "sse4.2") { 2730 setSSELevel(Features, SSE42, Enabled); 2731 } else if (Name == "sse4.1") { 2732 setSSELevel(Features, SSE41, Enabled); 2733 } else if (Name == "3dnow") { 2734 setMMXLevel(Features, AMD3DNow, Enabled); 2735 } else if (Name == "3dnowa") { 2736 setMMXLevel(Features, AMD3DNowAthlon, Enabled); 2737 } else if (Name == "aes") { 2738 if (Enabled) 2739 setSSELevel(Features, SSE2, Enabled); 2740 } else if (Name == "pclmul") { 2741 if (Enabled) 2742 setSSELevel(Features, SSE2, Enabled); 2743 } else if (Name == "avx") { 2744 setSSELevel(Features, AVX, Enabled); 2745 } else if (Name == "avx2") { 2746 setSSELevel(Features, AVX2, Enabled); 2747 } else if (Name == "avx512f") { 2748 setSSELevel(Features, AVX512F, Enabled); 2749 } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf" 2750 || Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl") { 2751 if (Enabled) 2752 setSSELevel(Features, AVX512F, Enabled); 2753 } else if (Name == "fma") { 2754 if (Enabled) 2755 setSSELevel(Features, AVX, Enabled); 2756 } else if (Name == "fma4") { 2757 setXOPLevel(Features, FMA4, Enabled); 2758 } else if (Name == "xop") { 2759 setXOPLevel(Features, XOP, Enabled); 2760 } else if (Name == "sse4a") { 2761 setXOPLevel(Features, SSE4A, Enabled); 2762 } else if (Name == "f16c") { 2763 if (Enabled) 2764 setSSELevel(Features, AVX, Enabled); 2765 } else if (Name == "sha") { 2766 if (Enabled) 2767 setSSELevel(Features, SSE2, Enabled); 2768 } 2769 } 2770 2771 /// handleTargetFeatures - Perform initialization based on the user 2772 /// configured set of features. 2773 bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, 2774 DiagnosticsEngine &Diags) { 2775 // Remember the maximum enabled sselevel. 2776 for (unsigned i = 0, e = Features.size(); i !=e; ++i) { 2777 // Ignore disabled features. 2778 if (Features[i][0] == '-') 2779 continue; 2780 2781 StringRef Feature = StringRef(Features[i]).substr(1); 2782 2783 if (Feature == "aes") { 2784 HasAES = true; 2785 continue; 2786 } 2787 2788 if (Feature == "pclmul") { 2789 HasPCLMUL = true; 2790 continue; 2791 } 2792 2793 if (Feature == "lzcnt") { 2794 HasLZCNT = true; 2795 continue; 2796 } 2797 2798 if (Feature == "rdrnd") { 2799 HasRDRND = true; 2800 continue; 2801 } 2802 2803 if (Feature == "fsgsbase") { 2804 HasFSGSBASE = true; 2805 continue; 2806 } 2807 2808 if (Feature == "bmi") { 2809 HasBMI = true; 2810 continue; 2811 } 2812 2813 if (Feature == "bmi2") { 2814 HasBMI2 = true; 2815 continue; 2816 } 2817 2818 if (Feature == "popcnt") { 2819 HasPOPCNT = true; 2820 continue; 2821 } 2822 2823 if (Feature == "rtm") { 2824 HasRTM = true; 2825 continue; 2826 } 2827 2828 if (Feature == "prfchw") { 2829 HasPRFCHW = true; 2830 continue; 2831 } 2832 2833 if (Feature == "rdseed") { 2834 HasRDSEED = true; 2835 continue; 2836 } 2837 2838 if (Feature == "adx") { 2839 HasADX = true; 2840 continue; 2841 } 2842 2843 if (Feature == "tbm") { 2844 HasTBM = true; 2845 continue; 2846 } 2847 2848 if (Feature == "fma") { 2849 HasFMA = true; 2850 continue; 2851 } 2852 2853 if (Feature == "f16c") { 2854 HasF16C = true; 2855 continue; 2856 } 2857 2858 if (Feature == "avx512cd") { 2859 HasAVX512CD = true; 2860 continue; 2861 } 2862 2863 if (Feature == "avx512er") { 2864 HasAVX512ER = true; 2865 continue; 2866 } 2867 2868 if (Feature == "avx512pf") { 2869 HasAVX512PF = true; 2870 continue; 2871 } 2872 2873 if (Feature == "avx512dq") { 2874 HasAVX512DQ = true; 2875 continue; 2876 } 2877 2878 if (Feature == "avx512bw") { 2879 HasAVX512BW = true; 2880 continue; 2881 } 2882 2883 if (Feature == "avx512vl") { 2884 HasAVX512VL = true; 2885 continue; 2886 } 2887 2888 if (Feature == "sha") { 2889 HasSHA = true; 2890 continue; 2891 } 2892 2893 if (Feature == "cx16") { 2894 HasCX16 = true; 2895 continue; 2896 } 2897 2898 assert(Features[i][0] == '+' && "Invalid target feature!"); 2899 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature) 2900 .Case("avx512f", AVX512F) 2901 .Case("avx2", AVX2) 2902 .Case("avx", AVX) 2903 .Case("sse4.2", SSE42) 2904 .Case("sse4.1", SSE41) 2905 .Case("ssse3", SSSE3) 2906 .Case("sse3", SSE3) 2907 .Case("sse2", SSE2) 2908 .Case("sse", SSE1) 2909 .Default(NoSSE); 2910 SSELevel = std::max(SSELevel, Level); 2911 2912 MMX3DNowEnum ThreeDNowLevel = 2913 llvm::StringSwitch<MMX3DNowEnum>(Feature) 2914 .Case("3dnowa", AMD3DNowAthlon) 2915 .Case("3dnow", AMD3DNow) 2916 .Case("mmx", MMX) 2917 .Default(NoMMX3DNow); 2918 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel); 2919 2920 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature) 2921 .Case("xop", XOP) 2922 .Case("fma4", FMA4) 2923 .Case("sse4a", SSE4A) 2924 .Default(NoXOP); 2925 XOPLevel = std::max(XOPLevel, XLevel); 2926 } 2927 2928 // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled. 2929 // Can't do this earlier because we need to be able to explicitly enable 2930 // popcnt and still disable sse4.2. 2931 if (!HasPOPCNT && SSELevel >= SSE42 && 2932 std::find(Features.begin(), Features.end(), "-popcnt") == Features.end()){ 2933 HasPOPCNT = true; 2934 Features.push_back("+popcnt"); 2935 } 2936 2937 // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled. 2938 if (!HasPRFCHW && MMX3DNowLevel >= AMD3DNow && 2939 std::find(Features.begin(), Features.end(), "-prfchw") == Features.end()){ 2940 HasPRFCHW = true; 2941 Features.push_back("+prfchw"); 2942 } 2943 2944 // LLVM doesn't have a separate switch for fpmath, so only accept it if it 2945 // matches the selected sse level. 2946 if (FPMath == FP_SSE && SSELevel < SSE1) { 2947 Diags.Report(diag::err_target_unsupported_fpmath) << "sse"; 2948 return false; 2949 } else if (FPMath == FP_387 && SSELevel >= SSE1) { 2950 Diags.Report(diag::err_target_unsupported_fpmath) << "387"; 2951 return false; 2952 } 2953 2954 // Don't tell the backend if we're turning off mmx; it will end up disabling 2955 // SSE, which we don't want. 2956 // Additionally, if SSE is enabled and mmx is not explicitly disabled, 2957 // then enable MMX. 2958 std::vector<std::string>::iterator it; 2959 it = std::find(Features.begin(), Features.end(), "-mmx"); 2960 if (it != Features.end()) 2961 Features.erase(it); 2962 else if (SSELevel > NoSSE) 2963 MMX3DNowLevel = std::max(MMX3DNowLevel, MMX); 2964 return true; 2965 } 2966 2967 /// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro 2968 /// definitions for this particular subtarget. 2969 void X86TargetInfo::getTargetDefines(const LangOptions &Opts, 2970 MacroBuilder &Builder) const { 2971 // Target identification. 2972 if (getTriple().getArch() == llvm::Triple::x86_64) { 2973 Builder.defineMacro("__amd64__"); 2974 Builder.defineMacro("__amd64"); 2975 Builder.defineMacro("__x86_64"); 2976 Builder.defineMacro("__x86_64__"); 2977 if (getTriple().getArchName() == "x86_64h") { 2978 Builder.defineMacro("__x86_64h"); 2979 Builder.defineMacro("__x86_64h__"); 2980 } 2981 } else { 2982 DefineStd(Builder, "i386", Opts); 2983 } 2984 2985 // Subtarget options. 2986 // FIXME: We are hard-coding the tune parameters based on the CPU, but they 2987 // truly should be based on -mtune options. 2988 switch (CPU) { 2989 case CK_Generic: 2990 break; 2991 case CK_i386: 2992 // The rest are coming from the i386 define above. 2993 Builder.defineMacro("__tune_i386__"); 2994 break; 2995 case CK_i486: 2996 case CK_WinChipC6: 2997 case CK_WinChip2: 2998 case CK_C3: 2999 defineCPUMacros(Builder, "i486"); 3000 break; 3001 case CK_PentiumMMX: 3002 Builder.defineMacro("__pentium_mmx__"); 3003 Builder.defineMacro("__tune_pentium_mmx__"); 3004 // Fallthrough 3005 case CK_i586: 3006 case CK_Pentium: 3007 defineCPUMacros(Builder, "i586"); 3008 defineCPUMacros(Builder, "pentium"); 3009 break; 3010 case CK_Pentium3: 3011 case CK_Pentium3M: 3012 case CK_PentiumM: 3013 Builder.defineMacro("__tune_pentium3__"); 3014 // Fallthrough 3015 case CK_Pentium2: 3016 case CK_C3_2: 3017 Builder.defineMacro("__tune_pentium2__"); 3018 // Fallthrough 3019 case CK_PentiumPro: 3020 Builder.defineMacro("__tune_i686__"); 3021 Builder.defineMacro("__tune_pentiumpro__"); 3022 // Fallthrough 3023 case CK_i686: 3024 Builder.defineMacro("__i686"); 3025 Builder.defineMacro("__i686__"); 3026 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686. 3027 Builder.defineMacro("__pentiumpro"); 3028 Builder.defineMacro("__pentiumpro__"); 3029 break; 3030 case CK_Pentium4: 3031 case CK_Pentium4M: 3032 defineCPUMacros(Builder, "pentium4"); 3033 break; 3034 case CK_Yonah: 3035 case CK_Prescott: 3036 case CK_Nocona: 3037 defineCPUMacros(Builder, "nocona"); 3038 break; 3039 case CK_Core2: 3040 case CK_Penryn: 3041 defineCPUMacros(Builder, "core2"); 3042 break; 3043 case CK_Bonnell: 3044 defineCPUMacros(Builder, "atom"); 3045 break; 3046 case CK_Silvermont: 3047 defineCPUMacros(Builder, "slm"); 3048 break; 3049 case CK_Nehalem: 3050 case CK_Westmere: 3051 case CK_SandyBridge: 3052 case CK_IvyBridge: 3053 case CK_Haswell: 3054 case CK_Broadwell: 3055 // FIXME: Historically, we defined this legacy name, it would be nice to 3056 // remove it at some point. We've never exposed fine-grained names for 3057 // recent primary x86 CPUs, and we should keep it that way. 3058 defineCPUMacros(Builder, "corei7"); 3059 break; 3060 case CK_Skylake: 3061 // FIXME: Historically, we defined this legacy name, it would be nice to 3062 // remove it at some point. This is the only fine-grained CPU macro in the 3063 // main intel CPU line, and it would be better to not have these and force 3064 // people to use ISA macros. 3065 defineCPUMacros(Builder, "skx"); 3066 break; 3067 case CK_KNL: 3068 defineCPUMacros(Builder, "knl"); 3069 break; 3070 case CK_K6_2: 3071 Builder.defineMacro("__k6_2__"); 3072 Builder.defineMacro("__tune_k6_2__"); 3073 // Fallthrough 3074 case CK_K6_3: 3075 if (CPU != CK_K6_2) { // In case of fallthrough 3076 // FIXME: GCC may be enabling these in cases where some other k6 3077 // architecture is specified but -m3dnow is explicitly provided. The 3078 // exact semantics need to be determined and emulated here. 3079 Builder.defineMacro("__k6_3__"); 3080 Builder.defineMacro("__tune_k6_3__"); 3081 } 3082 // Fallthrough 3083 case CK_K6: 3084 defineCPUMacros(Builder, "k6"); 3085 break; 3086 case CK_Athlon: 3087 case CK_AthlonThunderbird: 3088 case CK_Athlon4: 3089 case CK_AthlonXP: 3090 case CK_AthlonMP: 3091 defineCPUMacros(Builder, "athlon"); 3092 if (SSELevel != NoSSE) { 3093 Builder.defineMacro("__athlon_sse__"); 3094 Builder.defineMacro("__tune_athlon_sse__"); 3095 } 3096 break; 3097 case CK_K8: 3098 case CK_K8SSE3: 3099 case CK_x86_64: 3100 case CK_Opteron: 3101 case CK_OpteronSSE3: 3102 case CK_Athlon64: 3103 case CK_Athlon64SSE3: 3104 case CK_AthlonFX: 3105 defineCPUMacros(Builder, "k8"); 3106 break; 3107 case CK_AMDFAM10: 3108 defineCPUMacros(Builder, "amdfam10"); 3109 break; 3110 case CK_BTVER1: 3111 defineCPUMacros(Builder, "btver1"); 3112 break; 3113 case CK_BTVER2: 3114 defineCPUMacros(Builder, "btver2"); 3115 break; 3116 case CK_BDVER1: 3117 defineCPUMacros(Builder, "bdver1"); 3118 break; 3119 case CK_BDVER2: 3120 defineCPUMacros(Builder, "bdver2"); 3121 break; 3122 case CK_BDVER3: 3123 defineCPUMacros(Builder, "bdver3"); 3124 break; 3125 case CK_BDVER4: 3126 defineCPUMacros(Builder, "bdver4"); 3127 break; 3128 case CK_Geode: 3129 defineCPUMacros(Builder, "geode"); 3130 break; 3131 } 3132 3133 // Target properties. 3134 Builder.defineMacro("__REGISTER_PREFIX__", ""); 3135 3136 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline 3137 // functions in glibc header files that use FP Stack inline asm which the 3138 // backend can't deal with (PR879). 3139 Builder.defineMacro("__NO_MATH_INLINES"); 3140 3141 if (HasAES) 3142 Builder.defineMacro("__AES__"); 3143 3144 if (HasPCLMUL) 3145 Builder.defineMacro("__PCLMUL__"); 3146 3147 if (HasLZCNT) 3148 Builder.defineMacro("__LZCNT__"); 3149 3150 if (HasRDRND) 3151 Builder.defineMacro("__RDRND__"); 3152 3153 if (HasFSGSBASE) 3154 Builder.defineMacro("__FSGSBASE__"); 3155 3156 if (HasBMI) 3157 Builder.defineMacro("__BMI__"); 3158 3159 if (HasBMI2) 3160 Builder.defineMacro("__BMI2__"); 3161 3162 if (HasPOPCNT) 3163 Builder.defineMacro("__POPCNT__"); 3164 3165 if (HasRTM) 3166 Builder.defineMacro("__RTM__"); 3167 3168 if (HasPRFCHW) 3169 Builder.defineMacro("__PRFCHW__"); 3170 3171 if (HasRDSEED) 3172 Builder.defineMacro("__RDSEED__"); 3173 3174 if (HasADX) 3175 Builder.defineMacro("__ADX__"); 3176 3177 if (HasTBM) 3178 Builder.defineMacro("__TBM__"); 3179 3180 switch (XOPLevel) { 3181 case XOP: 3182 Builder.defineMacro("__XOP__"); 3183 case FMA4: 3184 Builder.defineMacro("__FMA4__"); 3185 case SSE4A: 3186 Builder.defineMacro("__SSE4A__"); 3187 case NoXOP: 3188 break; 3189 } 3190 3191 if (HasFMA) 3192 Builder.defineMacro("__FMA__"); 3193 3194 if (HasF16C) 3195 Builder.defineMacro("__F16C__"); 3196 3197 if (HasAVX512CD) 3198 Builder.defineMacro("__AVX512CD__"); 3199 if (HasAVX512ER) 3200 Builder.defineMacro("__AVX512ER__"); 3201 if (HasAVX512PF) 3202 Builder.defineMacro("__AVX512PF__"); 3203 if (HasAVX512DQ) 3204 Builder.defineMacro("__AVX512DQ__"); 3205 if (HasAVX512BW) 3206 Builder.defineMacro("__AVX512BW__"); 3207 if (HasAVX512VL) 3208 Builder.defineMacro("__AVX512VL__"); 3209 3210 if (HasSHA) 3211 Builder.defineMacro("__SHA__"); 3212 3213 if (HasCX16) 3214 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"); 3215 3216 // Each case falls through to the previous one here. 3217 switch (SSELevel) { 3218 case AVX512F: 3219 Builder.defineMacro("__AVX512F__"); 3220 case AVX2: 3221 Builder.defineMacro("__AVX2__"); 3222 case AVX: 3223 Builder.defineMacro("__AVX__"); 3224 case SSE42: 3225 Builder.defineMacro("__SSE4_2__"); 3226 case SSE41: 3227 Builder.defineMacro("__SSE4_1__"); 3228 case SSSE3: 3229 Builder.defineMacro("__SSSE3__"); 3230 case SSE3: 3231 Builder.defineMacro("__SSE3__"); 3232 case SSE2: 3233 Builder.defineMacro("__SSE2__"); 3234 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied. 3235 case SSE1: 3236 Builder.defineMacro("__SSE__"); 3237 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied. 3238 case NoSSE: 3239 break; 3240 } 3241 3242 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) { 3243 switch (SSELevel) { 3244 case AVX512F: 3245 case AVX2: 3246 case AVX: 3247 case SSE42: 3248 case SSE41: 3249 case SSSE3: 3250 case SSE3: 3251 case SSE2: 3252 Builder.defineMacro("_M_IX86_FP", Twine(2)); 3253 break; 3254 case SSE1: 3255 Builder.defineMacro("_M_IX86_FP", Twine(1)); 3256 break; 3257 default: 3258 Builder.defineMacro("_M_IX86_FP", Twine(0)); 3259 } 3260 } 3261 3262 // Each case falls through to the previous one here. 3263 switch (MMX3DNowLevel) { 3264 case AMD3DNowAthlon: 3265 Builder.defineMacro("__3dNOW_A__"); 3266 case AMD3DNow: 3267 Builder.defineMacro("__3dNOW__"); 3268 case MMX: 3269 Builder.defineMacro("__MMX__"); 3270 case NoMMX3DNow: 3271 break; 3272 } 3273 3274 if (CPU >= CK_i486) { 3275 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); 3276 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); 3277 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); 3278 } 3279 if (CPU >= CK_i586) 3280 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); 3281 } 3282 3283 bool X86TargetInfo::hasFeature(StringRef Feature) const { 3284 return llvm::StringSwitch<bool>(Feature) 3285 .Case("aes", HasAES) 3286 .Case("avx", SSELevel >= AVX) 3287 .Case("avx2", SSELevel >= AVX2) 3288 .Case("avx512f", SSELevel >= AVX512F) 3289 .Case("avx512cd", HasAVX512CD) 3290 .Case("avx512er", HasAVX512ER) 3291 .Case("avx512pf", HasAVX512PF) 3292 .Case("avx512dq", HasAVX512DQ) 3293 .Case("avx512bw", HasAVX512BW) 3294 .Case("avx512vl", HasAVX512VL) 3295 .Case("bmi", HasBMI) 3296 .Case("bmi2", HasBMI2) 3297 .Case("cx16", HasCX16) 3298 .Case("f16c", HasF16C) 3299 .Case("fma", HasFMA) 3300 .Case("fma4", XOPLevel >= FMA4) 3301 .Case("fsgsbase", HasFSGSBASE) 3302 .Case("lzcnt", HasLZCNT) 3303 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow) 3304 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon) 3305 .Case("mmx", MMX3DNowLevel >= MMX) 3306 .Case("pclmul", HasPCLMUL) 3307 .Case("popcnt", HasPOPCNT) 3308 .Case("prfchw", HasPRFCHW) 3309 .Case("rdrnd", HasRDRND) 3310 .Case("rdseed", HasRDSEED) 3311 .Case("rtm", HasRTM) 3312 .Case("sha", HasSHA) 3313 .Case("sse", SSELevel >= SSE1) 3314 .Case("sse2", SSELevel >= SSE2) 3315 .Case("sse3", SSELevel >= SSE3) 3316 .Case("ssse3", SSELevel >= SSSE3) 3317 .Case("sse4.1", SSELevel >= SSE41) 3318 .Case("sse4.2", SSELevel >= SSE42) 3319 .Case("sse4a", XOPLevel >= SSE4A) 3320 .Case("tbm", HasTBM) 3321 .Case("x86", true) 3322 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86) 3323 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64) 3324 .Case("xop", XOPLevel >= XOP) 3325 .Default(false); 3326 } 3327 3328 bool 3329 X86TargetInfo::validateAsmConstraint(const char *&Name, 3330 TargetInfo::ConstraintInfo &Info) const { 3331 switch (*Name) { 3332 default: return false; 3333 case 'I': 3334 Info.setRequiresImmediate(0, 31); 3335 return true; 3336 case 'J': 3337 Info.setRequiresImmediate(0, 63); 3338 return true; 3339 case 'K': 3340 Info.setRequiresImmediate(-128, 127); 3341 return true; 3342 case 'L': 3343 // FIXME: properly analyze this constraint: 3344 // must be one of 0xff, 0xffff, or 0xffffffff 3345 return true; 3346 case 'M': 3347 Info.setRequiresImmediate(0, 3); 3348 return true; 3349 case 'N': 3350 Info.setRequiresImmediate(0, 255); 3351 return true; 3352 case 'O': 3353 Info.setRequiresImmediate(0, 127); 3354 return true; 3355 case 'Y': // first letter of a pair: 3356 switch (*(Name+1)) { 3357 default: return false; 3358 case '0': // First SSE register. 3359 case 't': // Any SSE register, when SSE2 is enabled. 3360 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled. 3361 case 'm': // any MMX register, when inter-unit moves enabled. 3362 break; // falls through to setAllowsRegister. 3363 } 3364 case 'f': // any x87 floating point stack register. 3365 // Constraint 'f' cannot be used for output operands. 3366 if (Info.ConstraintStr[0] == '=') 3367 return false; 3368 3369 Info.setAllowsRegister(); 3370 return true; 3371 case 'a': // eax. 3372 case 'b': // ebx. 3373 case 'c': // ecx. 3374 case 'd': // edx. 3375 case 'S': // esi. 3376 case 'D': // edi. 3377 case 'A': // edx:eax. 3378 case 't': // top of floating point stack. 3379 case 'u': // second from top of floating point stack. 3380 case 'q': // Any register accessible as [r]l: a, b, c, and d. 3381 case 'y': // Any MMX register. 3382 case 'x': // Any SSE register. 3383 case 'Q': // Any register accessible as [r]h: a, b, c, and d. 3384 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp. 3385 case 'l': // "Index" registers: any general register that can be used as an 3386 // index in a base+index memory access. 3387 Info.setAllowsRegister(); 3388 return true; 3389 case 'C': // SSE floating point constant. 3390 case 'G': // x87 floating point constant. 3391 case 'e': // 32-bit signed integer constant for use with zero-extending 3392 // x86_64 instructions. 3393 case 'Z': // 32-bit unsigned integer constant for use with zero-extending 3394 // x86_64 instructions. 3395 return true; 3396 } 3397 } 3398 3399 bool X86TargetInfo::validateOutputSize(StringRef Constraint, 3400 unsigned Size) const { 3401 // Strip off constraint modifiers. 3402 while (Constraint[0] == '=' || 3403 Constraint[0] == '+' || 3404 Constraint[0] == '&') 3405 Constraint = Constraint.substr(1); 3406 3407 return validateOperandSize(Constraint, Size); 3408 } 3409 3410 bool X86TargetInfo::validateInputSize(StringRef Constraint, 3411 unsigned Size) const { 3412 return validateOperandSize(Constraint, Size); 3413 } 3414 3415 bool X86TargetInfo::validateOperandSize(StringRef Constraint, 3416 unsigned Size) const { 3417 switch (Constraint[0]) { 3418 default: break; 3419 case 'y': 3420 return Size <= 64; 3421 case 'f': 3422 case 't': 3423 case 'u': 3424 return Size <= 128; 3425 case 'x': 3426 // 256-bit ymm registers can be used if target supports AVX. 3427 return Size <= (SSELevel >= AVX ? 256U : 128U); 3428 } 3429 3430 return true; 3431 } 3432 3433 std::string 3434 X86TargetInfo::convertConstraint(const char *&Constraint) const { 3435 switch (*Constraint) { 3436 case 'a': return std::string("{ax}"); 3437 case 'b': return std::string("{bx}"); 3438 case 'c': return std::string("{cx}"); 3439 case 'd': return std::string("{dx}"); 3440 case 'S': return std::string("{si}"); 3441 case 'D': return std::string("{di}"); 3442 case 'p': // address 3443 return std::string("im"); 3444 case 't': // top of floating point stack. 3445 return std::string("{st}"); 3446 case 'u': // second from top of floating point stack. 3447 return std::string("{st(1)}"); // second from top of floating point stack. 3448 default: 3449 return std::string(1, *Constraint); 3450 } 3451 } 3452 3453 // X86-32 generic target 3454 class X86_32TargetInfo : public X86TargetInfo { 3455 public: 3456 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) { 3457 DoubleAlign = LongLongAlign = 32; 3458 LongDoubleWidth = 96; 3459 LongDoubleAlign = 32; 3460 SuitableAlign = 128; 3461 DescriptionString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"; 3462 SizeType = UnsignedInt; 3463 PtrDiffType = SignedInt; 3464 IntPtrType = SignedInt; 3465 RegParmMax = 3; 3466 3467 // Use fpret for all types. 3468 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) | 3469 (1 << TargetInfo::Double) | 3470 (1 << TargetInfo::LongDouble)); 3471 3472 // x86-32 has atomics up to 8 bytes 3473 // FIXME: Check that we actually have cmpxchg8b before setting 3474 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.) 3475 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 3476 } 3477 BuiltinVaListKind getBuiltinVaListKind() const override { 3478 return TargetInfo::CharPtrBuiltinVaList; 3479 } 3480 3481 int getEHDataRegisterNumber(unsigned RegNo) const override { 3482 if (RegNo == 0) return 0; 3483 if (RegNo == 1) return 2; 3484 return -1; 3485 } 3486 bool validateOperandSize(StringRef Constraint, 3487 unsigned Size) const override { 3488 switch (Constraint[0]) { 3489 default: break; 3490 case 'R': 3491 case 'q': 3492 case 'Q': 3493 case 'a': 3494 case 'b': 3495 case 'c': 3496 case 'd': 3497 case 'S': 3498 case 'D': 3499 return Size <= 32; 3500 case 'A': 3501 return Size <= 64; 3502 } 3503 3504 return X86TargetInfo::validateOperandSize(Constraint, Size); 3505 } 3506 }; 3507 3508 class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> { 3509 public: 3510 NetBSDI386TargetInfo(const llvm::Triple &Triple) 3511 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {} 3512 3513 unsigned getFloatEvalMethod() const override { 3514 unsigned Major, Minor, Micro; 3515 getTriple().getOSVersion(Major, Minor, Micro); 3516 // New NetBSD uses the default rounding mode. 3517 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0) 3518 return X86_32TargetInfo::getFloatEvalMethod(); 3519 // NetBSD before 6.99.26 defaults to "double" rounding. 3520 return 1; 3521 } 3522 }; 3523 3524 class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> { 3525 public: 3526 OpenBSDI386TargetInfo(const llvm::Triple &Triple) 3527 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) { 3528 SizeType = UnsignedLong; 3529 IntPtrType = SignedLong; 3530 PtrDiffType = SignedLong; 3531 } 3532 }; 3533 3534 class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> { 3535 public: 3536 BitrigI386TargetInfo(const llvm::Triple &Triple) 3537 : BitrigTargetInfo<X86_32TargetInfo>(Triple) { 3538 SizeType = UnsignedLong; 3539 IntPtrType = SignedLong; 3540 PtrDiffType = SignedLong; 3541 } 3542 }; 3543 3544 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> { 3545 public: 3546 DarwinI386TargetInfo(const llvm::Triple &Triple) 3547 : DarwinTargetInfo<X86_32TargetInfo>(Triple) { 3548 LongDoubleWidth = 128; 3549 LongDoubleAlign = 128; 3550 SuitableAlign = 128; 3551 MaxVectorAlign = 256; 3552 SizeType = UnsignedLong; 3553 IntPtrType = SignedLong; 3554 DescriptionString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"; 3555 HasAlignMac68kSupport = true; 3556 } 3557 3558 }; 3559 3560 // x86-32 Windows target 3561 class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> { 3562 public: 3563 WindowsX86_32TargetInfo(const llvm::Triple &Triple) 3564 : WindowsTargetInfo<X86_32TargetInfo>(Triple) { 3565 WCharType = UnsignedShort; 3566 DoubleAlign = LongLongAlign = 64; 3567 bool IsWinCOFF = 3568 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF(); 3569 DescriptionString = IsWinCOFF 3570 ? "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" 3571 : "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"; 3572 } 3573 void getTargetDefines(const LangOptions &Opts, 3574 MacroBuilder &Builder) const override { 3575 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder); 3576 } 3577 }; 3578 3579 // x86-32 Windows Visual Studio target 3580 class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo { 3581 public: 3582 MicrosoftX86_32TargetInfo(const llvm::Triple &Triple) 3583 : WindowsX86_32TargetInfo(Triple) { 3584 LongDoubleWidth = LongDoubleAlign = 64; 3585 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 3586 } 3587 void getTargetDefines(const LangOptions &Opts, 3588 MacroBuilder &Builder) const override { 3589 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder); 3590 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder); 3591 // The value of the following reflects processor type. 3592 // 300=386, 400=486, 500=Pentium, 600=Blend (default) 3593 // We lost the original triple, so we use the default. 3594 Builder.defineMacro("_M_IX86", "600"); 3595 } 3596 }; 3597 } // end anonymous namespace 3598 3599 static void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) { 3600 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang supports 3601 // __declspec natively under -fms-extensions, but we define a no-op __declspec 3602 // macro anyway for pre-processor compatibility. 3603 if (Opts.MicrosoftExt) 3604 Builder.defineMacro("__declspec", "__declspec"); 3605 else 3606 Builder.defineMacro("__declspec(a)", "__attribute__((a))"); 3607 3608 if (!Opts.MicrosoftExt) { 3609 // Provide macros for all the calling convention keywords. Provide both 3610 // single and double underscore prefixed variants. These are available on 3611 // x64 as well as x86, even though they have no effect. 3612 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"}; 3613 for (const char *CC : CCs) { 3614 std::string GCCSpelling = "__attribute__((__"; 3615 GCCSpelling += CC; 3616 GCCSpelling += "__))"; 3617 Builder.defineMacro(Twine("_") + CC, GCCSpelling); 3618 Builder.defineMacro(Twine("__") + CC, GCCSpelling); 3619 } 3620 } 3621 } 3622 3623 static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) { 3624 Builder.defineMacro("__MSVCRT__"); 3625 Builder.defineMacro("__MINGW32__"); 3626 addCygMingDefines(Opts, Builder); 3627 } 3628 3629 namespace { 3630 // x86-32 MinGW target 3631 class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo { 3632 public: 3633 MinGWX86_32TargetInfo(const llvm::Triple &Triple) 3634 : WindowsX86_32TargetInfo(Triple) {} 3635 void getTargetDefines(const LangOptions &Opts, 3636 MacroBuilder &Builder) const override { 3637 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder); 3638 DefineStd(Builder, "WIN32", Opts); 3639 DefineStd(Builder, "WINNT", Opts); 3640 Builder.defineMacro("_X86_"); 3641 addMinGWDefines(Opts, Builder); 3642 } 3643 }; 3644 3645 // x86-32 Cygwin target 3646 class CygwinX86_32TargetInfo : public X86_32TargetInfo { 3647 public: 3648 CygwinX86_32TargetInfo(const llvm::Triple &Triple) 3649 : X86_32TargetInfo(Triple) { 3650 TLSSupported = false; 3651 WCharType = UnsignedShort; 3652 DoubleAlign = LongLongAlign = 64; 3653 DescriptionString = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"; 3654 } 3655 void getTargetDefines(const LangOptions &Opts, 3656 MacroBuilder &Builder) const override { 3657 X86_32TargetInfo::getTargetDefines(Opts, Builder); 3658 Builder.defineMacro("_X86_"); 3659 Builder.defineMacro("__CYGWIN__"); 3660 Builder.defineMacro("__CYGWIN32__"); 3661 addCygMingDefines(Opts, Builder); 3662 DefineStd(Builder, "unix", Opts); 3663 if (Opts.CPlusPlus) 3664 Builder.defineMacro("_GNU_SOURCE"); 3665 } 3666 }; 3667 3668 // x86-32 Haiku target 3669 class HaikuX86_32TargetInfo : public X86_32TargetInfo { 3670 public: 3671 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) { 3672 SizeType = UnsignedLong; 3673 IntPtrType = SignedLong; 3674 PtrDiffType = SignedLong; 3675 ProcessIDType = SignedLong; 3676 this->UserLabelPrefix = ""; 3677 this->TLSSupported = false; 3678 } 3679 void getTargetDefines(const LangOptions &Opts, 3680 MacroBuilder &Builder) const override { 3681 X86_32TargetInfo::getTargetDefines(Opts, Builder); 3682 Builder.defineMacro("__INTEL__"); 3683 Builder.defineMacro("__HAIKU__"); 3684 } 3685 }; 3686 3687 // RTEMS Target 3688 template<typename Target> 3689 class RTEMSTargetInfo : public OSTargetInfo<Target> { 3690 protected: 3691 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 3692 MacroBuilder &Builder) const override { 3693 // RTEMS defines; list based off of gcc output 3694 3695 Builder.defineMacro("__rtems__"); 3696 Builder.defineMacro("__ELF__"); 3697 } 3698 3699 public: 3700 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) { 3701 this->UserLabelPrefix = ""; 3702 3703 switch (Triple.getArch()) { 3704 default: 3705 case llvm::Triple::x86: 3706 // this->MCountName = ".mcount"; 3707 break; 3708 case llvm::Triple::mips: 3709 case llvm::Triple::mipsel: 3710 case llvm::Triple::ppc: 3711 case llvm::Triple::ppc64: 3712 case llvm::Triple::ppc64le: 3713 // this->MCountName = "_mcount"; 3714 break; 3715 case llvm::Triple::arm: 3716 // this->MCountName = "__mcount"; 3717 break; 3718 } 3719 } 3720 }; 3721 3722 // x86-32 RTEMS target 3723 class RTEMSX86_32TargetInfo : public X86_32TargetInfo { 3724 public: 3725 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) { 3726 SizeType = UnsignedLong; 3727 IntPtrType = SignedLong; 3728 PtrDiffType = SignedLong; 3729 this->UserLabelPrefix = ""; 3730 } 3731 void getTargetDefines(const LangOptions &Opts, 3732 MacroBuilder &Builder) const override { 3733 X86_32TargetInfo::getTargetDefines(Opts, Builder); 3734 Builder.defineMacro("__INTEL__"); 3735 Builder.defineMacro("__rtems__"); 3736 } 3737 }; 3738 3739 // x86-64 generic target 3740 class X86_64TargetInfo : public X86TargetInfo { 3741 public: 3742 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) { 3743 const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32; 3744 bool IsWinCOFF = 3745 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF(); 3746 LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64; 3747 LongDoubleWidth = 128; 3748 LongDoubleAlign = 128; 3749 LargeArrayMinWidth = 128; 3750 LargeArrayAlign = 128; 3751 SuitableAlign = 128; 3752 SizeType = IsX32 ? UnsignedInt : UnsignedLong; 3753 PtrDiffType = IsX32 ? SignedInt : SignedLong; 3754 IntPtrType = IsX32 ? SignedInt : SignedLong; 3755 IntMaxType = IsX32 ? SignedLongLong : SignedLong; 3756 Int64Type = IsX32 ? SignedLongLong : SignedLong; 3757 RegParmMax = 6; 3758 3759 // Pointers are 32-bit in x32. 3760 DescriptionString = IsX32 ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128" 3761 : IsWinCOFF 3762 ? "e-m:w-i64:64-f80:128-n8:16:32:64-S128" 3763 : "e-m:e-i64:64-f80:128-n8:16:32:64-S128"; 3764 3765 // Use fpret only for long double. 3766 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble); 3767 3768 // Use fp2ret for _Complex long double. 3769 ComplexLongDoubleUsesFP2Ret = true; 3770 3771 // x86-64 has atomics up to 16 bytes. 3772 MaxAtomicPromoteWidth = 128; 3773 MaxAtomicInlineWidth = 128; 3774 } 3775 BuiltinVaListKind getBuiltinVaListKind() const override { 3776 return TargetInfo::X86_64ABIBuiltinVaList; 3777 } 3778 3779 int getEHDataRegisterNumber(unsigned RegNo) const override { 3780 if (RegNo == 0) return 0; 3781 if (RegNo == 1) return 1; 3782 return -1; 3783 } 3784 3785 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override { 3786 return (CC == CC_C || 3787 CC == CC_X86VectorCall || 3788 CC == CC_IntelOclBicc || 3789 CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning; 3790 } 3791 3792 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override { 3793 return CC_C; 3794 } 3795 3796 // for x32 we need it here explicitly 3797 bool hasInt128Type() const override { return true; } 3798 }; 3799 3800 // x86-64 Windows target 3801 class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> { 3802 public: 3803 WindowsX86_64TargetInfo(const llvm::Triple &Triple) 3804 : WindowsTargetInfo<X86_64TargetInfo>(Triple) { 3805 WCharType = UnsignedShort; 3806 LongWidth = LongAlign = 32; 3807 DoubleAlign = LongLongAlign = 64; 3808 IntMaxType = SignedLongLong; 3809 Int64Type = SignedLongLong; 3810 SizeType = UnsignedLongLong; 3811 PtrDiffType = SignedLongLong; 3812 IntPtrType = SignedLongLong; 3813 this->UserLabelPrefix = ""; 3814 } 3815 3816 void getTargetDefines(const LangOptions &Opts, 3817 MacroBuilder &Builder) const override { 3818 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder); 3819 Builder.defineMacro("_WIN64"); 3820 } 3821 3822 BuiltinVaListKind getBuiltinVaListKind() const override { 3823 return TargetInfo::CharPtrBuiltinVaList; 3824 } 3825 3826 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override { 3827 switch (CC) { 3828 case CC_X86StdCall: 3829 case CC_X86ThisCall: 3830 case CC_X86FastCall: 3831 return CCCR_Ignore; 3832 case CC_C: 3833 case CC_X86VectorCall: 3834 case CC_IntelOclBicc: 3835 case CC_X86_64SysV: 3836 return CCCR_OK; 3837 default: 3838 return CCCR_Warning; 3839 } 3840 } 3841 }; 3842 3843 // x86-64 Windows Visual Studio target 3844 class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo { 3845 public: 3846 MicrosoftX86_64TargetInfo(const llvm::Triple &Triple) 3847 : WindowsX86_64TargetInfo(Triple) { 3848 LongDoubleWidth = LongDoubleAlign = 64; 3849 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 3850 } 3851 void getTargetDefines(const LangOptions &Opts, 3852 MacroBuilder &Builder) const override { 3853 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder); 3854 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder); 3855 Builder.defineMacro("_M_X64"); 3856 Builder.defineMacro("_M_AMD64"); 3857 } 3858 }; 3859 3860 // x86-64 MinGW target 3861 class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo { 3862 public: 3863 MinGWX86_64TargetInfo(const llvm::Triple &Triple) 3864 : WindowsX86_64TargetInfo(Triple) {} 3865 void getTargetDefines(const LangOptions &Opts, 3866 MacroBuilder &Builder) const override { 3867 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder); 3868 DefineStd(Builder, "WIN64", Opts); 3869 Builder.defineMacro("__MINGW64__"); 3870 addMinGWDefines(Opts, Builder); 3871 3872 // GCC defines this macro when it is using __gxx_personality_seh0. 3873 if (!Opts.SjLjExceptions) 3874 Builder.defineMacro("__SEH__"); 3875 } 3876 }; 3877 3878 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> { 3879 public: 3880 DarwinX86_64TargetInfo(const llvm::Triple &Triple) 3881 : DarwinTargetInfo<X86_64TargetInfo>(Triple) { 3882 Int64Type = SignedLongLong; 3883 MaxVectorAlign = 256; 3884 // The 64-bit iOS simulator uses the builtin bool type for Objective-C. 3885 llvm::Triple T = llvm::Triple(Triple); 3886 if (T.isiOS()) 3887 UseSignedCharForObjCBool = false; 3888 DescriptionString = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"; 3889 } 3890 }; 3891 3892 class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> { 3893 public: 3894 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple) 3895 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) { 3896 IntMaxType = SignedLongLong; 3897 Int64Type = SignedLongLong; 3898 } 3899 }; 3900 3901 class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> { 3902 public: 3903 BitrigX86_64TargetInfo(const llvm::Triple &Triple) 3904 : BitrigTargetInfo<X86_64TargetInfo>(Triple) { 3905 IntMaxType = SignedLongLong; 3906 Int64Type = SignedLongLong; 3907 } 3908 }; 3909 3910 class ARMTargetInfo : public TargetInfo { 3911 // Possible FPU choices. 3912 enum FPUMode { 3913 VFP2FPU = (1 << 0), 3914 VFP3FPU = (1 << 1), 3915 VFP4FPU = (1 << 2), 3916 NeonFPU = (1 << 3), 3917 FPARMV8 = (1 << 4) 3918 }; 3919 3920 // Possible HWDiv features. 3921 enum HWDivMode { 3922 HWDivThumb = (1 << 0), 3923 HWDivARM = (1 << 1) 3924 }; 3925 3926 static bool FPUModeIsVFP(FPUMode Mode) { 3927 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8); 3928 } 3929 3930 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 3931 static const char * const GCCRegNames[]; 3932 3933 std::string ABI, CPU; 3934 3935 enum { 3936 FP_Default, 3937 FP_VFP, 3938 FP_Neon 3939 } FPMath; 3940 3941 unsigned FPU : 5; 3942 3943 unsigned IsAAPCS : 1; 3944 unsigned IsThumb : 1; 3945 unsigned HWDiv : 2; 3946 3947 // Initialized via features. 3948 unsigned SoftFloat : 1; 3949 unsigned SoftFloatABI : 1; 3950 3951 unsigned CRC : 1; 3952 unsigned Crypto : 1; 3953 3954 // ACLE 6.5.1 Hardware floating point 3955 enum { 3956 HW_FP_HP = (1 << 1), /// half (16-bit) 3957 HW_FP_SP = (1 << 2), /// single (32-bit) 3958 HW_FP_DP = (1 << 3), /// double (64-bit) 3959 }; 3960 uint32_t HW_FP; 3961 3962 static const Builtin::Info BuiltinInfo[]; 3963 3964 static bool shouldUseInlineAtomic(const llvm::Triple &T) { 3965 StringRef ArchName = T.getArchName(); 3966 if (T.getArch() == llvm::Triple::arm || 3967 T.getArch() == llvm::Triple::armeb) { 3968 StringRef VersionStr; 3969 if (ArchName.startswith("armv")) 3970 VersionStr = ArchName.substr(4, 1); 3971 else if (ArchName.startswith("armebv")) 3972 VersionStr = ArchName.substr(6, 1); 3973 else 3974 return false; 3975 unsigned Version; 3976 if (VersionStr.getAsInteger(10, Version)) 3977 return false; 3978 return Version >= 6; 3979 } 3980 assert(T.getArch() == llvm::Triple::thumb || 3981 T.getArch() == llvm::Triple::thumbeb); 3982 StringRef VersionStr; 3983 if (ArchName.startswith("thumbv")) 3984 VersionStr = ArchName.substr(6, 1); 3985 else if (ArchName.startswith("thumbebv")) 3986 VersionStr = ArchName.substr(8, 1); 3987 else 3988 return false; 3989 unsigned Version; 3990 if (VersionStr.getAsInteger(10, Version)) 3991 return false; 3992 return Version >= 7; 3993 } 3994 3995 void setABIAAPCS() { 3996 IsAAPCS = true; 3997 3998 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64; 3999 const llvm::Triple &T = getTriple(); 4000 4001 // size_t is unsigned long on MachO-derived environments, NetBSD and Bitrig. 4002 if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD || 4003 T.getOS() == llvm::Triple::Bitrig) 4004 SizeType = UnsignedLong; 4005 else 4006 SizeType = UnsignedInt; 4007 4008 switch (T.getOS()) { 4009 case llvm::Triple::NetBSD: 4010 WCharType = SignedInt; 4011 break; 4012 case llvm::Triple::Win32: 4013 WCharType = UnsignedShort; 4014 break; 4015 case llvm::Triple::Linux: 4016 default: 4017 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int. 4018 WCharType = UnsignedInt; 4019 break; 4020 } 4021 4022 UseBitFieldTypeAlignment = true; 4023 4024 ZeroLengthBitfieldBoundary = 0; 4025 4026 // Thumb1 add sp, #imm requires the immediate value be multiple of 4, 4027 // so set preferred for small types to 32. 4028 if (T.isOSBinFormatMachO()) { 4029 DescriptionString = 4030 BigEndian ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" 4031 : "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"; 4032 } else if (T.isOSWindows()) { 4033 assert(!BigEndian && "Windows on ARM does not support big endian"); 4034 DescriptionString = "e" 4035 "-m:w" 4036 "-p:32:32" 4037 "-i64:64" 4038 "-v128:64:128" 4039 "-a:0:32" 4040 "-n32" 4041 "-S64"; 4042 } else if (T.isOSNaCl()) { 4043 assert(!BigEndian && "NaCl on ARM does not support big endian"); 4044 DescriptionString = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128"; 4045 } else { 4046 DescriptionString = 4047 BigEndian ? "E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" 4048 : "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"; 4049 } 4050 4051 // FIXME: Enumerated types are variable width in straight AAPCS. 4052 } 4053 4054 void setABIAPCS() { 4055 const llvm::Triple &T = getTriple(); 4056 4057 IsAAPCS = false; 4058 4059 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32; 4060 4061 // size_t is unsigned int on FreeBSD. 4062 if (T.getOS() == llvm::Triple::FreeBSD) 4063 SizeType = UnsignedInt; 4064 else 4065 SizeType = UnsignedLong; 4066 4067 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour. 4068 WCharType = SignedInt; 4069 4070 // Do not respect the alignment of bit-field types when laying out 4071 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc. 4072 UseBitFieldTypeAlignment = false; 4073 4074 /// gcc forces the alignment to 4 bytes, regardless of the type of the 4075 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in 4076 /// gcc. 4077 ZeroLengthBitfieldBoundary = 32; 4078 4079 if (T.isOSBinFormatMachO()) 4080 DescriptionString = 4081 BigEndian 4082 ? "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" 4083 : "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"; 4084 else 4085 DescriptionString = 4086 BigEndian 4087 ? "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" 4088 : "e-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"; 4089 4090 // FIXME: Override "preferred align" for double and long long. 4091 } 4092 4093 public: 4094 ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian) 4095 : TargetInfo(Triple), CPU("arm1136j-s"), FPMath(FP_Default), 4096 IsAAPCS(true), HW_FP(0) { 4097 BigEndian = IsBigEndian; 4098 4099 switch (getTriple().getOS()) { 4100 case llvm::Triple::NetBSD: 4101 PtrDiffType = SignedLong; 4102 break; 4103 default: 4104 PtrDiffType = SignedInt; 4105 break; 4106 } 4107 4108 // {} in inline assembly are neon specifiers, not assembly variant 4109 // specifiers. 4110 NoAsmVariants = true; 4111 4112 // FIXME: Should we just treat this as a feature? 4113 IsThumb = getTriple().getArchName().startswith("thumb"); 4114 4115 // FIXME: This duplicates code from the driver that sets the -target-abi 4116 // option - this code is used if -target-abi isn't passed and should 4117 // be unified in some way. 4118 if (Triple.isOSBinFormatMachO()) { 4119 // The backend is hardwired to assume AAPCS for M-class processors, ensure 4120 // the frontend matches that. 4121 if (Triple.getEnvironment() == llvm::Triple::EABI || 4122 Triple.getOS() == llvm::Triple::UnknownOS || 4123 StringRef(CPU).startswith("cortex-m")) { 4124 setABI("aapcs"); 4125 } else { 4126 setABI("apcs-gnu"); 4127 } 4128 } else if (Triple.isOSWindows()) { 4129 // FIXME: this is invalid for WindowsCE 4130 setABI("aapcs"); 4131 } else { 4132 // Select the default based on the platform. 4133 switch (Triple.getEnvironment()) { 4134 case llvm::Triple::Android: 4135 case llvm::Triple::GNUEABI: 4136 case llvm::Triple::GNUEABIHF: 4137 setABI("aapcs-linux"); 4138 break; 4139 case llvm::Triple::EABIHF: 4140 case llvm::Triple::EABI: 4141 setABI("aapcs"); 4142 break; 4143 case llvm::Triple::GNU: 4144 setABI("apcs-gnu"); 4145 break; 4146 default: 4147 if (Triple.getOS() == llvm::Triple::NetBSD) 4148 setABI("apcs-gnu"); 4149 else 4150 setABI("aapcs"); 4151 break; 4152 } 4153 } 4154 4155 // ARM targets default to using the ARM C++ ABI. 4156 TheCXXABI.set(TargetCXXABI::GenericARM); 4157 4158 // ARM has atomics up to 8 bytes 4159 MaxAtomicPromoteWidth = 64; 4160 if (shouldUseInlineAtomic(getTriple())) 4161 MaxAtomicInlineWidth = 64; 4162 4163 // Do force alignment of members that follow zero length bitfields. If 4164 // the alignment of the zero-length bitfield is greater than the member 4165 // that follows it, `bar', `bar' will be aligned as the type of the 4166 // zero length bitfield. 4167 UseZeroLengthBitfieldAlignment = true; 4168 } 4169 StringRef getABI() const override { return ABI; } 4170 bool setABI(const std::string &Name) override { 4171 ABI = Name; 4172 4173 // The defaults (above) are for AAPCS, check if we need to change them. 4174 // 4175 // FIXME: We need support for -meabi... we could just mangle it into the 4176 // name. 4177 if (Name == "apcs-gnu") { 4178 setABIAPCS(); 4179 return true; 4180 } 4181 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") { 4182 setABIAAPCS(); 4183 return true; 4184 } 4185 return false; 4186 } 4187 4188 // FIXME: This should be based on Arch attributes, not CPU names. 4189 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override { 4190 StringRef ArchName = getTriple().getArchName(); 4191 unsigned ArchKind = 4192 llvm::ARMTargetParser::parseArch( 4193 llvm::ARMTargetParser::getCanonicalArchName(ArchName)); 4194 bool IsV8 = (ArchKind == llvm::ARM::AK_ARMV8A || 4195 ArchKind == llvm::ARM::AK_ARMV8_1A); 4196 4197 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore") 4198 Features["vfp2"] = true; 4199 else if (CPU == "cortex-a8" || CPU == "cortex-a9") { 4200 Features["vfp3"] = true; 4201 Features["neon"] = true; 4202 } 4203 else if (CPU == "cortex-a5") { 4204 Features["vfp4"] = true; 4205 Features["neon"] = true; 4206 } else if (CPU == "swift" || CPU == "cortex-a7" || 4207 CPU == "cortex-a12" || CPU == "cortex-a15" || 4208 CPU == "cortex-a17" || CPU == "krait") { 4209 Features["vfp4"] = true; 4210 Features["neon"] = true; 4211 Features["hwdiv"] = true; 4212 Features["hwdiv-arm"] = true; 4213 } else if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" || 4214 CPU == "cortex-a72") { 4215 Features["fp-armv8"] = true; 4216 Features["neon"] = true; 4217 Features["hwdiv"] = true; 4218 Features["hwdiv-arm"] = true; 4219 Features["crc"] = true; 4220 Features["crypto"] = true; 4221 } else if (CPU == "cortex-r5" || CPU == "cortex-r7" || IsV8) { 4222 Features["hwdiv"] = true; 4223 Features["hwdiv-arm"] = true; 4224 } else if (CPU == "cortex-m3" || CPU == "cortex-m4" || CPU == "cortex-m7" || 4225 CPU == "sc300" || CPU == "cortex-r4" || CPU == "cortex-r4f") { 4226 Features["hwdiv"] = true; 4227 } 4228 } 4229 4230 bool handleTargetFeatures(std::vector<std::string> &Features, 4231 DiagnosticsEngine &Diags) override { 4232 FPU = 0; 4233 CRC = 0; 4234 Crypto = 0; 4235 SoftFloat = SoftFloatABI = false; 4236 HWDiv = 0; 4237 4238 for (const auto &Feature : Features) { 4239 if (Feature == "+soft-float") { 4240 SoftFloat = true; 4241 } else if (Feature == "+soft-float-abi") { 4242 SoftFloatABI = true; 4243 } else if (Feature == "+vfp2") { 4244 FPU |= VFP2FPU; 4245 HW_FP = HW_FP_SP | HW_FP_DP; 4246 } else if (Feature == "+vfp3") { 4247 FPU |= VFP3FPU; 4248 HW_FP = HW_FP_SP | HW_FP_DP; 4249 } else if (Feature == "+vfp4") { 4250 FPU |= VFP4FPU; 4251 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP; 4252 } else if (Feature == "+fp-armv8") { 4253 FPU |= FPARMV8; 4254 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP; 4255 } else if (Feature == "+neon") { 4256 FPU |= NeonFPU; 4257 HW_FP = HW_FP_SP | HW_FP_DP; 4258 } else if (Feature == "+hwdiv") { 4259 HWDiv |= HWDivThumb; 4260 } else if (Feature == "+hwdiv-arm") { 4261 HWDiv |= HWDivARM; 4262 } else if (Feature == "+crc") { 4263 CRC = 1; 4264 } else if (Feature == "+crypto") { 4265 Crypto = 1; 4266 } else if (Feature == "+fp-only-sp") { 4267 HW_FP &= ~HW_FP_DP; 4268 } 4269 } 4270 4271 if (!(FPU & NeonFPU) && FPMath == FP_Neon) { 4272 Diags.Report(diag::err_target_unsupported_fpmath) << "neon"; 4273 return false; 4274 } 4275 4276 if (FPMath == FP_Neon) 4277 Features.push_back("+neonfp"); 4278 else if (FPMath == FP_VFP) 4279 Features.push_back("-neonfp"); 4280 4281 // Remove front-end specific options which the backend handles differently. 4282 auto Feature = 4283 std::find(Features.begin(), Features.end(), "+soft-float-abi"); 4284 if (Feature != Features.end()) 4285 Features.erase(Feature); 4286 4287 return true; 4288 } 4289 4290 bool hasFeature(StringRef Feature) const override { 4291 return llvm::StringSwitch<bool>(Feature) 4292 .Case("arm", true) 4293 .Case("softfloat", SoftFloat) 4294 .Case("thumb", IsThumb) 4295 .Case("neon", (FPU & NeonFPU) && !SoftFloat) 4296 .Case("hwdiv", HWDiv & HWDivThumb) 4297 .Case("hwdiv-arm", HWDiv & HWDivARM) 4298 .Default(false); 4299 } 4300 const char *getCPUDefineSuffix(StringRef Name) const { 4301 if(Name == "generic") { 4302 auto subarch = getTriple().getSubArch(); 4303 switch (subarch) { 4304 case llvm::Triple::SubArchType::ARMSubArch_v8_1a: 4305 return "8_1A"; 4306 default: 4307 break; 4308 } 4309 } 4310 4311 unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(Name); 4312 if (ArchKind == llvm::ARM::AK_INVALID) 4313 return ""; 4314 4315 // For most sub-arches, the build attribute CPU name is enough. 4316 // For Cortex variants, it's slightly different. 4317 switch(ArchKind) { 4318 default: 4319 return llvm::ARMTargetParser::getCPUAttr(ArchKind); 4320 case llvm::ARM::AK_ARMV6M: 4321 case llvm::ARM::AK_ARMV6SM: 4322 return "6M"; 4323 case llvm::ARM::AK_ARMV7: 4324 case llvm::ARM::AK_ARMV7A: 4325 return "7A"; 4326 case llvm::ARM::AK_ARMV7R: 4327 return "7R"; 4328 case llvm::ARM::AK_ARMV7M: 4329 return "7M"; 4330 case llvm::ARM::AK_ARMV7EM: 4331 return "7EM"; 4332 case llvm::ARM::AK_ARMV8A: 4333 return "8A"; 4334 case llvm::ARM::AK_ARMV8_1A: 4335 return "8_1A"; 4336 } 4337 } 4338 const char *getCPUProfile(StringRef Name) const { 4339 if(Name == "generic") { 4340 auto subarch = getTriple().getSubArch(); 4341 switch (subarch) { 4342 case llvm::Triple::SubArchType::ARMSubArch_v8_1a: 4343 return "A"; 4344 default: 4345 break; 4346 } 4347 } 4348 4349 unsigned CPUArch = llvm::ARMTargetParser::parseCPUArch(Name); 4350 if (CPUArch == llvm::ARM::AK_INVALID) 4351 return ""; 4352 4353 StringRef ArchName = llvm::ARMTargetParser::getArchName(CPUArch); 4354 switch(llvm::ARMTargetParser::parseArchProfile(ArchName)) { 4355 case llvm::ARM::PK_A: 4356 return "A"; 4357 case llvm::ARM::PK_R: 4358 return "R"; 4359 case llvm::ARM::PK_M: 4360 return "M"; 4361 default: 4362 return ""; 4363 } 4364 } 4365 bool setCPU(const std::string &Name) override { 4366 if (!getCPUDefineSuffix(Name)) 4367 return false; 4368 4369 // Cortex M does not support 8 byte atomics, while general Thumb2 does. 4370 StringRef Profile = getCPUProfile(Name); 4371 if (Profile == "M" && MaxAtomicInlineWidth) { 4372 MaxAtomicPromoteWidth = 32; 4373 MaxAtomicInlineWidth = 32; 4374 } 4375 4376 CPU = Name; 4377 return true; 4378 } 4379 bool setFPMath(StringRef Name) override; 4380 bool supportsThumb(StringRef ArchName, StringRef CPUArch, 4381 unsigned CPUArchVer) const { 4382 return CPUArchVer >= 7 || (CPUArch.find('T') != StringRef::npos) || 4383 (CPUArch.find('M') != StringRef::npos); 4384 } 4385 bool supportsThumb2(StringRef ArchName, StringRef CPUArch, 4386 unsigned CPUArchVer) const { 4387 // We check both CPUArchVer and ArchName because when only triple is 4388 // specified, the default CPU is arm1136j-s. 4389 return ArchName.endswith("v6t2") || ArchName.endswith("v7") || 4390 ArchName.endswith("v8.1a") || 4391 ArchName.endswith("v8") || CPUArch == "6T2" || CPUArchVer >= 7; 4392 } 4393 void getTargetDefines(const LangOptions &Opts, 4394 MacroBuilder &Builder) const override { 4395 // Target identification. 4396 Builder.defineMacro("__arm"); 4397 Builder.defineMacro("__arm__"); 4398 4399 // Target properties. 4400 Builder.defineMacro("__REGISTER_PREFIX__", ""); 4401 4402 StringRef CPUArch = getCPUDefineSuffix(CPU); 4403 unsigned int CPUArchVer; 4404 if (CPUArch.substr(0, 1).getAsInteger<unsigned int>(10, CPUArchVer)) 4405 llvm_unreachable("Invalid char for architecture version number"); 4406 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__"); 4407 4408 // ACLE 6.4.1 ARM/Thumb instruction set architecture 4409 StringRef CPUProfile = getCPUProfile(CPU); 4410 StringRef ArchName = getTriple().getArchName(); 4411 4412 // __ARM_ARCH is defined as an integer value indicating the current ARM ISA 4413 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1)); 4414 if (CPUArch[0] >= '8') { 4415 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN"); 4416 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING"); 4417 } 4418 4419 // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA. It 4420 // is not defined for the M-profile. 4421 // NOTE that the deffault profile is assumed to be 'A' 4422 if (CPUProfile.empty() || CPUProfile != "M") 4423 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1"); 4424 4425 // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supporst the original 4426 // Thumb ISA (including v6-M). It is set to 2 if the core supports the 4427 // Thumb-2 ISA as found in the v6T2 architecture and all v7 architecture. 4428 if (supportsThumb2(ArchName, CPUArch, CPUArchVer)) 4429 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2"); 4430 else if (supportsThumb(ArchName, CPUArch, CPUArchVer)) 4431 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1"); 4432 4433 // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit 4434 // instruction set such as ARM or Thumb. 4435 Builder.defineMacro("__ARM_32BIT_STATE", "1"); 4436 4437 // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex) 4438 4439 // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset. 4440 if (!CPUProfile.empty()) 4441 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'"); 4442 4443 // ACLE 6.5.1 Hardware Floating Point 4444 if (HW_FP) 4445 Builder.defineMacro("__ARM_FP", "0x" + llvm::utohexstr(HW_FP)); 4446 4447 // ACLE predefines. 4448 Builder.defineMacro("__ARM_ACLE", "200"); 4449 4450 // Subtarget options. 4451 4452 // FIXME: It's more complicated than this and we don't really support 4453 // interworking. 4454 // Windows on ARM does not "support" interworking 4455 if (5 <= CPUArchVer && CPUArchVer <= 8 && !getTriple().isOSWindows()) 4456 Builder.defineMacro("__THUMB_INTERWORK__"); 4457 4458 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") { 4459 // Embedded targets on Darwin follow AAPCS, but not EABI. 4460 // Windows on ARM follows AAPCS VFP, but does not conform to EABI. 4461 if (!getTriple().isOSDarwin() && !getTriple().isOSWindows()) 4462 Builder.defineMacro("__ARM_EABI__"); 4463 Builder.defineMacro("__ARM_PCS", "1"); 4464 4465 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp") 4466 Builder.defineMacro("__ARM_PCS_VFP", "1"); 4467 } 4468 4469 if (SoftFloat) 4470 Builder.defineMacro("__SOFTFP__"); 4471 4472 if (CPU == "xscale") 4473 Builder.defineMacro("__XSCALE__"); 4474 4475 if (IsThumb) { 4476 Builder.defineMacro("__THUMBEL__"); 4477 Builder.defineMacro("__thumb__"); 4478 if (supportsThumb2(ArchName, CPUArch, CPUArchVer)) 4479 Builder.defineMacro("__thumb2__"); 4480 } 4481 if (((HWDiv & HWDivThumb) && IsThumb) || ((HWDiv & HWDivARM) && !IsThumb)) 4482 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1"); 4483 4484 // Note, this is always on in gcc, even though it doesn't make sense. 4485 Builder.defineMacro("__APCS_32__"); 4486 4487 if (FPUModeIsVFP((FPUMode) FPU)) { 4488 Builder.defineMacro("__VFP_FP__"); 4489 if (FPU & VFP2FPU) 4490 Builder.defineMacro("__ARM_VFPV2__"); 4491 if (FPU & VFP3FPU) 4492 Builder.defineMacro("__ARM_VFPV3__"); 4493 if (FPU & VFP4FPU) 4494 Builder.defineMacro("__ARM_VFPV4__"); 4495 } 4496 4497 // This only gets set when Neon instructions are actually available, unlike 4498 // the VFP define, hence the soft float and arch check. This is subtly 4499 // different from gcc, we follow the intent which was that it should be set 4500 // when Neon instructions are actually available. 4501 if ((FPU & NeonFPU) && !SoftFloat && CPUArchVer >= 7) { 4502 Builder.defineMacro("__ARM_NEON"); 4503 Builder.defineMacro("__ARM_NEON__"); 4504 } 4505 4506 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", 4507 Opts.ShortWChar ? "2" : "4"); 4508 4509 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM", 4510 Opts.ShortEnums ? "1" : "4"); 4511 4512 if (CRC) 4513 Builder.defineMacro("__ARM_FEATURE_CRC32"); 4514 4515 if (Crypto) 4516 Builder.defineMacro("__ARM_FEATURE_CRYPTO"); 4517 4518 if (CPUArchVer >= 6 && CPUArch != "6M") { 4519 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); 4520 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); 4521 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); 4522 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); 4523 } 4524 4525 bool is5EOrAbove = (CPUArchVer >= 6 || 4526 (CPUArchVer == 5 && 4527 CPUArch.find('E') != StringRef::npos)); 4528 bool is32Bit = (!IsThumb || supportsThumb2(ArchName, CPUArch, CPUArchVer)); 4529 if (is5EOrAbove && is32Bit && (CPUProfile != "M" || CPUArch == "7EM")) 4530 Builder.defineMacro("__ARM_FEATURE_DSP"); 4531 } 4532 void getTargetBuiltins(const Builtin::Info *&Records, 4533 unsigned &NumRecords) const override { 4534 Records = BuiltinInfo; 4535 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin; 4536 } 4537 bool isCLZForZeroUndef() const override { return false; } 4538 BuiltinVaListKind getBuiltinVaListKind() const override { 4539 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList; 4540 } 4541 void getGCCRegNames(const char * const *&Names, 4542 unsigned &NumNames) const override; 4543 void getGCCRegAliases(const GCCRegAlias *&Aliases, 4544 unsigned &NumAliases) const override; 4545 bool validateAsmConstraint(const char *&Name, 4546 TargetInfo::ConstraintInfo &Info) const override { 4547 switch (*Name) { 4548 default: break; 4549 case 'l': // r0-r7 4550 case 'h': // r8-r15 4551 case 'w': // VFP Floating point register single precision 4552 case 'P': // VFP Floating point register double precision 4553 Info.setAllowsRegister(); 4554 return true; 4555 case 'I': 4556 case 'J': 4557 case 'K': 4558 case 'L': 4559 case 'M': 4560 // FIXME 4561 return true; 4562 case 'Q': // A memory address that is a single base register. 4563 Info.setAllowsMemory(); 4564 return true; 4565 case 'U': // a memory reference... 4566 switch (Name[1]) { 4567 case 'q': // ...ARMV4 ldrsb 4568 case 'v': // ...VFP load/store (reg+constant offset) 4569 case 'y': // ...iWMMXt load/store 4570 case 't': // address valid for load/store opaque types wider 4571 // than 128-bits 4572 case 'n': // valid address for Neon doubleword vector load/store 4573 case 'm': // valid address for Neon element and structure load/store 4574 case 's': // valid address for non-offset loads/stores of quad-word 4575 // values in four ARM registers 4576 Info.setAllowsMemory(); 4577 Name++; 4578 return true; 4579 } 4580 } 4581 return false; 4582 } 4583 std::string convertConstraint(const char *&Constraint) const override { 4584 std::string R; 4585 switch (*Constraint) { 4586 case 'U': // Two-character constraint; add "^" hint for later parsing. 4587 R = std::string("^") + std::string(Constraint, 2); 4588 Constraint++; 4589 break; 4590 case 'p': // 'p' should be translated to 'r' by default. 4591 R = std::string("r"); 4592 break; 4593 default: 4594 return std::string(1, *Constraint); 4595 } 4596 return R; 4597 } 4598 bool 4599 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size, 4600 std::string &SuggestedModifier) const override { 4601 bool isOutput = (Constraint[0] == '='); 4602 bool isInOut = (Constraint[0] == '+'); 4603 4604 // Strip off constraint modifiers. 4605 while (Constraint[0] == '=' || 4606 Constraint[0] == '+' || 4607 Constraint[0] == '&') 4608 Constraint = Constraint.substr(1); 4609 4610 switch (Constraint[0]) { 4611 default: break; 4612 case 'r': { 4613 switch (Modifier) { 4614 default: 4615 return (isInOut || isOutput || Size <= 64); 4616 case 'q': 4617 // A register of size 32 cannot fit a vector type. 4618 return false; 4619 } 4620 } 4621 } 4622 4623 return true; 4624 } 4625 const char *getClobbers() const override { 4626 // FIXME: Is this really right? 4627 return ""; 4628 } 4629 4630 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override { 4631 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning; 4632 } 4633 4634 int getEHDataRegisterNumber(unsigned RegNo) const override { 4635 if (RegNo == 0) return 0; 4636 if (RegNo == 1) return 1; 4637 return -1; 4638 } 4639 }; 4640 4641 bool ARMTargetInfo::setFPMath(StringRef Name) { 4642 if (Name == "neon") { 4643 FPMath = FP_Neon; 4644 return true; 4645 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" || 4646 Name == "vfp4") { 4647 FPMath = FP_VFP; 4648 return true; 4649 } 4650 return false; 4651 } 4652 4653 const char * const ARMTargetInfo::GCCRegNames[] = { 4654 // Integer registers 4655 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 4656 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc", 4657 4658 // Float registers 4659 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", 4660 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15", 4661 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23", 4662 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", 4663 4664 // Double registers 4665 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", 4666 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15", 4667 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23", 4668 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31", 4669 4670 // Quad registers 4671 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", 4672 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 4673 }; 4674 4675 void ARMTargetInfo::getGCCRegNames(const char * const *&Names, 4676 unsigned &NumNames) const { 4677 Names = GCCRegNames; 4678 NumNames = llvm::array_lengthof(GCCRegNames); 4679 } 4680 4681 const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = { 4682 { { "a1" }, "r0" }, 4683 { { "a2" }, "r1" }, 4684 { { "a3" }, "r2" }, 4685 { { "a4" }, "r3" }, 4686 { { "v1" }, "r4" }, 4687 { { "v2" }, "r5" }, 4688 { { "v3" }, "r6" }, 4689 { { "v4" }, "r7" }, 4690 { { "v5" }, "r8" }, 4691 { { "v6", "rfp" }, "r9" }, 4692 { { "sl" }, "r10" }, 4693 { { "fp" }, "r11" }, 4694 { { "ip" }, "r12" }, 4695 { { "r13" }, "sp" }, 4696 { { "r14" }, "lr" }, 4697 { { "r15" }, "pc" }, 4698 // The S, D and Q registers overlap, but aren't really aliases; we 4699 // don't want to substitute one of these for a different-sized one. 4700 }; 4701 4702 void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 4703 unsigned &NumAliases) const { 4704 Aliases = GCCRegAliases; 4705 NumAliases = llvm::array_lengthof(GCCRegAliases); 4706 } 4707 4708 const Builtin::Info ARMTargetInfo::BuiltinInfo[] = { 4709 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 4710 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 4711 ALL_LANGUAGES }, 4712 #include "clang/Basic/BuiltinsNEON.def" 4713 4714 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 4715 #define LANGBUILTIN(ID, TYPE, ATTRS, LANG) { #ID, TYPE, ATTRS, 0, LANG }, 4716 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 4717 ALL_LANGUAGES }, 4718 #include "clang/Basic/BuiltinsARM.def" 4719 }; 4720 4721 class ARMleTargetInfo : public ARMTargetInfo { 4722 public: 4723 ARMleTargetInfo(const llvm::Triple &Triple) 4724 : ARMTargetInfo(Triple, false) { } 4725 void getTargetDefines(const LangOptions &Opts, 4726 MacroBuilder &Builder) const override { 4727 Builder.defineMacro("__ARMEL__"); 4728 ARMTargetInfo::getTargetDefines(Opts, Builder); 4729 } 4730 }; 4731 4732 class ARMbeTargetInfo : public ARMTargetInfo { 4733 public: 4734 ARMbeTargetInfo(const llvm::Triple &Triple) 4735 : ARMTargetInfo(Triple, true) { } 4736 void getTargetDefines(const LangOptions &Opts, 4737 MacroBuilder &Builder) const override { 4738 Builder.defineMacro("__ARMEB__"); 4739 Builder.defineMacro("__ARM_BIG_ENDIAN"); 4740 ARMTargetInfo::getTargetDefines(Opts, Builder); 4741 } 4742 }; 4743 4744 class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> { 4745 const llvm::Triple Triple; 4746 public: 4747 WindowsARMTargetInfo(const llvm::Triple &Triple) 4748 : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) { 4749 TLSSupported = false; 4750 WCharType = UnsignedShort; 4751 SizeType = UnsignedInt; 4752 UserLabelPrefix = ""; 4753 } 4754 void getVisualStudioDefines(const LangOptions &Opts, 4755 MacroBuilder &Builder) const { 4756 WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder); 4757 4758 // FIXME: this is invalid for WindowsCE 4759 Builder.defineMacro("_M_ARM_NT", "1"); 4760 Builder.defineMacro("_M_ARMT", "_M_ARM"); 4761 Builder.defineMacro("_M_THUMB", "_M_ARM"); 4762 4763 assert((Triple.getArch() == llvm::Triple::arm || 4764 Triple.getArch() == llvm::Triple::thumb) && 4765 "invalid architecture for Windows ARM target info"); 4766 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6; 4767 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset)); 4768 4769 // TODO map the complete set of values 4770 // 31: VFPv3 40: VFPv4 4771 Builder.defineMacro("_M_ARM_FP", "31"); 4772 } 4773 BuiltinVaListKind getBuiltinVaListKind() const override { 4774 return TargetInfo::CharPtrBuiltinVaList; 4775 } 4776 }; 4777 4778 // Windows ARM + Itanium C++ ABI Target 4779 class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo { 4780 public: 4781 ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple) 4782 : WindowsARMTargetInfo(Triple) { 4783 TheCXXABI.set(TargetCXXABI::GenericARM); 4784 } 4785 4786 void getTargetDefines(const LangOptions &Opts, 4787 MacroBuilder &Builder) const override { 4788 WindowsARMTargetInfo::getTargetDefines(Opts, Builder); 4789 4790 if (Opts.MSVCCompat) 4791 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder); 4792 } 4793 }; 4794 4795 // Windows ARM, MS (C++) ABI 4796 class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo { 4797 public: 4798 MicrosoftARMleTargetInfo(const llvm::Triple &Triple) 4799 : WindowsARMTargetInfo(Triple) { 4800 TheCXXABI.set(TargetCXXABI::Microsoft); 4801 } 4802 4803 void getTargetDefines(const LangOptions &Opts, 4804 MacroBuilder &Builder) const override { 4805 WindowsARMTargetInfo::getTargetDefines(Opts, Builder); 4806 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder); 4807 } 4808 }; 4809 4810 class DarwinARMTargetInfo : 4811 public DarwinTargetInfo<ARMleTargetInfo> { 4812 protected: 4813 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 4814 MacroBuilder &Builder) const override { 4815 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion); 4816 } 4817 4818 public: 4819 DarwinARMTargetInfo(const llvm::Triple &Triple) 4820 : DarwinTargetInfo<ARMleTargetInfo>(Triple) { 4821 HasAlignMac68kSupport = true; 4822 // iOS always has 64-bit atomic instructions. 4823 // FIXME: This should be based off of the target features in 4824 // ARMleTargetInfo. 4825 MaxAtomicInlineWidth = 64; 4826 4827 // Darwin on iOS uses a variant of the ARM C++ ABI. 4828 TheCXXABI.set(TargetCXXABI::iOS); 4829 } 4830 }; 4831 4832 class AArch64TargetInfo : public TargetInfo { 4833 virtual void setDescriptionString() = 0; 4834 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 4835 static const char *const GCCRegNames[]; 4836 4837 enum FPUModeEnum { 4838 FPUMode, 4839 NeonMode 4840 }; 4841 4842 unsigned FPU; 4843 unsigned CRC; 4844 unsigned Crypto; 4845 4846 static const Builtin::Info BuiltinInfo[]; 4847 4848 std::string ABI; 4849 4850 public: 4851 AArch64TargetInfo(const llvm::Triple &Triple) 4852 : TargetInfo(Triple), ABI("aapcs") { 4853 4854 if (getTriple().getOS() == llvm::Triple::NetBSD) { 4855 WCharType = SignedInt; 4856 4857 // NetBSD apparently prefers consistency across ARM targets to consistency 4858 // across 64-bit targets. 4859 Int64Type = SignedLongLong; 4860 IntMaxType = SignedLongLong; 4861 } else { 4862 WCharType = UnsignedInt; 4863 Int64Type = SignedLong; 4864 IntMaxType = SignedLong; 4865 } 4866 4867 LongWidth = LongAlign = PointerWidth = PointerAlign = 64; 4868 MaxVectorAlign = 128; 4869 RegParmMax = 8; 4870 MaxAtomicInlineWidth = 128; 4871 MaxAtomicPromoteWidth = 128; 4872 4873 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128; 4874 LongDoubleFormat = &llvm::APFloat::IEEEquad; 4875 4876 // {} in inline assembly are neon specifiers, not assembly variant 4877 // specifiers. 4878 NoAsmVariants = true; 4879 4880 // AAPCS gives rules for bitfields. 7.1.7 says: "The container type 4881 // contributes to the alignment of the containing aggregate in the same way 4882 // a plain (non bit-field) member of that type would, without exception for 4883 // zero-sized or anonymous bit-fields." 4884 UseBitFieldTypeAlignment = true; 4885 UseZeroLengthBitfieldAlignment = true; 4886 4887 // AArch64 targets default to using the ARM C++ ABI. 4888 TheCXXABI.set(TargetCXXABI::GenericAArch64); 4889 } 4890 4891 StringRef getABI() const override { return ABI; } 4892 bool setABI(const std::string &Name) override { 4893 if (Name != "aapcs" && Name != "darwinpcs") 4894 return false; 4895 4896 ABI = Name; 4897 return true; 4898 } 4899 4900 bool setCPU(const std::string &Name) override { 4901 bool CPUKnown = llvm::StringSwitch<bool>(Name) 4902 .Case("generic", true) 4903 .Cases("cortex-a53", "cortex-a57", "cortex-a72", true) 4904 .Case("cyclone", true) 4905 .Default(false); 4906 return CPUKnown; 4907 } 4908 4909 void getTargetDefines(const LangOptions &Opts, 4910 MacroBuilder &Builder) const override { 4911 // Target identification. 4912 Builder.defineMacro("__aarch64__"); 4913 4914 // Target properties. 4915 Builder.defineMacro("_LP64"); 4916 Builder.defineMacro("__LP64__"); 4917 4918 // ACLE predefines. Many can only have one possible value on v8 AArch64. 4919 Builder.defineMacro("__ARM_ACLE", "200"); 4920 Builder.defineMacro("__ARM_ARCH", "8"); 4921 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'"); 4922 4923 Builder.defineMacro("__ARM_64BIT_STATE"); 4924 Builder.defineMacro("__ARM_PCS_AAPCS64"); 4925 Builder.defineMacro("__ARM_ARCH_ISA_A64"); 4926 4927 Builder.defineMacro("__ARM_FEATURE_UNALIGNED"); 4928 Builder.defineMacro("__ARM_FEATURE_CLZ"); 4929 Builder.defineMacro("__ARM_FEATURE_FMA"); 4930 Builder.defineMacro("__ARM_FEATURE_DIV"); 4931 Builder.defineMacro("__ARM_FEATURE_IDIV"); // As specified in ACLE 4932 Builder.defineMacro("__ARM_FEATURE_DIV"); // For backwards compatibility 4933 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN"); 4934 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING"); 4935 4936 Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4"); 4937 4938 // 0xe implies support for half, single and double precision operations. 4939 Builder.defineMacro("__ARM_FP", "0xe"); 4940 4941 // PCS specifies this for SysV variants, which is all we support. Other ABIs 4942 // may choose __ARM_FP16_FORMAT_ALTERNATIVE. 4943 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE"); 4944 4945 if (Opts.FastMath || Opts.FiniteMathOnly) 4946 Builder.defineMacro("__ARM_FP_FAST"); 4947 4948 if (Opts.C99 && !Opts.Freestanding) 4949 Builder.defineMacro("__ARM_FP_FENV_ROUNDING"); 4950 4951 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4"); 4952 4953 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM", 4954 Opts.ShortEnums ? "1" : "4"); 4955 4956 if (FPU == NeonMode) { 4957 Builder.defineMacro("__ARM_NEON"); 4958 // 64-bit NEON supports half, single and double precision operations. 4959 Builder.defineMacro("__ARM_NEON_FP", "0xe"); 4960 } 4961 4962 if (CRC) 4963 Builder.defineMacro("__ARM_FEATURE_CRC32"); 4964 4965 if (Crypto) 4966 Builder.defineMacro("__ARM_FEATURE_CRYPTO"); 4967 4968 // All of the __sync_(bool|val)_compare_and_swap_(1|2|4|8) builtins work. 4969 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); 4970 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); 4971 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); 4972 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); 4973 } 4974 4975 void getTargetBuiltins(const Builtin::Info *&Records, 4976 unsigned &NumRecords) const override { 4977 Records = BuiltinInfo; 4978 NumRecords = clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin; 4979 } 4980 4981 bool hasFeature(StringRef Feature) const override { 4982 return Feature == "aarch64" || 4983 Feature == "arm64" || 4984 (Feature == "neon" && FPU == NeonMode); 4985 } 4986 4987 bool handleTargetFeatures(std::vector<std::string> &Features, 4988 DiagnosticsEngine &Diags) override { 4989 FPU = FPUMode; 4990 CRC = 0; 4991 Crypto = 0; 4992 for (unsigned i = 0, e = Features.size(); i != e; ++i) { 4993 if (Features[i] == "+neon") 4994 FPU = NeonMode; 4995 if (Features[i] == "+crc") 4996 CRC = 1; 4997 if (Features[i] == "+crypto") 4998 Crypto = 1; 4999 } 5000 5001 setDescriptionString(); 5002 5003 return true; 5004 } 5005 5006 bool isCLZForZeroUndef() const override { return false; } 5007 5008 BuiltinVaListKind getBuiltinVaListKind() const override { 5009 return TargetInfo::AArch64ABIBuiltinVaList; 5010 } 5011 5012 void getGCCRegNames(const char *const *&Names, 5013 unsigned &NumNames) const override; 5014 void getGCCRegAliases(const GCCRegAlias *&Aliases, 5015 unsigned &NumAliases) const override; 5016 5017 bool validateAsmConstraint(const char *&Name, 5018 TargetInfo::ConstraintInfo &Info) const override { 5019 switch (*Name) { 5020 default: 5021 return false; 5022 case 'w': // Floating point and SIMD registers (V0-V31) 5023 Info.setAllowsRegister(); 5024 return true; 5025 case 'I': // Constant that can be used with an ADD instruction 5026 case 'J': // Constant that can be used with a SUB instruction 5027 case 'K': // Constant that can be used with a 32-bit logical instruction 5028 case 'L': // Constant that can be used with a 64-bit logical instruction 5029 case 'M': // Constant that can be used as a 32-bit MOV immediate 5030 case 'N': // Constant that can be used as a 64-bit MOV immediate 5031 case 'Y': // Floating point constant zero 5032 case 'Z': // Integer constant zero 5033 return true; 5034 case 'Q': // A memory reference with base register and no offset 5035 Info.setAllowsMemory(); 5036 return true; 5037 case 'S': // A symbolic address 5038 Info.setAllowsRegister(); 5039 return true; 5040 case 'U': 5041 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes. 5042 // Utf: A memory address suitable for ldp/stp in TF mode. 5043 // Usa: An absolute symbolic address. 5044 // Ush: The high part (bits 32:12) of a pc-relative symbolic address. 5045 llvm_unreachable("FIXME: Unimplemented support for U* constraints."); 5046 case 'z': // Zero register, wzr or xzr 5047 Info.setAllowsRegister(); 5048 return true; 5049 case 'x': // Floating point and SIMD registers (V0-V15) 5050 Info.setAllowsRegister(); 5051 return true; 5052 } 5053 return false; 5054 } 5055 5056 bool 5057 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size, 5058 std::string &SuggestedModifier) const override { 5059 // Strip off constraint modifiers. 5060 while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&') 5061 Constraint = Constraint.substr(1); 5062 5063 switch (Constraint[0]) { 5064 default: 5065 return true; 5066 case 'z': 5067 case 'r': { 5068 switch (Modifier) { 5069 case 'x': 5070 case 'w': 5071 // For now assume that the person knows what they're 5072 // doing with the modifier. 5073 return true; 5074 default: 5075 // By default an 'r' constraint will be in the 'x' 5076 // registers. 5077 if (Size == 64) 5078 return true; 5079 5080 SuggestedModifier = "w"; 5081 return false; 5082 } 5083 } 5084 } 5085 } 5086 5087 const char *getClobbers() const override { return ""; } 5088 5089 int getEHDataRegisterNumber(unsigned RegNo) const override { 5090 if (RegNo == 0) 5091 return 0; 5092 if (RegNo == 1) 5093 return 1; 5094 return -1; 5095 } 5096 }; 5097 5098 const char *const AArch64TargetInfo::GCCRegNames[] = { 5099 // 32-bit Integer registers 5100 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10", 5101 "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21", 5102 "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", 5103 5104 // 64-bit Integer registers 5105 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", 5106 "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21", 5107 "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp", "lr", "sp", 5108 5109 // 32-bit floating point regsisters 5110 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", 5111 "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21", 5112 "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", 5113 5114 // 64-bit floating point regsisters 5115 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10", 5116 "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21", 5117 "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31", 5118 5119 // Vector registers 5120 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", 5121 "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21", 5122 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31" 5123 }; 5124 5125 void AArch64TargetInfo::getGCCRegNames(const char *const *&Names, 5126 unsigned &NumNames) const { 5127 Names = GCCRegNames; 5128 NumNames = llvm::array_lengthof(GCCRegNames); 5129 } 5130 5131 const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = { 5132 { { "w31" }, "wsp" }, 5133 { { "x29" }, "fp" }, 5134 { { "x30" }, "lr" }, 5135 { { "x31" }, "sp" }, 5136 // The S/D/Q and W/X registers overlap, but aren't really aliases; we 5137 // don't want to substitute one of these for a different-sized one. 5138 }; 5139 5140 void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 5141 unsigned &NumAliases) const { 5142 Aliases = GCCRegAliases; 5143 NumAliases = llvm::array_lengthof(GCCRegAliases); 5144 } 5145 5146 const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = { 5147 #define BUILTIN(ID, TYPE, ATTRS) \ 5148 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 5149 #include "clang/Basic/BuiltinsNEON.def" 5150 5151 #define BUILTIN(ID, TYPE, ATTRS) \ 5152 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 5153 #include "clang/Basic/BuiltinsAArch64.def" 5154 }; 5155 5156 class AArch64leTargetInfo : public AArch64TargetInfo { 5157 void setDescriptionString() override { 5158 if (getTriple().isOSBinFormatMachO()) 5159 DescriptionString = "e-m:o-i64:64-i128:128-n32:64-S128"; 5160 else 5161 DescriptionString = "e-m:e-i64:64-i128:128-n32:64-S128"; 5162 } 5163 5164 public: 5165 AArch64leTargetInfo(const llvm::Triple &Triple) 5166 : AArch64TargetInfo(Triple) { 5167 BigEndian = false; 5168 } 5169 void getTargetDefines(const LangOptions &Opts, 5170 MacroBuilder &Builder) const override { 5171 Builder.defineMacro("__AARCH64EL__"); 5172 AArch64TargetInfo::getTargetDefines(Opts, Builder); 5173 } 5174 }; 5175 5176 class AArch64beTargetInfo : public AArch64TargetInfo { 5177 void setDescriptionString() override { 5178 assert(!getTriple().isOSBinFormatMachO()); 5179 DescriptionString = "E-m:e-i64:64-i128:128-n32:64-S128"; 5180 } 5181 5182 public: 5183 AArch64beTargetInfo(const llvm::Triple &Triple) 5184 : AArch64TargetInfo(Triple) { } 5185 void getTargetDefines(const LangOptions &Opts, 5186 MacroBuilder &Builder) const override { 5187 Builder.defineMacro("__AARCH64EB__"); 5188 Builder.defineMacro("__AARCH_BIG_ENDIAN"); 5189 Builder.defineMacro("__ARM_BIG_ENDIAN"); 5190 AArch64TargetInfo::getTargetDefines(Opts, Builder); 5191 } 5192 }; 5193 5194 class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> { 5195 protected: 5196 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 5197 MacroBuilder &Builder) const override { 5198 Builder.defineMacro("__AARCH64_SIMD__"); 5199 Builder.defineMacro("__ARM64_ARCH_8__"); 5200 Builder.defineMacro("__ARM_NEON__"); 5201 Builder.defineMacro("__LITTLE_ENDIAN__"); 5202 Builder.defineMacro("__REGISTER_PREFIX__", ""); 5203 Builder.defineMacro("__arm64", "1"); 5204 Builder.defineMacro("__arm64__", "1"); 5205 5206 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion); 5207 } 5208 5209 public: 5210 DarwinAArch64TargetInfo(const llvm::Triple &Triple) 5211 : DarwinTargetInfo<AArch64leTargetInfo>(Triple) { 5212 Int64Type = SignedLongLong; 5213 WCharType = SignedInt; 5214 UseSignedCharForObjCBool = false; 5215 5216 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64; 5217 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 5218 5219 TheCXXABI.set(TargetCXXABI::iOS64); 5220 } 5221 5222 BuiltinVaListKind getBuiltinVaListKind() const override { 5223 return TargetInfo::CharPtrBuiltinVaList; 5224 } 5225 }; 5226 5227 // Hexagon abstract base class 5228 class HexagonTargetInfo : public TargetInfo { 5229 static const Builtin::Info BuiltinInfo[]; 5230 static const char * const GCCRegNames[]; 5231 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 5232 std::string CPU; 5233 public: 5234 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 5235 BigEndian = false; 5236 DescriptionString = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"; 5237 5238 // {} in inline assembly are packet specifiers, not assembly variant 5239 // specifiers. 5240 NoAsmVariants = true; 5241 } 5242 5243 void getTargetBuiltins(const Builtin::Info *&Records, 5244 unsigned &NumRecords) const override { 5245 Records = BuiltinInfo; 5246 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin; 5247 } 5248 5249 bool validateAsmConstraint(const char *&Name, 5250 TargetInfo::ConstraintInfo &Info) const override { 5251 return true; 5252 } 5253 5254 void getTargetDefines(const LangOptions &Opts, 5255 MacroBuilder &Builder) const override; 5256 5257 bool hasFeature(StringRef Feature) const override { 5258 return Feature == "hexagon"; 5259 } 5260 5261 BuiltinVaListKind getBuiltinVaListKind() const override { 5262 return TargetInfo::CharPtrBuiltinVaList; 5263 } 5264 void getGCCRegNames(const char * const *&Names, 5265 unsigned &NumNames) const override; 5266 void getGCCRegAliases(const GCCRegAlias *&Aliases, 5267 unsigned &NumAliases) const override; 5268 const char *getClobbers() const override { 5269 return ""; 5270 } 5271 5272 static const char *getHexagonCPUSuffix(StringRef Name) { 5273 return llvm::StringSwitch<const char*>(Name) 5274 .Case("hexagonv4", "4") 5275 .Case("hexagonv5", "5") 5276 .Default(nullptr); 5277 } 5278 5279 bool setCPU(const std::string &Name) override { 5280 if (!getHexagonCPUSuffix(Name)) 5281 return false; 5282 5283 CPU = Name; 5284 return true; 5285 } 5286 }; 5287 5288 void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts, 5289 MacroBuilder &Builder) const { 5290 Builder.defineMacro("qdsp6"); 5291 Builder.defineMacro("__qdsp6", "1"); 5292 Builder.defineMacro("__qdsp6__", "1"); 5293 5294 Builder.defineMacro("hexagon"); 5295 Builder.defineMacro("__hexagon", "1"); 5296 Builder.defineMacro("__hexagon__", "1"); 5297 5298 if(CPU == "hexagonv1") { 5299 Builder.defineMacro("__HEXAGON_V1__"); 5300 Builder.defineMacro("__HEXAGON_ARCH__", "1"); 5301 if(Opts.HexagonQdsp6Compat) { 5302 Builder.defineMacro("__QDSP6_V1__"); 5303 Builder.defineMacro("__QDSP6_ARCH__", "1"); 5304 } 5305 } 5306 else if(CPU == "hexagonv2") { 5307 Builder.defineMacro("__HEXAGON_V2__"); 5308 Builder.defineMacro("__HEXAGON_ARCH__", "2"); 5309 if(Opts.HexagonQdsp6Compat) { 5310 Builder.defineMacro("__QDSP6_V2__"); 5311 Builder.defineMacro("__QDSP6_ARCH__", "2"); 5312 } 5313 } 5314 else if(CPU == "hexagonv3") { 5315 Builder.defineMacro("__HEXAGON_V3__"); 5316 Builder.defineMacro("__HEXAGON_ARCH__", "3"); 5317 if(Opts.HexagonQdsp6Compat) { 5318 Builder.defineMacro("__QDSP6_V3__"); 5319 Builder.defineMacro("__QDSP6_ARCH__", "3"); 5320 } 5321 } 5322 else if(CPU == "hexagonv4") { 5323 Builder.defineMacro("__HEXAGON_V4__"); 5324 Builder.defineMacro("__HEXAGON_ARCH__", "4"); 5325 if(Opts.HexagonQdsp6Compat) { 5326 Builder.defineMacro("__QDSP6_V4__"); 5327 Builder.defineMacro("__QDSP6_ARCH__", "4"); 5328 } 5329 } 5330 else if(CPU == "hexagonv5") { 5331 Builder.defineMacro("__HEXAGON_V5__"); 5332 Builder.defineMacro("__HEXAGON_ARCH__", "5"); 5333 if(Opts.HexagonQdsp6Compat) { 5334 Builder.defineMacro("__QDSP6_V5__"); 5335 Builder.defineMacro("__QDSP6_ARCH__", "5"); 5336 } 5337 } 5338 } 5339 5340 const char * const HexagonTargetInfo::GCCRegNames[] = { 5341 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 5342 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 5343 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 5344 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 5345 "p0", "p1", "p2", "p3", 5346 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp" 5347 }; 5348 5349 void HexagonTargetInfo::getGCCRegNames(const char * const *&Names, 5350 unsigned &NumNames) const { 5351 Names = GCCRegNames; 5352 NumNames = llvm::array_lengthof(GCCRegNames); 5353 } 5354 5355 5356 const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = { 5357 { { "sp" }, "r29" }, 5358 { { "fp" }, "r30" }, 5359 { { "lr" }, "r31" }, 5360 }; 5361 5362 void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 5363 unsigned &NumAliases) const { 5364 Aliases = GCCRegAliases; 5365 NumAliases = llvm::array_lengthof(GCCRegAliases); 5366 } 5367 5368 5369 const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = { 5370 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 5371 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 5372 ALL_LANGUAGES }, 5373 #include "clang/Basic/BuiltinsHexagon.def" 5374 }; 5375 5376 // Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit). 5377 class SparcTargetInfo : public TargetInfo { 5378 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 5379 static const char * const GCCRegNames[]; 5380 bool SoftFloat; 5381 public: 5382 SparcTargetInfo(const llvm::Triple &Triple) 5383 : TargetInfo(Triple), SoftFloat(false) {} 5384 5385 bool handleTargetFeatures(std::vector<std::string> &Features, 5386 DiagnosticsEngine &Diags) override { 5387 // The backend doesn't actually handle soft float yet, but in case someone 5388 // is using the support for the front end continue to support it. 5389 auto Feature = std::find(Features.begin(), Features.end(), "+soft-float"); 5390 if (Feature != Features.end()) { 5391 SoftFloat = true; 5392 Features.erase(Feature); 5393 } 5394 return true; 5395 } 5396 void getTargetDefines(const LangOptions &Opts, 5397 MacroBuilder &Builder) const override { 5398 DefineStd(Builder, "sparc", Opts); 5399 Builder.defineMacro("__REGISTER_PREFIX__", ""); 5400 5401 if (SoftFloat) 5402 Builder.defineMacro("SOFT_FLOAT", "1"); 5403 } 5404 5405 bool hasFeature(StringRef Feature) const override { 5406 return llvm::StringSwitch<bool>(Feature) 5407 .Case("softfloat", SoftFloat) 5408 .Case("sparc", true) 5409 .Default(false); 5410 } 5411 5412 void getTargetBuiltins(const Builtin::Info *&Records, 5413 unsigned &NumRecords) const override { 5414 // FIXME: Implement! 5415 } 5416 BuiltinVaListKind getBuiltinVaListKind() const override { 5417 return TargetInfo::VoidPtrBuiltinVaList; 5418 } 5419 void getGCCRegNames(const char * const *&Names, 5420 unsigned &NumNames) const override; 5421 void getGCCRegAliases(const GCCRegAlias *&Aliases, 5422 unsigned &NumAliases) const override; 5423 bool validateAsmConstraint(const char *&Name, 5424 TargetInfo::ConstraintInfo &info) const override { 5425 // FIXME: Implement! 5426 switch (*Name) { 5427 case 'I': // Signed 13-bit constant 5428 case 'J': // Zero 5429 case 'K': // 32-bit constant with the low 12 bits clear 5430 case 'L': // A constant in the range supported by movcc (11-bit signed imm) 5431 case 'M': // A constant in the range supported by movrcc (19-bit signed imm) 5432 case 'N': // Same as 'K' but zext (required for SIMode) 5433 case 'O': // The constant 4096 5434 return true; 5435 } 5436 return false; 5437 } 5438 const char *getClobbers() const override { 5439 // FIXME: Implement! 5440 return ""; 5441 } 5442 }; 5443 5444 const char * const SparcTargetInfo::GCCRegNames[] = { 5445 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 5446 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 5447 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 5448 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31" 5449 }; 5450 5451 void SparcTargetInfo::getGCCRegNames(const char * const *&Names, 5452 unsigned &NumNames) const { 5453 Names = GCCRegNames; 5454 NumNames = llvm::array_lengthof(GCCRegNames); 5455 } 5456 5457 const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = { 5458 { { "g0" }, "r0" }, 5459 { { "g1" }, "r1" }, 5460 { { "g2" }, "r2" }, 5461 { { "g3" }, "r3" }, 5462 { { "g4" }, "r4" }, 5463 { { "g5" }, "r5" }, 5464 { { "g6" }, "r6" }, 5465 { { "g7" }, "r7" }, 5466 { { "o0" }, "r8" }, 5467 { { "o1" }, "r9" }, 5468 { { "o2" }, "r10" }, 5469 { { "o3" }, "r11" }, 5470 { { "o4" }, "r12" }, 5471 { { "o5" }, "r13" }, 5472 { { "o6", "sp" }, "r14" }, 5473 { { "o7" }, "r15" }, 5474 { { "l0" }, "r16" }, 5475 { { "l1" }, "r17" }, 5476 { { "l2" }, "r18" }, 5477 { { "l3" }, "r19" }, 5478 { { "l4" }, "r20" }, 5479 { { "l5" }, "r21" }, 5480 { { "l6" }, "r22" }, 5481 { { "l7" }, "r23" }, 5482 { { "i0" }, "r24" }, 5483 { { "i1" }, "r25" }, 5484 { { "i2" }, "r26" }, 5485 { { "i3" }, "r27" }, 5486 { { "i4" }, "r28" }, 5487 { { "i5" }, "r29" }, 5488 { { "i6", "fp" }, "r30" }, 5489 { { "i7" }, "r31" }, 5490 }; 5491 5492 void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 5493 unsigned &NumAliases) const { 5494 Aliases = GCCRegAliases; 5495 NumAliases = llvm::array_lengthof(GCCRegAliases); 5496 } 5497 5498 // SPARC v8 is the 32-bit mode selected by Triple::sparc. 5499 class SparcV8TargetInfo : public SparcTargetInfo { 5500 public: 5501 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) { 5502 DescriptionString = "E-m:e-p:32:32-i64:64-f128:64-n32-S64"; 5503 } 5504 5505 void getTargetDefines(const LangOptions &Opts, 5506 MacroBuilder &Builder) const override { 5507 SparcTargetInfo::getTargetDefines(Opts, Builder); 5508 Builder.defineMacro("__sparcv8"); 5509 } 5510 }; 5511 5512 // SPARCV8el is the 32-bit little-endian mode selected by Triple::sparcel. 5513 class SparcV8elTargetInfo : public SparcV8TargetInfo { 5514 public: 5515 SparcV8elTargetInfo(const llvm::Triple &Triple) : SparcV8TargetInfo(Triple) { 5516 DescriptionString = "e-m:e-p:32:32-i64:64-f128:64-n32-S64"; 5517 BigEndian = false; 5518 } 5519 }; 5520 5521 // SPARC v9 is the 64-bit mode selected by Triple::sparcv9. 5522 class SparcV9TargetInfo : public SparcTargetInfo { 5523 public: 5524 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) { 5525 // FIXME: Support Sparc quad-precision long double? 5526 DescriptionString = "E-m:e-i64:64-n32:64-S128"; 5527 // This is an LP64 platform. 5528 LongWidth = LongAlign = PointerWidth = PointerAlign = 64; 5529 5530 // OpenBSD uses long long for int64_t and intmax_t. 5531 if (getTriple().getOS() == llvm::Triple::OpenBSD) 5532 IntMaxType = SignedLongLong; 5533 else 5534 IntMaxType = SignedLong; 5535 Int64Type = IntMaxType; 5536 5537 // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit 5538 // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned. 5539 LongDoubleWidth = 128; 5540 LongDoubleAlign = 128; 5541 LongDoubleFormat = &llvm::APFloat::IEEEquad; 5542 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 5543 } 5544 5545 void getTargetDefines(const LangOptions &Opts, 5546 MacroBuilder &Builder) const override { 5547 SparcTargetInfo::getTargetDefines(Opts, Builder); 5548 Builder.defineMacro("__sparcv9"); 5549 Builder.defineMacro("__arch64__"); 5550 // Solaris doesn't need these variants, but the BSDs do. 5551 if (getTriple().getOS() != llvm::Triple::Solaris) { 5552 Builder.defineMacro("__sparc64__"); 5553 Builder.defineMacro("__sparc_v9__"); 5554 Builder.defineMacro("__sparcv9__"); 5555 } 5556 } 5557 5558 bool setCPU(const std::string &Name) override { 5559 bool CPUKnown = llvm::StringSwitch<bool>(Name) 5560 .Case("v9", true) 5561 .Case("ultrasparc", true) 5562 .Case("ultrasparc3", true) 5563 .Case("niagara", true) 5564 .Case("niagara2", true) 5565 .Case("niagara3", true) 5566 .Case("niagara4", true) 5567 .Default(false); 5568 5569 // No need to store the CPU yet. There aren't any CPU-specific 5570 // macros to define. 5571 return CPUKnown; 5572 } 5573 }; 5574 5575 class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> { 5576 public: 5577 SolarisSparcV8TargetInfo(const llvm::Triple &Triple) 5578 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) { 5579 SizeType = UnsignedInt; 5580 PtrDiffType = SignedInt; 5581 } 5582 }; 5583 5584 class SystemZTargetInfo : public TargetInfo { 5585 static const Builtin::Info BuiltinInfo[]; 5586 static const char *const GCCRegNames[]; 5587 std::string CPU; 5588 bool HasTransactionalExecution; 5589 bool HasVector; 5590 5591 public: 5592 SystemZTargetInfo(const llvm::Triple &Triple) 5593 : TargetInfo(Triple), CPU("z10"), HasTransactionalExecution(false), HasVector(false) { 5594 IntMaxType = SignedLong; 5595 Int64Type = SignedLong; 5596 TLSSupported = true; 5597 IntWidth = IntAlign = 32; 5598 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64; 5599 PointerWidth = PointerAlign = 64; 5600 LongDoubleWidth = 128; 5601 LongDoubleAlign = 64; 5602 LongDoubleFormat = &llvm::APFloat::IEEEquad; 5603 DefaultAlignForAttributeAligned = 64; 5604 MinGlobalAlign = 16; 5605 DescriptionString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64"; 5606 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 5607 } 5608 void getTargetDefines(const LangOptions &Opts, 5609 MacroBuilder &Builder) const override { 5610 Builder.defineMacro("__s390__"); 5611 Builder.defineMacro("__s390x__"); 5612 Builder.defineMacro("__zarch__"); 5613 Builder.defineMacro("__LONG_DOUBLE_128__"); 5614 if (HasTransactionalExecution) 5615 Builder.defineMacro("__HTM__"); 5616 } 5617 void getTargetBuiltins(const Builtin::Info *&Records, 5618 unsigned &NumRecords) const override { 5619 Records = BuiltinInfo; 5620 NumRecords = clang::SystemZ::LastTSBuiltin-Builtin::FirstTSBuiltin; 5621 } 5622 5623 void getGCCRegNames(const char *const *&Names, 5624 unsigned &NumNames) const override; 5625 void getGCCRegAliases(const GCCRegAlias *&Aliases, 5626 unsigned &NumAliases) const override { 5627 // No aliases. 5628 Aliases = nullptr; 5629 NumAliases = 0; 5630 } 5631 bool validateAsmConstraint(const char *&Name, 5632 TargetInfo::ConstraintInfo &info) const override; 5633 const char *getClobbers() const override { 5634 // FIXME: Is this really right? 5635 return ""; 5636 } 5637 BuiltinVaListKind getBuiltinVaListKind() const override { 5638 return TargetInfo::SystemZBuiltinVaList; 5639 } 5640 bool setCPU(const std::string &Name) override { 5641 CPU = Name; 5642 bool CPUKnown = llvm::StringSwitch<bool>(Name) 5643 .Case("z10", true) 5644 .Case("z196", true) 5645 .Case("zEC12", true) 5646 .Case("z13", true) 5647 .Default(false); 5648 5649 return CPUKnown; 5650 } 5651 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override { 5652 if (CPU == "zEC12") 5653 Features["transactional-execution"] = true; 5654 if (CPU == "z13") { 5655 Features["transactional-execution"] = true; 5656 Features["vector"] = true; 5657 } 5658 } 5659 5660 bool handleTargetFeatures(std::vector<std::string> &Features, 5661 DiagnosticsEngine &Diags) override { 5662 HasTransactionalExecution = false; 5663 for (unsigned i = 0, e = Features.size(); i != e; ++i) { 5664 if (Features[i] == "+transactional-execution") 5665 HasTransactionalExecution = true; 5666 if (Features[i] == "+vector") 5667 HasVector = true; 5668 } 5669 // If we use the vector ABI, vector types are 64-bit aligned. 5670 if (HasVector) { 5671 MaxVectorAlign = 64; 5672 DescriptionString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64" 5673 "-v128:64-a:8:16-n32:64"; 5674 } 5675 return true; 5676 } 5677 5678 bool hasFeature(StringRef Feature) const override { 5679 return llvm::StringSwitch<bool>(Feature) 5680 .Case("systemz", true) 5681 .Case("htm", HasTransactionalExecution) 5682 .Case("vx", HasVector) 5683 .Default(false); 5684 } 5685 5686 StringRef getABI() const override { 5687 if (HasVector) 5688 return "vector"; 5689 return ""; 5690 } 5691 }; 5692 5693 const Builtin::Info SystemZTargetInfo::BuiltinInfo[] = { 5694 #define BUILTIN(ID, TYPE, ATTRS) \ 5695 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 5696 #include "clang/Basic/BuiltinsSystemZ.def" 5697 }; 5698 5699 const char *const SystemZTargetInfo::GCCRegNames[] = { 5700 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 5701 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 5702 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7", 5703 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15" 5704 }; 5705 5706 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names, 5707 unsigned &NumNames) const { 5708 Names = GCCRegNames; 5709 NumNames = llvm::array_lengthof(GCCRegNames); 5710 } 5711 5712 bool SystemZTargetInfo:: 5713 validateAsmConstraint(const char *&Name, 5714 TargetInfo::ConstraintInfo &Info) const { 5715 switch (*Name) { 5716 default: 5717 return false; 5718 5719 case 'a': // Address register 5720 case 'd': // Data register (equivalent to 'r') 5721 case 'f': // Floating-point register 5722 Info.setAllowsRegister(); 5723 return true; 5724 5725 case 'I': // Unsigned 8-bit constant 5726 case 'J': // Unsigned 12-bit constant 5727 case 'K': // Signed 16-bit constant 5728 case 'L': // Signed 20-bit displacement (on all targets we support) 5729 case 'M': // 0x7fffffff 5730 return true; 5731 5732 case 'Q': // Memory with base and unsigned 12-bit displacement 5733 case 'R': // Likewise, plus an index 5734 case 'S': // Memory with base and signed 20-bit displacement 5735 case 'T': // Likewise, plus an index 5736 Info.setAllowsMemory(); 5737 return true; 5738 } 5739 } 5740 5741 class MSP430TargetInfo : public TargetInfo { 5742 static const char * const GCCRegNames[]; 5743 public: 5744 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 5745 BigEndian = false; 5746 TLSSupported = false; 5747 IntWidth = 16; IntAlign = 16; 5748 LongWidth = 32; LongLongWidth = 64; 5749 LongAlign = LongLongAlign = 16; 5750 PointerWidth = 16; PointerAlign = 16; 5751 SuitableAlign = 16; 5752 SizeType = UnsignedInt; 5753 IntMaxType = SignedLongLong; 5754 IntPtrType = SignedInt; 5755 PtrDiffType = SignedInt; 5756 SigAtomicType = SignedLong; 5757 DescriptionString = "e-m:e-p:16:16-i32:16:32-a:16-n8:16"; 5758 } 5759 void getTargetDefines(const LangOptions &Opts, 5760 MacroBuilder &Builder) const override { 5761 Builder.defineMacro("MSP430"); 5762 Builder.defineMacro("__MSP430__"); 5763 // FIXME: defines for different 'flavours' of MCU 5764 } 5765 void getTargetBuiltins(const Builtin::Info *&Records, 5766 unsigned &NumRecords) const override { 5767 // FIXME: Implement. 5768 Records = nullptr; 5769 NumRecords = 0; 5770 } 5771 bool hasFeature(StringRef Feature) const override { 5772 return Feature == "msp430"; 5773 } 5774 void getGCCRegNames(const char * const *&Names, 5775 unsigned &NumNames) const override; 5776 void getGCCRegAliases(const GCCRegAlias *&Aliases, 5777 unsigned &NumAliases) const override { 5778 // No aliases. 5779 Aliases = nullptr; 5780 NumAliases = 0; 5781 } 5782 bool 5783 validateAsmConstraint(const char *&Name, 5784 TargetInfo::ConstraintInfo &info) const override { 5785 // FIXME: implement 5786 switch (*Name) { 5787 case 'K': // the constant 1 5788 case 'L': // constant -1^20 .. 1^19 5789 case 'M': // constant 1-4: 5790 return true; 5791 } 5792 // No target constraints for now. 5793 return false; 5794 } 5795 const char *getClobbers() const override { 5796 // FIXME: Is this really right? 5797 return ""; 5798 } 5799 BuiltinVaListKind getBuiltinVaListKind() const override { 5800 // FIXME: implement 5801 return TargetInfo::CharPtrBuiltinVaList; 5802 } 5803 }; 5804 5805 const char * const MSP430TargetInfo::GCCRegNames[] = { 5806 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 5807 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 5808 }; 5809 5810 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names, 5811 unsigned &NumNames) const { 5812 Names = GCCRegNames; 5813 NumNames = llvm::array_lengthof(GCCRegNames); 5814 } 5815 5816 // LLVM and Clang cannot be used directly to output native binaries for 5817 // target, but is used to compile C code to llvm bitcode with correct 5818 // type and alignment information. 5819 // 5820 // TCE uses the llvm bitcode as input and uses it for generating customized 5821 // target processor and program binary. TCE co-design environment is 5822 // publicly available in http://tce.cs.tut.fi 5823 5824 static const unsigned TCEOpenCLAddrSpaceMap[] = { 5825 3, // opencl_global 5826 4, // opencl_local 5827 5, // opencl_constant 5828 // FIXME: generic has to be added to the target 5829 0, // opencl_generic 5830 0, // cuda_device 5831 0, // cuda_constant 5832 0 // cuda_shared 5833 }; 5834 5835 class TCETargetInfo : public TargetInfo{ 5836 public: 5837 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 5838 TLSSupported = false; 5839 IntWidth = 32; 5840 LongWidth = LongLongWidth = 32; 5841 PointerWidth = 32; 5842 IntAlign = 32; 5843 LongAlign = LongLongAlign = 32; 5844 PointerAlign = 32; 5845 SuitableAlign = 32; 5846 SizeType = UnsignedInt; 5847 IntMaxType = SignedLong; 5848 IntPtrType = SignedInt; 5849 PtrDiffType = SignedInt; 5850 FloatWidth = 32; 5851 FloatAlign = 32; 5852 DoubleWidth = 32; 5853 DoubleAlign = 32; 5854 LongDoubleWidth = 32; 5855 LongDoubleAlign = 32; 5856 FloatFormat = &llvm::APFloat::IEEEsingle; 5857 DoubleFormat = &llvm::APFloat::IEEEsingle; 5858 LongDoubleFormat = &llvm::APFloat::IEEEsingle; 5859 DescriptionString = "E-p:32:32-i8:8:32-i16:16:32-i64:32" 5860 "-f64:32-v64:32-v128:32-a:0:32-n32"; 5861 AddrSpaceMap = &TCEOpenCLAddrSpaceMap; 5862 UseAddrSpaceMapMangling = true; 5863 } 5864 5865 void getTargetDefines(const LangOptions &Opts, 5866 MacroBuilder &Builder) const override { 5867 DefineStd(Builder, "tce", Opts); 5868 Builder.defineMacro("__TCE__"); 5869 Builder.defineMacro("__TCE_V1__"); 5870 } 5871 bool hasFeature(StringRef Feature) const override { 5872 return Feature == "tce"; 5873 } 5874 5875 void getTargetBuiltins(const Builtin::Info *&Records, 5876 unsigned &NumRecords) const override {} 5877 const char *getClobbers() const override { 5878 return ""; 5879 } 5880 BuiltinVaListKind getBuiltinVaListKind() const override { 5881 return TargetInfo::VoidPtrBuiltinVaList; 5882 } 5883 void getGCCRegNames(const char * const *&Names, 5884 unsigned &NumNames) const override {} 5885 bool validateAsmConstraint(const char *&Name, 5886 TargetInfo::ConstraintInfo &info) const override{ 5887 return true; 5888 } 5889 void getGCCRegAliases(const GCCRegAlias *&Aliases, 5890 unsigned &NumAliases) const override {} 5891 }; 5892 5893 class MipsTargetInfoBase : public TargetInfo { 5894 virtual void setDescriptionString() = 0; 5895 5896 static const Builtin::Info BuiltinInfo[]; 5897 std::string CPU; 5898 bool IsMips16; 5899 bool IsMicromips; 5900 bool IsNan2008; 5901 bool IsSingleFloat; 5902 enum MipsFloatABI { 5903 HardFloat, SoftFloat 5904 } FloatABI; 5905 enum DspRevEnum { 5906 NoDSP, DSP1, DSP2 5907 } DspRev; 5908 bool HasMSA; 5909 5910 protected: 5911 bool HasFP64; 5912 std::string ABI; 5913 5914 public: 5915 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr, 5916 const std::string &CPUStr) 5917 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false), 5918 IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat), 5919 DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) { 5920 TheCXXABI.set(TargetCXXABI::GenericMIPS); 5921 } 5922 5923 bool isNaN2008Default() const { 5924 return CPU == "mips32r6" || CPU == "mips64r6"; 5925 } 5926 5927 bool isFP64Default() const { 5928 return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64"; 5929 } 5930 5931 bool isNan2008() const override { 5932 return IsNan2008; 5933 } 5934 5935 StringRef getABI() const override { return ABI; } 5936 bool setCPU(const std::string &Name) override { 5937 bool IsMips32 = getTriple().getArch() == llvm::Triple::mips || 5938 getTriple().getArch() == llvm::Triple::mipsel; 5939 CPU = Name; 5940 return llvm::StringSwitch<bool>(Name) 5941 .Case("mips1", IsMips32) 5942 .Case("mips2", IsMips32) 5943 .Case("mips3", true) 5944 .Case("mips4", true) 5945 .Case("mips5", true) 5946 .Case("mips32", IsMips32) 5947 .Case("mips32r2", IsMips32) 5948 .Case("mips32r3", IsMips32) 5949 .Case("mips32r5", IsMips32) 5950 .Case("mips32r6", IsMips32) 5951 .Case("mips64", true) 5952 .Case("mips64r2", true) 5953 .Case("mips64r3", true) 5954 .Case("mips64r5", true) 5955 .Case("mips64r6", true) 5956 .Case("octeon", true) 5957 .Default(false); 5958 } 5959 const std::string& getCPU() const { return CPU; } 5960 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override { 5961 if (CPU == "octeon") 5962 Features["mips64r2"] = Features["cnmips"] = true; 5963 else 5964 Features[CPU] = true; 5965 } 5966 5967 void getTargetDefines(const LangOptions &Opts, 5968 MacroBuilder &Builder) const override { 5969 Builder.defineMacro("__mips__"); 5970 Builder.defineMacro("_mips"); 5971 if (Opts.GNUMode) 5972 Builder.defineMacro("mips"); 5973 5974 Builder.defineMacro("__REGISTER_PREFIX__", ""); 5975 5976 switch (FloatABI) { 5977 case HardFloat: 5978 Builder.defineMacro("__mips_hard_float", Twine(1)); 5979 break; 5980 case SoftFloat: 5981 Builder.defineMacro("__mips_soft_float", Twine(1)); 5982 break; 5983 } 5984 5985 if (IsSingleFloat) 5986 Builder.defineMacro("__mips_single_float", Twine(1)); 5987 5988 Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32)); 5989 Builder.defineMacro("_MIPS_FPSET", 5990 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2))); 5991 5992 if (IsMips16) 5993 Builder.defineMacro("__mips16", Twine(1)); 5994 5995 if (IsMicromips) 5996 Builder.defineMacro("__mips_micromips", Twine(1)); 5997 5998 if (IsNan2008) 5999 Builder.defineMacro("__mips_nan2008", Twine(1)); 6000 6001 switch (DspRev) { 6002 default: 6003 break; 6004 case DSP1: 6005 Builder.defineMacro("__mips_dsp_rev", Twine(1)); 6006 Builder.defineMacro("__mips_dsp", Twine(1)); 6007 break; 6008 case DSP2: 6009 Builder.defineMacro("__mips_dsp_rev", Twine(2)); 6010 Builder.defineMacro("__mips_dspr2", Twine(1)); 6011 Builder.defineMacro("__mips_dsp", Twine(1)); 6012 break; 6013 } 6014 6015 if (HasMSA) 6016 Builder.defineMacro("__mips_msa", Twine(1)); 6017 6018 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0))); 6019 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth())); 6020 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth())); 6021 6022 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\""); 6023 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper()); 6024 } 6025 6026 void getTargetBuiltins(const Builtin::Info *&Records, 6027 unsigned &NumRecords) const override { 6028 Records = BuiltinInfo; 6029 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin; 6030 } 6031 bool hasFeature(StringRef Feature) const override { 6032 return llvm::StringSwitch<bool>(Feature) 6033 .Case("mips", true) 6034 .Case("fp64", HasFP64) 6035 .Default(false); 6036 } 6037 BuiltinVaListKind getBuiltinVaListKind() const override { 6038 return TargetInfo::VoidPtrBuiltinVaList; 6039 } 6040 void getGCCRegNames(const char * const *&Names, 6041 unsigned &NumNames) const override { 6042 static const char *const GCCRegNames[] = { 6043 // CPU register names 6044 // Must match second column of GCCRegAliases 6045 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7", 6046 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", 6047 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23", 6048 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31", 6049 // Floating point register names 6050 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", 6051 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15", 6052 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23", 6053 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31", 6054 // Hi/lo and condition register names 6055 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4", 6056 "$fcc5","$fcc6","$fcc7", 6057 // MSA register names 6058 "$w0", "$w1", "$w2", "$w3", "$w4", "$w5", "$w6", "$w7", 6059 "$w8", "$w9", "$w10", "$w11", "$w12", "$w13", "$w14", "$w15", 6060 "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23", 6061 "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31", 6062 // MSA control register names 6063 "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify", 6064 "$msarequest", "$msamap", "$msaunmap" 6065 }; 6066 Names = GCCRegNames; 6067 NumNames = llvm::array_lengthof(GCCRegNames); 6068 } 6069 void getGCCRegAliases(const GCCRegAlias *&Aliases, 6070 unsigned &NumAliases) const override = 0; 6071 bool validateAsmConstraint(const char *&Name, 6072 TargetInfo::ConstraintInfo &Info) const override { 6073 switch (*Name) { 6074 default: 6075 return false; 6076 case 'r': // CPU registers. 6077 case 'd': // Equivalent to "r" unless generating MIPS16 code. 6078 case 'y': // Equivalent to "r", backward compatibility only. 6079 case 'f': // floating-point registers. 6080 case 'c': // $25 for indirect jumps 6081 case 'l': // lo register 6082 case 'x': // hilo register pair 6083 Info.setAllowsRegister(); 6084 return true; 6085 case 'I': // Signed 16-bit constant 6086 case 'J': // Integer 0 6087 case 'K': // Unsigned 16-bit constant 6088 case 'L': // Signed 32-bit constant, lower 16-bit zeros (for lui) 6089 case 'M': // Constants not loadable via lui, addiu, or ori 6090 case 'N': // Constant -1 to -65535 6091 case 'O': // A signed 15-bit constant 6092 case 'P': // A constant between 1 go 65535 6093 return true; 6094 case 'R': // An address that can be used in a non-macro load or store 6095 Info.setAllowsMemory(); 6096 return true; 6097 case 'Z': 6098 if (Name[1] == 'C') { // An address usable by ll, and sc. 6099 Info.setAllowsMemory(); 6100 Name++; // Skip over 'Z'. 6101 return true; 6102 } 6103 return false; 6104 } 6105 } 6106 6107 std::string convertConstraint(const char *&Constraint) const override { 6108 std::string R; 6109 switch (*Constraint) { 6110 case 'Z': // Two-character constraint; add "^" hint for later parsing. 6111 if (Constraint[1] == 'C') { 6112 R = std::string("^") + std::string(Constraint, 2); 6113 Constraint++; 6114 return R; 6115 } 6116 break; 6117 } 6118 return TargetInfo::convertConstraint(Constraint); 6119 } 6120 6121 const char *getClobbers() const override { 6122 // In GCC, $1 is not widely used in generated code (it's used only in a few 6123 // specific situations), so there is no real need for users to add it to 6124 // the clobbers list if they want to use it in their inline assembly code. 6125 // 6126 // In LLVM, $1 is treated as a normal GPR and is always allocatable during 6127 // code generation, so using it in inline assembly without adding it to the 6128 // clobbers list can cause conflicts between the inline assembly code and 6129 // the surrounding generated code. 6130 // 6131 // Another problem is that LLVM is allowed to choose $1 for inline assembly 6132 // operands, which will conflict with the ".set at" assembler option (which 6133 // we use only for inline assembly, in order to maintain compatibility with 6134 // GCC) and will also conflict with the user's usage of $1. 6135 // 6136 // The easiest way to avoid these conflicts and keep $1 as an allocatable 6137 // register for generated code is to automatically clobber $1 for all inline 6138 // assembly code. 6139 // 6140 // FIXME: We should automatically clobber $1 only for inline assembly code 6141 // which actually uses it. This would allow LLVM to use $1 for inline 6142 // assembly operands if the user's assembly code doesn't use it. 6143 return "~{$1}"; 6144 } 6145 6146 bool handleTargetFeatures(std::vector<std::string> &Features, 6147 DiagnosticsEngine &Diags) override { 6148 IsMips16 = false; 6149 IsMicromips = false; 6150 IsNan2008 = isNaN2008Default(); 6151 IsSingleFloat = false; 6152 FloatABI = HardFloat; 6153 DspRev = NoDSP; 6154 HasFP64 = isFP64Default(); 6155 6156 for (std::vector<std::string>::iterator it = Features.begin(), 6157 ie = Features.end(); it != ie; ++it) { 6158 if (*it == "+single-float") 6159 IsSingleFloat = true; 6160 else if (*it == "+soft-float") 6161 FloatABI = SoftFloat; 6162 else if (*it == "+mips16") 6163 IsMips16 = true; 6164 else if (*it == "+micromips") 6165 IsMicromips = true; 6166 else if (*it == "+dsp") 6167 DspRev = std::max(DspRev, DSP1); 6168 else if (*it == "+dspr2") 6169 DspRev = std::max(DspRev, DSP2); 6170 else if (*it == "+msa") 6171 HasMSA = true; 6172 else if (*it == "+fp64") 6173 HasFP64 = true; 6174 else if (*it == "-fp64") 6175 HasFP64 = false; 6176 else if (*it == "+nan2008") 6177 IsNan2008 = true; 6178 else if (*it == "-nan2008") 6179 IsNan2008 = false; 6180 } 6181 6182 setDescriptionString(); 6183 6184 return true; 6185 } 6186 6187 int getEHDataRegisterNumber(unsigned RegNo) const override { 6188 if (RegNo == 0) return 4; 6189 if (RegNo == 1) return 5; 6190 return -1; 6191 } 6192 6193 bool isCLZForZeroUndef() const override { return false; } 6194 }; 6195 6196 const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = { 6197 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 6198 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 6199 ALL_LANGUAGES }, 6200 #include "clang/Basic/BuiltinsMips.def" 6201 }; 6202 6203 class Mips32TargetInfoBase : public MipsTargetInfoBase { 6204 public: 6205 Mips32TargetInfoBase(const llvm::Triple &Triple) 6206 : MipsTargetInfoBase(Triple, "o32", "mips32r2") { 6207 SizeType = UnsignedInt; 6208 PtrDiffType = SignedInt; 6209 Int64Type = SignedLongLong; 6210 IntMaxType = Int64Type; 6211 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32; 6212 } 6213 bool setABI(const std::string &Name) override { 6214 if (Name == "o32" || Name == "eabi") { 6215 ABI = Name; 6216 return true; 6217 } 6218 return false; 6219 } 6220 void getTargetDefines(const LangOptions &Opts, 6221 MacroBuilder &Builder) const override { 6222 MipsTargetInfoBase::getTargetDefines(Opts, Builder); 6223 6224 Builder.defineMacro("__mips", "32"); 6225 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32"); 6226 6227 const std::string& CPUStr = getCPU(); 6228 if (CPUStr == "mips32") 6229 Builder.defineMacro("__mips_isa_rev", "1"); 6230 else if (CPUStr == "mips32r2") 6231 Builder.defineMacro("__mips_isa_rev", "2"); 6232 else if (CPUStr == "mips32r3") 6233 Builder.defineMacro("__mips_isa_rev", "3"); 6234 else if (CPUStr == "mips32r5") 6235 Builder.defineMacro("__mips_isa_rev", "5"); 6236 else if (CPUStr == "mips32r6") 6237 Builder.defineMacro("__mips_isa_rev", "6"); 6238 6239 if (ABI == "o32") { 6240 Builder.defineMacro("__mips_o32"); 6241 Builder.defineMacro("_ABIO32", "1"); 6242 Builder.defineMacro("_MIPS_SIM", "_ABIO32"); 6243 } 6244 else if (ABI == "eabi") 6245 Builder.defineMacro("__mips_eabi"); 6246 else 6247 llvm_unreachable("Invalid ABI for Mips32."); 6248 } 6249 void getGCCRegAliases(const GCCRegAlias *&Aliases, 6250 unsigned &NumAliases) const override { 6251 static const TargetInfo::GCCRegAlias GCCRegAliases[] = { 6252 { { "at" }, "$1" }, 6253 { { "v0" }, "$2" }, 6254 { { "v1" }, "$3" }, 6255 { { "a0" }, "$4" }, 6256 { { "a1" }, "$5" }, 6257 { { "a2" }, "$6" }, 6258 { { "a3" }, "$7" }, 6259 { { "t0" }, "$8" }, 6260 { { "t1" }, "$9" }, 6261 { { "t2" }, "$10" }, 6262 { { "t3" }, "$11" }, 6263 { { "t4" }, "$12" }, 6264 { { "t5" }, "$13" }, 6265 { { "t6" }, "$14" }, 6266 { { "t7" }, "$15" }, 6267 { { "s0" }, "$16" }, 6268 { { "s1" }, "$17" }, 6269 { { "s2" }, "$18" }, 6270 { { "s3" }, "$19" }, 6271 { { "s4" }, "$20" }, 6272 { { "s5" }, "$21" }, 6273 { { "s6" }, "$22" }, 6274 { { "s7" }, "$23" }, 6275 { { "t8" }, "$24" }, 6276 { { "t9" }, "$25" }, 6277 { { "k0" }, "$26" }, 6278 { { "k1" }, "$27" }, 6279 { { "gp" }, "$28" }, 6280 { { "sp","$sp" }, "$29" }, 6281 { { "fp","$fp" }, "$30" }, 6282 { { "ra" }, "$31" } 6283 }; 6284 Aliases = GCCRegAliases; 6285 NumAliases = llvm::array_lengthof(GCCRegAliases); 6286 } 6287 }; 6288 6289 class Mips32EBTargetInfo : public Mips32TargetInfoBase { 6290 void setDescriptionString() override { 6291 DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"; 6292 } 6293 6294 public: 6295 Mips32EBTargetInfo(const llvm::Triple &Triple) 6296 : Mips32TargetInfoBase(Triple) { 6297 } 6298 void getTargetDefines(const LangOptions &Opts, 6299 MacroBuilder &Builder) const override { 6300 DefineStd(Builder, "MIPSEB", Opts); 6301 Builder.defineMacro("_MIPSEB"); 6302 Mips32TargetInfoBase::getTargetDefines(Opts, Builder); 6303 } 6304 }; 6305 6306 class Mips32ELTargetInfo : public Mips32TargetInfoBase { 6307 void setDescriptionString() override { 6308 DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"; 6309 } 6310 6311 public: 6312 Mips32ELTargetInfo(const llvm::Triple &Triple) 6313 : Mips32TargetInfoBase(Triple) { 6314 BigEndian = false; 6315 } 6316 void getTargetDefines(const LangOptions &Opts, 6317 MacroBuilder &Builder) const override { 6318 DefineStd(Builder, "MIPSEL", Opts); 6319 Builder.defineMacro("_MIPSEL"); 6320 Mips32TargetInfoBase::getTargetDefines(Opts, Builder); 6321 } 6322 }; 6323 6324 class Mips64TargetInfoBase : public MipsTargetInfoBase { 6325 public: 6326 Mips64TargetInfoBase(const llvm::Triple &Triple) 6327 : MipsTargetInfoBase(Triple, "n64", "mips64r2") { 6328 LongDoubleWidth = LongDoubleAlign = 128; 6329 LongDoubleFormat = &llvm::APFloat::IEEEquad; 6330 if (getTriple().getOS() == llvm::Triple::FreeBSD) { 6331 LongDoubleWidth = LongDoubleAlign = 64; 6332 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 6333 } 6334 setN64ABITypes(); 6335 SuitableAlign = 128; 6336 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 6337 } 6338 6339 void setN64ABITypes() { 6340 LongWidth = LongAlign = 64; 6341 PointerWidth = PointerAlign = 64; 6342 SizeType = UnsignedLong; 6343 PtrDiffType = SignedLong; 6344 Int64Type = SignedLong; 6345 IntMaxType = Int64Type; 6346 } 6347 6348 void setN32ABITypes() { 6349 LongWidth = LongAlign = 32; 6350 PointerWidth = PointerAlign = 32; 6351 SizeType = UnsignedInt; 6352 PtrDiffType = SignedInt; 6353 Int64Type = SignedLongLong; 6354 IntMaxType = Int64Type; 6355 } 6356 6357 bool setABI(const std::string &Name) override { 6358 if (Name == "n32") { 6359 setN32ABITypes(); 6360 ABI = Name; 6361 return true; 6362 } 6363 if (Name == "n64") { 6364 setN64ABITypes(); 6365 ABI = Name; 6366 return true; 6367 } 6368 return false; 6369 } 6370 6371 void getTargetDefines(const LangOptions &Opts, 6372 MacroBuilder &Builder) const override { 6373 MipsTargetInfoBase::getTargetDefines(Opts, Builder); 6374 6375 Builder.defineMacro("__mips", "64"); 6376 Builder.defineMacro("__mips64"); 6377 Builder.defineMacro("__mips64__"); 6378 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64"); 6379 6380 const std::string& CPUStr = getCPU(); 6381 if (CPUStr == "mips64") 6382 Builder.defineMacro("__mips_isa_rev", "1"); 6383 else if (CPUStr == "mips64r2") 6384 Builder.defineMacro("__mips_isa_rev", "2"); 6385 else if (CPUStr == "mips64r3") 6386 Builder.defineMacro("__mips_isa_rev", "3"); 6387 else if (CPUStr == "mips64r5") 6388 Builder.defineMacro("__mips_isa_rev", "5"); 6389 else if (CPUStr == "mips64r6") 6390 Builder.defineMacro("__mips_isa_rev", "6"); 6391 6392 if (ABI == "n32") { 6393 Builder.defineMacro("__mips_n32"); 6394 Builder.defineMacro("_ABIN32", "2"); 6395 Builder.defineMacro("_MIPS_SIM", "_ABIN32"); 6396 } 6397 else if (ABI == "n64") { 6398 Builder.defineMacro("__mips_n64"); 6399 Builder.defineMacro("_ABI64", "3"); 6400 Builder.defineMacro("_MIPS_SIM", "_ABI64"); 6401 } 6402 else 6403 llvm_unreachable("Invalid ABI for Mips64."); 6404 } 6405 void getGCCRegAliases(const GCCRegAlias *&Aliases, 6406 unsigned &NumAliases) const override { 6407 static const TargetInfo::GCCRegAlias GCCRegAliases[] = { 6408 { { "at" }, "$1" }, 6409 { { "v0" }, "$2" }, 6410 { { "v1" }, "$3" }, 6411 { { "a0" }, "$4" }, 6412 { { "a1" }, "$5" }, 6413 { { "a2" }, "$6" }, 6414 { { "a3" }, "$7" }, 6415 { { "a4" }, "$8" }, 6416 { { "a5" }, "$9" }, 6417 { { "a6" }, "$10" }, 6418 { { "a7" }, "$11" }, 6419 { { "t0" }, "$12" }, 6420 { { "t1" }, "$13" }, 6421 { { "t2" }, "$14" }, 6422 { { "t3" }, "$15" }, 6423 { { "s0" }, "$16" }, 6424 { { "s1" }, "$17" }, 6425 { { "s2" }, "$18" }, 6426 { { "s3" }, "$19" }, 6427 { { "s4" }, "$20" }, 6428 { { "s5" }, "$21" }, 6429 { { "s6" }, "$22" }, 6430 { { "s7" }, "$23" }, 6431 { { "t8" }, "$24" }, 6432 { { "t9" }, "$25" }, 6433 { { "k0" }, "$26" }, 6434 { { "k1" }, "$27" }, 6435 { { "gp" }, "$28" }, 6436 { { "sp","$sp" }, "$29" }, 6437 { { "fp","$fp" }, "$30" }, 6438 { { "ra" }, "$31" } 6439 }; 6440 Aliases = GCCRegAliases; 6441 NumAliases = llvm::array_lengthof(GCCRegAliases); 6442 } 6443 6444 bool hasInt128Type() const override { return true; } 6445 }; 6446 6447 class Mips64EBTargetInfo : public Mips64TargetInfoBase { 6448 void setDescriptionString() override { 6449 if (ABI == "n32") 6450 DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128"; 6451 else 6452 DescriptionString = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128"; 6453 6454 } 6455 6456 public: 6457 Mips64EBTargetInfo(const llvm::Triple &Triple) 6458 : Mips64TargetInfoBase(Triple) {} 6459 void getTargetDefines(const LangOptions &Opts, 6460 MacroBuilder &Builder) const override { 6461 DefineStd(Builder, "MIPSEB", Opts); 6462 Builder.defineMacro("_MIPSEB"); 6463 Mips64TargetInfoBase::getTargetDefines(Opts, Builder); 6464 } 6465 }; 6466 6467 class Mips64ELTargetInfo : public Mips64TargetInfoBase { 6468 void setDescriptionString() override { 6469 if (ABI == "n32") 6470 DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128"; 6471 else 6472 DescriptionString = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128"; 6473 } 6474 public: 6475 Mips64ELTargetInfo(const llvm::Triple &Triple) 6476 : Mips64TargetInfoBase(Triple) { 6477 // Default ABI is n64. 6478 BigEndian = false; 6479 } 6480 void getTargetDefines(const LangOptions &Opts, 6481 MacroBuilder &Builder) const override { 6482 DefineStd(Builder, "MIPSEL", Opts); 6483 Builder.defineMacro("_MIPSEL"); 6484 Mips64TargetInfoBase::getTargetDefines(Opts, Builder); 6485 } 6486 }; 6487 6488 class PNaClTargetInfo : public TargetInfo { 6489 public: 6490 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 6491 BigEndian = false; 6492 this->UserLabelPrefix = ""; 6493 this->LongAlign = 32; 6494 this->LongWidth = 32; 6495 this->PointerAlign = 32; 6496 this->PointerWidth = 32; 6497 this->IntMaxType = TargetInfo::SignedLongLong; 6498 this->Int64Type = TargetInfo::SignedLongLong; 6499 this->DoubleAlign = 64; 6500 this->LongDoubleWidth = 64; 6501 this->LongDoubleAlign = 64; 6502 this->SizeType = TargetInfo::UnsignedInt; 6503 this->PtrDiffType = TargetInfo::SignedInt; 6504 this->IntPtrType = TargetInfo::SignedInt; 6505 this->RegParmMax = 0; // Disallow regparm 6506 } 6507 6508 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override { 6509 } 6510 void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const { 6511 Builder.defineMacro("__le32__"); 6512 Builder.defineMacro("__pnacl__"); 6513 } 6514 void getTargetDefines(const LangOptions &Opts, 6515 MacroBuilder &Builder) const override { 6516 getArchDefines(Opts, Builder); 6517 } 6518 bool hasFeature(StringRef Feature) const override { 6519 return Feature == "pnacl"; 6520 } 6521 void getTargetBuiltins(const Builtin::Info *&Records, 6522 unsigned &NumRecords) const override { 6523 } 6524 BuiltinVaListKind getBuiltinVaListKind() const override { 6525 return TargetInfo::PNaClABIBuiltinVaList; 6526 } 6527 void getGCCRegNames(const char * const *&Names, 6528 unsigned &NumNames) const override; 6529 void getGCCRegAliases(const GCCRegAlias *&Aliases, 6530 unsigned &NumAliases) const override; 6531 bool validateAsmConstraint(const char *&Name, 6532 TargetInfo::ConstraintInfo &Info) const override { 6533 return false; 6534 } 6535 6536 const char *getClobbers() const override { 6537 return ""; 6538 } 6539 }; 6540 6541 void PNaClTargetInfo::getGCCRegNames(const char * const *&Names, 6542 unsigned &NumNames) const { 6543 Names = nullptr; 6544 NumNames = 0; 6545 } 6546 6547 void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 6548 unsigned &NumAliases) const { 6549 Aliases = nullptr; 6550 NumAliases = 0; 6551 } 6552 6553 class Le64TargetInfo : public TargetInfo { 6554 static const Builtin::Info BuiltinInfo[]; 6555 6556 public: 6557 Le64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 6558 BigEndian = false; 6559 NoAsmVariants = true; 6560 LongWidth = LongAlign = PointerWidth = PointerAlign = 64; 6561 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 6562 DescriptionString = 6563 "e-m:e-v128:32-v16:16-v32:32-v96:32-n8:16:32:64-S128"; 6564 } 6565 6566 void getTargetDefines(const LangOptions &Opts, 6567 MacroBuilder &Builder) const override { 6568 DefineStd(Builder, "unix", Opts); 6569 defineCPUMacros(Builder, "le64", /*Tuning=*/false); 6570 Builder.defineMacro("__ELF__"); 6571 } 6572 void getTargetBuiltins(const Builtin::Info *&Records, 6573 unsigned &NumRecords) const override { 6574 Records = BuiltinInfo; 6575 NumRecords = clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin; 6576 } 6577 BuiltinVaListKind getBuiltinVaListKind() const override { 6578 return TargetInfo::PNaClABIBuiltinVaList; 6579 } 6580 const char *getClobbers() const override { return ""; } 6581 void getGCCRegNames(const char *const *&Names, 6582 unsigned &NumNames) const override { 6583 Names = nullptr; 6584 NumNames = 0; 6585 } 6586 void getGCCRegAliases(const GCCRegAlias *&Aliases, 6587 unsigned &NumAliases) const override { 6588 Aliases = nullptr; 6589 NumAliases = 0; 6590 } 6591 bool validateAsmConstraint(const char *&Name, 6592 TargetInfo::ConstraintInfo &Info) const override { 6593 return false; 6594 } 6595 6596 bool hasProtectedVisibility() const override { return false; } 6597 }; 6598 } // end anonymous namespace. 6599 6600 const Builtin::Info Le64TargetInfo::BuiltinInfo[] = { 6601 #define BUILTIN(ID, TYPE, ATTRS) \ 6602 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 6603 #include "clang/Basic/BuiltinsLe64.def" 6604 }; 6605 6606 namespace { 6607 static const unsigned SPIRAddrSpaceMap[] = { 6608 1, // opencl_global 6609 3, // opencl_local 6610 2, // opencl_constant 6611 4, // opencl_generic 6612 0, // cuda_device 6613 0, // cuda_constant 6614 0 // cuda_shared 6615 }; 6616 class SPIRTargetInfo : public TargetInfo { 6617 public: 6618 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 6619 assert(getTriple().getOS() == llvm::Triple::UnknownOS && 6620 "SPIR target must use unknown OS"); 6621 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment && 6622 "SPIR target must use unknown environment type"); 6623 BigEndian = false; 6624 TLSSupported = false; 6625 LongWidth = LongAlign = 64; 6626 AddrSpaceMap = &SPIRAddrSpaceMap; 6627 UseAddrSpaceMapMangling = true; 6628 // Define available target features 6629 // These must be defined in sorted order! 6630 NoAsmVariants = true; 6631 } 6632 void getTargetDefines(const LangOptions &Opts, 6633 MacroBuilder &Builder) const override { 6634 DefineStd(Builder, "SPIR", Opts); 6635 } 6636 bool hasFeature(StringRef Feature) const override { 6637 return Feature == "spir"; 6638 } 6639 6640 void getTargetBuiltins(const Builtin::Info *&Records, 6641 unsigned &NumRecords) const override {} 6642 const char *getClobbers() const override { 6643 return ""; 6644 } 6645 void getGCCRegNames(const char * const *&Names, 6646 unsigned &NumNames) const override {} 6647 bool 6648 validateAsmConstraint(const char *&Name, 6649 TargetInfo::ConstraintInfo &info) const override { 6650 return true; 6651 } 6652 void getGCCRegAliases(const GCCRegAlias *&Aliases, 6653 unsigned &NumAliases) const override {} 6654 BuiltinVaListKind getBuiltinVaListKind() const override { 6655 return TargetInfo::VoidPtrBuiltinVaList; 6656 } 6657 6658 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override { 6659 return (CC == CC_SpirFunction || 6660 CC == CC_SpirKernel) ? CCCR_OK : CCCR_Warning; 6661 } 6662 6663 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override { 6664 return CC_SpirFunction; 6665 } 6666 }; 6667 6668 6669 class SPIR32TargetInfo : public SPIRTargetInfo { 6670 public: 6671 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) { 6672 PointerWidth = PointerAlign = 32; 6673 SizeType = TargetInfo::UnsignedInt; 6674 PtrDiffType = IntPtrType = TargetInfo::SignedInt; 6675 DescriptionString 6676 = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-" 6677 "v96:128-v192:256-v256:256-v512:512-v1024:1024"; 6678 } 6679 void getTargetDefines(const LangOptions &Opts, 6680 MacroBuilder &Builder) const override { 6681 DefineStd(Builder, "SPIR32", Opts); 6682 } 6683 }; 6684 6685 class SPIR64TargetInfo : public SPIRTargetInfo { 6686 public: 6687 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) { 6688 PointerWidth = PointerAlign = 64; 6689 SizeType = TargetInfo::UnsignedLong; 6690 PtrDiffType = IntPtrType = TargetInfo::SignedLong; 6691 DescriptionString = "e-i64:64-v16:16-v24:32-v32:32-v48:64-" 6692 "v96:128-v192:256-v256:256-v512:512-v1024:1024"; 6693 } 6694 void getTargetDefines(const LangOptions &Opts, 6695 MacroBuilder &Builder) const override { 6696 DefineStd(Builder, "SPIR64", Opts); 6697 } 6698 }; 6699 6700 class XCoreTargetInfo : public TargetInfo { 6701 static const Builtin::Info BuiltinInfo[]; 6702 public: 6703 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) { 6704 BigEndian = false; 6705 NoAsmVariants = true; 6706 LongLongAlign = 32; 6707 SuitableAlign = 32; 6708 DoubleAlign = LongDoubleAlign = 32; 6709 SizeType = UnsignedInt; 6710 PtrDiffType = SignedInt; 6711 IntPtrType = SignedInt; 6712 WCharType = UnsignedChar; 6713 WIntType = UnsignedInt; 6714 UseZeroLengthBitfieldAlignment = true; 6715 DescriptionString = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32" 6716 "-f64:32-a:0:32-n32"; 6717 } 6718 void getTargetDefines(const LangOptions &Opts, 6719 MacroBuilder &Builder) const override { 6720 Builder.defineMacro("__XS1B__"); 6721 } 6722 void getTargetBuiltins(const Builtin::Info *&Records, 6723 unsigned &NumRecords) const override { 6724 Records = BuiltinInfo; 6725 NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin; 6726 } 6727 BuiltinVaListKind getBuiltinVaListKind() const override { 6728 return TargetInfo::VoidPtrBuiltinVaList; 6729 } 6730 const char *getClobbers() const override { 6731 return ""; 6732 } 6733 void getGCCRegNames(const char * const *&Names, 6734 unsigned &NumNames) const override { 6735 static const char * const GCCRegNames[] = { 6736 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 6737 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr" 6738 }; 6739 Names = GCCRegNames; 6740 NumNames = llvm::array_lengthof(GCCRegNames); 6741 } 6742 void getGCCRegAliases(const GCCRegAlias *&Aliases, 6743 unsigned &NumAliases) const override { 6744 Aliases = nullptr; 6745 NumAliases = 0; 6746 } 6747 bool validateAsmConstraint(const char *&Name, 6748 TargetInfo::ConstraintInfo &Info) const override { 6749 return false; 6750 } 6751 int getEHDataRegisterNumber(unsigned RegNo) const override { 6752 // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister 6753 return (RegNo < 2)? RegNo : -1; 6754 } 6755 }; 6756 6757 const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = { 6758 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 6759 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 6760 ALL_LANGUAGES }, 6761 #include "clang/Basic/BuiltinsXCore.def" 6762 }; 6763 } // end anonymous namespace. 6764 6765 namespace { 6766 // x86_32 Android target 6767 class AndroidX86_32TargetInfo : public LinuxTargetInfo<X86_32TargetInfo> { 6768 public: 6769 AndroidX86_32TargetInfo(const llvm::Triple &Triple) 6770 : LinuxTargetInfo<X86_32TargetInfo>(Triple) { 6771 SuitableAlign = 32; 6772 LongDoubleWidth = 64; 6773 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 6774 } 6775 }; 6776 } // end anonymous namespace 6777 6778 namespace { 6779 // x86_64 Android target 6780 class AndroidX86_64TargetInfo : public LinuxTargetInfo<X86_64TargetInfo> { 6781 public: 6782 AndroidX86_64TargetInfo(const llvm::Triple &Triple) 6783 : LinuxTargetInfo<X86_64TargetInfo>(Triple) { 6784 LongDoubleFormat = &llvm::APFloat::IEEEquad; 6785 } 6786 }; 6787 } // end anonymous namespace 6788 6789 6790 //===----------------------------------------------------------------------===// 6791 // Driver code 6792 //===----------------------------------------------------------------------===// 6793 6794 static TargetInfo *AllocateTarget(const llvm::Triple &Triple) { 6795 llvm::Triple::OSType os = Triple.getOS(); 6796 6797 switch (Triple.getArch()) { 6798 default: 6799 return nullptr; 6800 6801 case llvm::Triple::xcore: 6802 return new XCoreTargetInfo(Triple); 6803 6804 case llvm::Triple::hexagon: 6805 return new HexagonTargetInfo(Triple); 6806 6807 case llvm::Triple::aarch64: 6808 if (Triple.isOSDarwin()) 6809 return new DarwinAArch64TargetInfo(Triple); 6810 6811 switch (os) { 6812 case llvm::Triple::FreeBSD: 6813 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple); 6814 case llvm::Triple::Linux: 6815 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple); 6816 case llvm::Triple::NetBSD: 6817 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple); 6818 default: 6819 return new AArch64leTargetInfo(Triple); 6820 } 6821 6822 case llvm::Triple::aarch64_be: 6823 switch (os) { 6824 case llvm::Triple::FreeBSD: 6825 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple); 6826 case llvm::Triple::Linux: 6827 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple); 6828 case llvm::Triple::NetBSD: 6829 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple); 6830 default: 6831 return new AArch64beTargetInfo(Triple); 6832 } 6833 6834 case llvm::Triple::arm: 6835 case llvm::Triple::thumb: 6836 if (Triple.isOSBinFormatMachO()) 6837 return new DarwinARMTargetInfo(Triple); 6838 6839 switch (os) { 6840 case llvm::Triple::Linux: 6841 return new LinuxTargetInfo<ARMleTargetInfo>(Triple); 6842 case llvm::Triple::FreeBSD: 6843 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple); 6844 case llvm::Triple::NetBSD: 6845 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple); 6846 case llvm::Triple::OpenBSD: 6847 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple); 6848 case llvm::Triple::Bitrig: 6849 return new BitrigTargetInfo<ARMleTargetInfo>(Triple); 6850 case llvm::Triple::RTEMS: 6851 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple); 6852 case llvm::Triple::NaCl: 6853 return new NaClTargetInfo<ARMleTargetInfo>(Triple); 6854 case llvm::Triple::Win32: 6855 switch (Triple.getEnvironment()) { 6856 default: 6857 return new ARMleTargetInfo(Triple); 6858 case llvm::Triple::Itanium: 6859 return new ItaniumWindowsARMleTargetInfo(Triple); 6860 case llvm::Triple::MSVC: 6861 return new MicrosoftARMleTargetInfo(Triple); 6862 } 6863 default: 6864 return new ARMleTargetInfo(Triple); 6865 } 6866 6867 case llvm::Triple::armeb: 6868 case llvm::Triple::thumbeb: 6869 if (Triple.isOSDarwin()) 6870 return new DarwinARMTargetInfo(Triple); 6871 6872 switch (os) { 6873 case llvm::Triple::Linux: 6874 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple); 6875 case llvm::Triple::FreeBSD: 6876 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple); 6877 case llvm::Triple::NetBSD: 6878 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple); 6879 case llvm::Triple::OpenBSD: 6880 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple); 6881 case llvm::Triple::Bitrig: 6882 return new BitrigTargetInfo<ARMbeTargetInfo>(Triple); 6883 case llvm::Triple::RTEMS: 6884 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple); 6885 case llvm::Triple::NaCl: 6886 return new NaClTargetInfo<ARMbeTargetInfo>(Triple); 6887 default: 6888 return new ARMbeTargetInfo(Triple); 6889 } 6890 6891 case llvm::Triple::msp430: 6892 return new MSP430TargetInfo(Triple); 6893 6894 case llvm::Triple::mips: 6895 switch (os) { 6896 case llvm::Triple::Linux: 6897 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple); 6898 case llvm::Triple::RTEMS: 6899 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple); 6900 case llvm::Triple::FreeBSD: 6901 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple); 6902 case llvm::Triple::NetBSD: 6903 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple); 6904 default: 6905 return new Mips32EBTargetInfo(Triple); 6906 } 6907 6908 case llvm::Triple::mipsel: 6909 switch (os) { 6910 case llvm::Triple::Linux: 6911 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple); 6912 case llvm::Triple::RTEMS: 6913 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple); 6914 case llvm::Triple::FreeBSD: 6915 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple); 6916 case llvm::Triple::NetBSD: 6917 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple); 6918 case llvm::Triple::NaCl: 6919 return new NaClTargetInfo<Mips32ELTargetInfo>(Triple); 6920 default: 6921 return new Mips32ELTargetInfo(Triple); 6922 } 6923 6924 case llvm::Triple::mips64: 6925 switch (os) { 6926 case llvm::Triple::Linux: 6927 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple); 6928 case llvm::Triple::RTEMS: 6929 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple); 6930 case llvm::Triple::FreeBSD: 6931 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple); 6932 case llvm::Triple::NetBSD: 6933 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple); 6934 case llvm::Triple::OpenBSD: 6935 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple); 6936 default: 6937 return new Mips64EBTargetInfo(Triple); 6938 } 6939 6940 case llvm::Triple::mips64el: 6941 switch (os) { 6942 case llvm::Triple::Linux: 6943 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple); 6944 case llvm::Triple::RTEMS: 6945 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple); 6946 case llvm::Triple::FreeBSD: 6947 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple); 6948 case llvm::Triple::NetBSD: 6949 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple); 6950 case llvm::Triple::OpenBSD: 6951 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple); 6952 default: 6953 return new Mips64ELTargetInfo(Triple); 6954 } 6955 6956 case llvm::Triple::le32: 6957 switch (os) { 6958 case llvm::Triple::NaCl: 6959 return new NaClTargetInfo<PNaClTargetInfo>(Triple); 6960 default: 6961 return nullptr; 6962 } 6963 6964 case llvm::Triple::le64: 6965 return new Le64TargetInfo(Triple); 6966 6967 case llvm::Triple::ppc: 6968 if (Triple.isOSDarwin()) 6969 return new DarwinPPC32TargetInfo(Triple); 6970 switch (os) { 6971 case llvm::Triple::Linux: 6972 return new LinuxTargetInfo<PPC32TargetInfo>(Triple); 6973 case llvm::Triple::FreeBSD: 6974 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple); 6975 case llvm::Triple::NetBSD: 6976 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple); 6977 case llvm::Triple::OpenBSD: 6978 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple); 6979 case llvm::Triple::RTEMS: 6980 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple); 6981 default: 6982 return new PPC32TargetInfo(Triple); 6983 } 6984 6985 case llvm::Triple::ppc64: 6986 if (Triple.isOSDarwin()) 6987 return new DarwinPPC64TargetInfo(Triple); 6988 switch (os) { 6989 case llvm::Triple::Linux: 6990 return new LinuxTargetInfo<PPC64TargetInfo>(Triple); 6991 case llvm::Triple::Lv2: 6992 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple); 6993 case llvm::Triple::FreeBSD: 6994 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple); 6995 case llvm::Triple::NetBSD: 6996 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple); 6997 default: 6998 return new PPC64TargetInfo(Triple); 6999 } 7000 7001 case llvm::Triple::ppc64le: 7002 switch (os) { 7003 case llvm::Triple::Linux: 7004 return new LinuxTargetInfo<PPC64TargetInfo>(Triple); 7005 case llvm::Triple::NetBSD: 7006 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple); 7007 default: 7008 return new PPC64TargetInfo(Triple); 7009 } 7010 7011 case llvm::Triple::nvptx: 7012 return new NVPTX32TargetInfo(Triple); 7013 case llvm::Triple::nvptx64: 7014 return new NVPTX64TargetInfo(Triple); 7015 7016 case llvm::Triple::amdgcn: 7017 case llvm::Triple::r600: 7018 return new R600TargetInfo(Triple); 7019 7020 case llvm::Triple::sparc: 7021 switch (os) { 7022 case llvm::Triple::Linux: 7023 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple); 7024 case llvm::Triple::Solaris: 7025 return new SolarisSparcV8TargetInfo(Triple); 7026 case llvm::Triple::NetBSD: 7027 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple); 7028 case llvm::Triple::OpenBSD: 7029 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple); 7030 case llvm::Triple::RTEMS: 7031 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple); 7032 default: 7033 return new SparcV8TargetInfo(Triple); 7034 } 7035 7036 // The 'sparcel' architecture copies all the above cases except for Solaris. 7037 case llvm::Triple::sparcel: 7038 switch (os) { 7039 case llvm::Triple::Linux: 7040 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple); 7041 case llvm::Triple::NetBSD: 7042 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple); 7043 case llvm::Triple::OpenBSD: 7044 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple); 7045 case llvm::Triple::RTEMS: 7046 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple); 7047 default: 7048 return new SparcV8elTargetInfo(Triple); 7049 } 7050 7051 case llvm::Triple::sparcv9: 7052 switch (os) { 7053 case llvm::Triple::Linux: 7054 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple); 7055 case llvm::Triple::Solaris: 7056 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple); 7057 case llvm::Triple::NetBSD: 7058 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple); 7059 case llvm::Triple::OpenBSD: 7060 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple); 7061 case llvm::Triple::FreeBSD: 7062 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple); 7063 default: 7064 return new SparcV9TargetInfo(Triple); 7065 } 7066 7067 case llvm::Triple::systemz: 7068 switch (os) { 7069 case llvm::Triple::Linux: 7070 return new LinuxTargetInfo<SystemZTargetInfo>(Triple); 7071 default: 7072 return new SystemZTargetInfo(Triple); 7073 } 7074 7075 case llvm::Triple::tce: 7076 return new TCETargetInfo(Triple); 7077 7078 case llvm::Triple::x86: 7079 if (Triple.isOSDarwin()) 7080 return new DarwinI386TargetInfo(Triple); 7081 7082 switch (os) { 7083 case llvm::Triple::Linux: { 7084 switch (Triple.getEnvironment()) { 7085 default: 7086 return new LinuxTargetInfo<X86_32TargetInfo>(Triple); 7087 case llvm::Triple::Android: 7088 return new AndroidX86_32TargetInfo(Triple); 7089 } 7090 } 7091 case llvm::Triple::DragonFly: 7092 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple); 7093 case llvm::Triple::NetBSD: 7094 return new NetBSDI386TargetInfo(Triple); 7095 case llvm::Triple::OpenBSD: 7096 return new OpenBSDI386TargetInfo(Triple); 7097 case llvm::Triple::Bitrig: 7098 return new BitrigI386TargetInfo(Triple); 7099 case llvm::Triple::FreeBSD: 7100 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple); 7101 case llvm::Triple::KFreeBSD: 7102 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple); 7103 case llvm::Triple::Minix: 7104 return new MinixTargetInfo<X86_32TargetInfo>(Triple); 7105 case llvm::Triple::Solaris: 7106 return new SolarisTargetInfo<X86_32TargetInfo>(Triple); 7107 case llvm::Triple::Win32: { 7108 switch (Triple.getEnvironment()) { 7109 default: 7110 return new X86_32TargetInfo(Triple); 7111 case llvm::Triple::Cygnus: 7112 return new CygwinX86_32TargetInfo(Triple); 7113 case llvm::Triple::GNU: 7114 return new MinGWX86_32TargetInfo(Triple); 7115 case llvm::Triple::Itanium: 7116 case llvm::Triple::MSVC: 7117 return new MicrosoftX86_32TargetInfo(Triple); 7118 } 7119 } 7120 case llvm::Triple::Haiku: 7121 return new HaikuX86_32TargetInfo(Triple); 7122 case llvm::Triple::RTEMS: 7123 return new RTEMSX86_32TargetInfo(Triple); 7124 case llvm::Triple::NaCl: 7125 return new NaClTargetInfo<X86_32TargetInfo>(Triple); 7126 default: 7127 return new X86_32TargetInfo(Triple); 7128 } 7129 7130 case llvm::Triple::x86_64: 7131 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()) 7132 return new DarwinX86_64TargetInfo(Triple); 7133 7134 switch (os) { 7135 case llvm::Triple::CloudABI: 7136 return new CloudABITargetInfo<X86_64TargetInfo>(Triple); 7137 case llvm::Triple::Linux: { 7138 switch (Triple.getEnvironment()) { 7139 default: 7140 return new LinuxTargetInfo<X86_64TargetInfo>(Triple); 7141 case llvm::Triple::Android: 7142 return new AndroidX86_64TargetInfo(Triple); 7143 } 7144 } 7145 case llvm::Triple::DragonFly: 7146 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple); 7147 case llvm::Triple::NetBSD: 7148 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple); 7149 case llvm::Triple::OpenBSD: 7150 return new OpenBSDX86_64TargetInfo(Triple); 7151 case llvm::Triple::Bitrig: 7152 return new BitrigX86_64TargetInfo(Triple); 7153 case llvm::Triple::FreeBSD: 7154 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple); 7155 case llvm::Triple::KFreeBSD: 7156 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple); 7157 case llvm::Triple::Solaris: 7158 return new SolarisTargetInfo<X86_64TargetInfo>(Triple); 7159 case llvm::Triple::Win32: { 7160 switch (Triple.getEnvironment()) { 7161 default: 7162 return new X86_64TargetInfo(Triple); 7163 case llvm::Triple::GNU: 7164 return new MinGWX86_64TargetInfo(Triple); 7165 case llvm::Triple::MSVC: 7166 return new MicrosoftX86_64TargetInfo(Triple); 7167 } 7168 } 7169 case llvm::Triple::NaCl: 7170 return new NaClTargetInfo<X86_64TargetInfo>(Triple); 7171 case llvm::Triple::PS4: 7172 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple); 7173 default: 7174 return new X86_64TargetInfo(Triple); 7175 } 7176 7177 case llvm::Triple::spir: { 7178 if (Triple.getOS() != llvm::Triple::UnknownOS || 7179 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 7180 return nullptr; 7181 return new SPIR32TargetInfo(Triple); 7182 } 7183 case llvm::Triple::spir64: { 7184 if (Triple.getOS() != llvm::Triple::UnknownOS || 7185 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 7186 return nullptr; 7187 return new SPIR64TargetInfo(Triple); 7188 } 7189 } 7190 } 7191 7192 /// CreateTargetInfo - Return the target info object for the specified target 7193 /// triple. 7194 TargetInfo * 7195 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 7196 const std::shared_ptr<TargetOptions> &Opts) { 7197 llvm::Triple Triple(Opts->Triple); 7198 7199 // Construct the target 7200 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple)); 7201 if (!Target) { 7202 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 7203 return nullptr; 7204 } 7205 Target->TargetOpts = Opts; 7206 7207 // Set the target CPU if specified. 7208 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 7209 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 7210 return nullptr; 7211 } 7212 7213 // Set the target ABI if specified. 7214 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 7215 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 7216 return nullptr; 7217 } 7218 7219 // Set the fp math unit. 7220 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) { 7221 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; 7222 return nullptr; 7223 } 7224 7225 // Compute the default target features, we need the target to handle this 7226 // because features may have dependencies on one another. 7227 llvm::StringMap<bool> Features; 7228 Target->getDefaultFeatures(Features); 7229 7230 // Apply the user specified deltas. 7231 for (unsigned I = 0, N = Opts->FeaturesAsWritten.size(); 7232 I < N; ++I) { 7233 const char *Name = Opts->FeaturesAsWritten[I].c_str(); 7234 // Apply the feature via the target. 7235 bool Enabled = Name[0] == '+'; 7236 Target->setFeatureEnabled(Features, Name + 1, Enabled); 7237 } 7238 7239 // Add the features to the compile options. 7240 // 7241 // FIXME: If we are completely confident that we have the right set, we only 7242 // need to pass the minuses. 7243 Opts->Features.clear(); 7244 for (llvm::StringMap<bool>::const_iterator it = Features.begin(), 7245 ie = Features.end(); it != ie; ++it) 7246 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str()); 7247 if (!Target->handleTargetFeatures(Opts->Features, Diags)) 7248 return nullptr; 7249 7250 return Target.release(); 7251 } 7252