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