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/OwningPtr.h" 24 #include "llvm/ADT/STLExtras.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 using namespace clang; 33 34 //===----------------------------------------------------------------------===// 35 // Common code shared among targets. 36 //===----------------------------------------------------------------------===// 37 38 /// DefineStd - Define a macro name and standard variants. For example if 39 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix" 40 /// when in GNU mode. 41 static void DefineStd(MacroBuilder &Builder, StringRef MacroName, 42 const LangOptions &Opts) { 43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace"); 44 45 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier 46 // in the user's namespace. 47 if (Opts.GNUMode) 48 Builder.defineMacro(MacroName); 49 50 // Define __unix. 51 Builder.defineMacro("__" + MacroName); 52 53 // Define __unix__. 54 Builder.defineMacro("__" + MacroName + "__"); 55 } 56 57 static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, 58 bool Tuning = true) { 59 Builder.defineMacro("__" + CPUName); 60 Builder.defineMacro("__" + CPUName + "__"); 61 if (Tuning) 62 Builder.defineMacro("__tune_" + CPUName + "__"); 63 } 64 65 //===----------------------------------------------------------------------===// 66 // Defines specific to certain operating systems. 67 //===----------------------------------------------------------------------===// 68 69 namespace { 70 template<typename TgtInfo> 71 class OSTargetInfo : public TgtInfo { 72 protected: 73 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 74 MacroBuilder &Builder) const=0; 75 public: 76 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {} 77 virtual void getTargetDefines(const LangOptions &Opts, 78 MacroBuilder &Builder) const { 79 TgtInfo::getTargetDefines(Opts, Builder); 80 getOSDefines(Opts, TgtInfo::getTriple(), Builder); 81 } 82 83 }; 84 } // end anonymous namespace 85 86 87 static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, 88 const llvm::Triple &Triple, 89 StringRef &PlatformName, 90 VersionTuple &PlatformMinVersion) { 91 Builder.defineMacro("__APPLE_CC__", "5621"); 92 Builder.defineMacro("__APPLE__"); 93 Builder.defineMacro("__MACH__"); 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.Address) Builder.defineMacro("_FORTIFY_SOURCE", "0"); 98 99 if (!Opts.ObjCAutoRefCount) { 100 // __weak is always defined, for use in blocks and with objc pointers. 101 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))"); 102 103 // Darwin defines __strong even in C mode (just to nothing). 104 if (Opts.getGC() != LangOptions::NonGC) 105 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))"); 106 else 107 Builder.defineMacro("__strong", ""); 108 109 // __unsafe_unretained is defined to nothing in non-ARC mode. We even 110 // allow this in C, since one might have block pointers in structs that 111 // are used in pure C code and in Objective-C ARC. 112 Builder.defineMacro("__unsafe_unretained", ""); 113 } 114 115 if (Opts.Static) 116 Builder.defineMacro("__STATIC__"); 117 else 118 Builder.defineMacro("__DYNAMIC__"); 119 120 if (Opts.POSIXThreads) 121 Builder.defineMacro("_REENTRANT"); 122 123 // Get the platform type and version number from the triple. 124 unsigned Maj, Min, Rev; 125 if (Triple.isMacOSX()) { 126 Triple.getMacOSXVersion(Maj, Min, Rev); 127 PlatformName = "macosx"; 128 } else { 129 Triple.getOSVersion(Maj, Min, Rev); 130 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS()); 131 } 132 133 // If -target arch-pc-win32-macho option specified, we're 134 // generating code for Win32 ABI. No need to emit 135 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__. 136 if (PlatformName == "win32") { 137 PlatformMinVersion = VersionTuple(Maj, Min, Rev); 138 return; 139 } 140 141 // Set the appropriate OS version define. 142 if (Triple.getOS() == llvm::Triple::IOS) { 143 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!"); 144 char Str[6]; 145 Str[0] = '0' + Maj; 146 Str[1] = '0' + (Min / 10); 147 Str[2] = '0' + (Min % 10); 148 Str[3] = '0' + (Rev / 10); 149 Str[4] = '0' + (Rev % 10); 150 Str[5] = '\0'; 151 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str); 152 } else { 153 // Note that the Driver allows versions which aren't representable in the 154 // define (because we only get a single digit for the minor and micro 155 // revision numbers). So, we limit them to the maximum representable 156 // version. 157 assert(Triple.getEnvironmentName().empty() && "Invalid environment!"); 158 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!"); 159 char Str[5]; 160 Str[0] = '0' + (Maj / 10); 161 Str[1] = '0' + (Maj % 10); 162 Str[2] = '0' + std::min(Min, 9U); 163 Str[3] = '0' + std::min(Rev, 9U); 164 Str[4] = '\0'; 165 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str); 166 } 167 168 PlatformMinVersion = VersionTuple(Maj, Min, Rev); 169 } 170 171 namespace { 172 template<typename Target> 173 class DarwinTargetInfo : public OSTargetInfo<Target> { 174 protected: 175 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 176 MacroBuilder &Builder) const { 177 getDarwinDefines(Builder, Opts, Triple, this->PlatformName, 178 this->PlatformMinVersion); 179 } 180 181 public: 182 DarwinTargetInfo(const std::string& triple) : 183 OSTargetInfo<Target>(triple) { 184 llvm::Triple T = llvm::Triple(triple); 185 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7); 186 this->MCountName = "\01mcount"; 187 } 188 189 virtual std::string isValidSectionSpecifier(StringRef SR) const { 190 // Let MCSectionMachO validate this. 191 StringRef Segment, Section; 192 unsigned TAA, StubSize; 193 bool HasTAA; 194 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section, 195 TAA, HasTAA, StubSize); 196 } 197 198 virtual const char *getStaticInitSectionSpecifier() const { 199 // FIXME: We should return 0 when building kexts. 200 return "__TEXT,__StaticInit,regular,pure_instructions"; 201 } 202 203 /// Darwin does not support protected visibility. Darwin's "default" 204 /// is very similar to ELF's "protected"; Darwin requires a "weak" 205 /// attribute on declarations that can be dynamically replaced. 206 virtual bool hasProtectedVisibility() const { 207 return false; 208 } 209 }; 210 211 212 // DragonFlyBSD Target 213 template<typename Target> 214 class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> { 215 protected: 216 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 217 MacroBuilder &Builder) const { 218 // DragonFly defines; list based off of gcc output 219 Builder.defineMacro("__DragonFly__"); 220 Builder.defineMacro("__DragonFly_cc_version", "100001"); 221 Builder.defineMacro("__ELF__"); 222 Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 223 Builder.defineMacro("__tune_i386__"); 224 DefineStd(Builder, "unix", Opts); 225 } 226 public: 227 DragonFlyBSDTargetInfo(const std::string &triple) 228 : OSTargetInfo<Target>(triple) { 229 this->UserLabelPrefix = ""; 230 231 llvm::Triple Triple(triple); 232 switch (Triple.getArch()) { 233 default: 234 case llvm::Triple::x86: 235 case llvm::Triple::x86_64: 236 this->MCountName = ".mcount"; 237 break; 238 } 239 } 240 }; 241 242 // FreeBSD Target 243 template<typename Target> 244 class FreeBSDTargetInfo : public OSTargetInfo<Target> { 245 protected: 246 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 247 MacroBuilder &Builder) const { 248 // FreeBSD defines; list based off of gcc output 249 250 unsigned Release = Triple.getOSMajorVersion(); 251 if (Release == 0U) 252 Release = 8; 253 254 Builder.defineMacro("__FreeBSD__", Twine(Release)); 255 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U)); 256 Builder.defineMacro("__KPRINTF_ATTRIBUTE__"); 257 DefineStd(Builder, "unix", Opts); 258 Builder.defineMacro("__ELF__"); 259 } 260 public: 261 FreeBSDTargetInfo(const std::string &triple) 262 : OSTargetInfo<Target>(triple) { 263 this->UserLabelPrefix = ""; 264 265 llvm::Triple Triple(triple); 266 switch (Triple.getArch()) { 267 default: 268 case llvm::Triple::x86: 269 case llvm::Triple::x86_64: 270 this->MCountName = ".mcount"; 271 break; 272 case llvm::Triple::mips: 273 case llvm::Triple::mipsel: 274 case llvm::Triple::ppc: 275 case llvm::Triple::ppc64: 276 this->MCountName = "_mcount"; 277 break; 278 case llvm::Triple::arm: 279 this->MCountName = "__mcount"; 280 break; 281 } 282 283 } 284 }; 285 286 // Minix Target 287 template<typename Target> 288 class MinixTargetInfo : public OSTargetInfo<Target> { 289 protected: 290 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 291 MacroBuilder &Builder) const { 292 // Minix defines 293 294 Builder.defineMacro("__minix", "3"); 295 Builder.defineMacro("_EM_WSIZE", "4"); 296 Builder.defineMacro("_EM_PSIZE", "4"); 297 Builder.defineMacro("_EM_SSIZE", "2"); 298 Builder.defineMacro("_EM_LSIZE", "4"); 299 Builder.defineMacro("_EM_FSIZE", "4"); 300 Builder.defineMacro("_EM_DSIZE", "8"); 301 Builder.defineMacro("__ELF__"); 302 DefineStd(Builder, "unix", Opts); 303 } 304 public: 305 MinixTargetInfo(const std::string &triple) 306 : OSTargetInfo<Target>(triple) { 307 this->UserLabelPrefix = ""; 308 } 309 }; 310 311 // Linux target 312 template<typename Target> 313 class LinuxTargetInfo : public OSTargetInfo<Target> { 314 protected: 315 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 316 MacroBuilder &Builder) const { 317 // Linux defines; list based off of gcc output 318 DefineStd(Builder, "unix", Opts); 319 DefineStd(Builder, "linux", Opts); 320 Builder.defineMacro("__gnu_linux__"); 321 Builder.defineMacro("__ELF__"); 322 if (Triple.getEnvironment() == llvm::Triple::Android) 323 Builder.defineMacro("__ANDROID__", "1"); 324 if (Opts.POSIXThreads) 325 Builder.defineMacro("_REENTRANT"); 326 if (Opts.CPlusPlus) 327 Builder.defineMacro("_GNU_SOURCE"); 328 } 329 public: 330 LinuxTargetInfo(const std::string& triple) 331 : OSTargetInfo<Target>(triple) { 332 this->UserLabelPrefix = ""; 333 this->WIntType = TargetInfo::UnsignedInt; 334 } 335 336 virtual const char *getStaticInitSectionSpecifier() const { 337 return ".text.startup"; 338 } 339 }; 340 341 // NetBSD Target 342 template<typename Target> 343 class NetBSDTargetInfo : public OSTargetInfo<Target> { 344 protected: 345 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 346 MacroBuilder &Builder) const { 347 // NetBSD defines; list based off of gcc output 348 Builder.defineMacro("__NetBSD__"); 349 Builder.defineMacro("__unix__"); 350 Builder.defineMacro("__ELF__"); 351 if (Opts.POSIXThreads) 352 Builder.defineMacro("_POSIX_THREADS"); 353 } 354 public: 355 NetBSDTargetInfo(const std::string &triple) 356 : OSTargetInfo<Target>(triple) { 357 this->UserLabelPrefix = ""; 358 } 359 }; 360 361 // OpenBSD Target 362 template<typename Target> 363 class OpenBSDTargetInfo : public OSTargetInfo<Target> { 364 protected: 365 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 366 MacroBuilder &Builder) const { 367 // OpenBSD defines; list based off of gcc output 368 369 Builder.defineMacro("__OpenBSD__"); 370 DefineStd(Builder, "unix", Opts); 371 Builder.defineMacro("__ELF__"); 372 if (Opts.POSIXThreads) 373 Builder.defineMacro("_REENTRANT"); 374 } 375 public: 376 OpenBSDTargetInfo(const std::string &triple) 377 : OSTargetInfo<Target>(triple) { 378 this->UserLabelPrefix = ""; 379 this->TLSSupported = false; 380 381 llvm::Triple Triple(triple); 382 switch (Triple.getArch()) { 383 default: 384 case llvm::Triple::x86: 385 case llvm::Triple::x86_64: 386 case llvm::Triple::arm: 387 case llvm::Triple::sparc: 388 this->MCountName = "__mcount"; 389 break; 390 case llvm::Triple::mips64: 391 case llvm::Triple::mips64el: 392 case llvm::Triple::ppc: 393 case llvm::Triple::sparcv9: 394 this->MCountName = "_mcount"; 395 break; 396 } 397 } 398 }; 399 400 // Bitrig Target 401 template<typename Target> 402 class BitrigTargetInfo : public OSTargetInfo<Target> { 403 protected: 404 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 405 MacroBuilder &Builder) const { 406 // Bitrig defines; list based off of gcc output 407 408 Builder.defineMacro("__Bitrig__"); 409 DefineStd(Builder, "unix", Opts); 410 Builder.defineMacro("__ELF__"); 411 if (Opts.POSIXThreads) 412 Builder.defineMacro("_REENTRANT"); 413 } 414 public: 415 BitrigTargetInfo(const std::string &triple) 416 : OSTargetInfo<Target>(triple) { 417 this->UserLabelPrefix = ""; 418 this->TLSSupported = false; 419 this->MCountName = "__mcount"; 420 } 421 }; 422 423 // PSP Target 424 template<typename Target> 425 class PSPTargetInfo : public OSTargetInfo<Target> { 426 protected: 427 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 428 MacroBuilder &Builder) const { 429 // PSP defines; list based on the output of the pspdev gcc toolchain. 430 Builder.defineMacro("PSP"); 431 Builder.defineMacro("_PSP"); 432 Builder.defineMacro("__psp__"); 433 Builder.defineMacro("__ELF__"); 434 } 435 public: 436 PSPTargetInfo(const std::string& triple) 437 : OSTargetInfo<Target>(triple) { 438 this->UserLabelPrefix = ""; 439 } 440 }; 441 442 // PS3 PPU Target 443 template<typename Target> 444 class PS3PPUTargetInfo : public OSTargetInfo<Target> { 445 protected: 446 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 447 MacroBuilder &Builder) const { 448 // PS3 PPU defines. 449 Builder.defineMacro("__PPC__"); 450 Builder.defineMacro("__PPU__"); 451 Builder.defineMacro("__CELLOS_LV2__"); 452 Builder.defineMacro("__ELF__"); 453 Builder.defineMacro("__LP32__"); 454 Builder.defineMacro("_ARCH_PPC64"); 455 Builder.defineMacro("__powerpc64__"); 456 } 457 public: 458 PS3PPUTargetInfo(const std::string& triple) 459 : OSTargetInfo<Target>(triple) { 460 this->UserLabelPrefix = ""; 461 this->LongWidth = this->LongAlign = 32; 462 this->PointerWidth = this->PointerAlign = 32; 463 this->IntMaxType = TargetInfo::SignedLongLong; 464 this->UIntMaxType = TargetInfo::UnsignedLongLong; 465 this->Int64Type = TargetInfo::SignedLongLong; 466 this->SizeType = TargetInfo::UnsignedInt; 467 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 468 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32"; 469 } 470 }; 471 472 // FIXME: Need a real SPU target. 473 // PS3 SPU Target 474 template<typename Target> 475 class PS3SPUTargetInfo : public OSTargetInfo<Target> { 476 protected: 477 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 478 MacroBuilder &Builder) const { 479 // PS3 PPU defines. 480 Builder.defineMacro("__SPU__"); 481 Builder.defineMacro("__ELF__"); 482 } 483 public: 484 PS3SPUTargetInfo(const std::string& triple) 485 : OSTargetInfo<Target>(triple) { 486 this->UserLabelPrefix = ""; 487 } 488 }; 489 490 // AuroraUX target 491 template<typename Target> 492 class AuroraUXTargetInfo : public OSTargetInfo<Target> { 493 protected: 494 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 495 MacroBuilder &Builder) const { 496 DefineStd(Builder, "sun", Opts); 497 DefineStd(Builder, "unix", Opts); 498 Builder.defineMacro("__ELF__"); 499 Builder.defineMacro("__svr4__"); 500 Builder.defineMacro("__SVR4"); 501 } 502 public: 503 AuroraUXTargetInfo(const std::string& triple) 504 : OSTargetInfo<Target>(triple) { 505 this->UserLabelPrefix = ""; 506 this->WCharType = this->SignedLong; 507 // FIXME: WIntType should be SignedLong 508 } 509 }; 510 511 // Solaris target 512 template<typename Target> 513 class SolarisTargetInfo : public OSTargetInfo<Target> { 514 protected: 515 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 516 MacroBuilder &Builder) const { 517 DefineStd(Builder, "sun", Opts); 518 DefineStd(Builder, "unix", Opts); 519 Builder.defineMacro("__ELF__"); 520 Builder.defineMacro("__svr4__"); 521 Builder.defineMacro("__SVR4"); 522 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and 523 // newer, but to 500 for everything else. feature_test.h has a check to 524 // ensure that you are not using C99 with an old version of X/Open or C89 525 // with a new version. 526 if (Opts.C99 || Opts.C11) 527 Builder.defineMacro("_XOPEN_SOURCE", "600"); 528 else 529 Builder.defineMacro("_XOPEN_SOURCE", "500"); 530 if (Opts.CPlusPlus) 531 Builder.defineMacro("__C99FEATURES__"); 532 Builder.defineMacro("_LARGEFILE_SOURCE"); 533 Builder.defineMacro("_LARGEFILE64_SOURCE"); 534 Builder.defineMacro("__EXTENSIONS__"); 535 Builder.defineMacro("_REENTRANT"); 536 } 537 public: 538 SolarisTargetInfo(const std::string& triple) 539 : OSTargetInfo<Target>(triple) { 540 this->UserLabelPrefix = ""; 541 this->WCharType = this->SignedInt; 542 // FIXME: WIntType should be SignedLong 543 } 544 }; 545 546 // Windows target 547 template<typename Target> 548 class WindowsTargetInfo : public OSTargetInfo<Target> { 549 protected: 550 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 551 MacroBuilder &Builder) const { 552 Builder.defineMacro("_WIN32"); 553 } 554 void getVisualStudioDefines(const LangOptions &Opts, 555 MacroBuilder &Builder) const { 556 if (Opts.CPlusPlus) { 557 if (Opts.RTTI) 558 Builder.defineMacro("_CPPRTTI"); 559 560 if (Opts.Exceptions) 561 Builder.defineMacro("_CPPUNWIND"); 562 } 563 564 if (!Opts.CharIsSigned) 565 Builder.defineMacro("_CHAR_UNSIGNED"); 566 567 // FIXME: POSIXThreads isn't exactly the option this should be defined for, 568 // but it works for now. 569 if (Opts.POSIXThreads) 570 Builder.defineMacro("_MT"); 571 572 if (Opts.MSCVersion != 0) 573 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion)); 574 575 if (Opts.MicrosoftExt) { 576 Builder.defineMacro("_MSC_EXTENSIONS"); 577 578 if (Opts.CPlusPlus11) { 579 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED"); 580 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED"); 581 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED"); 582 } 583 } 584 585 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64"); 586 } 587 588 public: 589 WindowsTargetInfo(const std::string &triple) 590 : OSTargetInfo<Target>(triple) {} 591 }; 592 593 template <typename Target> 594 class NaClTargetInfo : public OSTargetInfo<Target> { 595 protected: 596 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 597 MacroBuilder &Builder) const { 598 if (Opts.POSIXThreads) 599 Builder.defineMacro("_REENTRANT"); 600 if (Opts.CPlusPlus) 601 Builder.defineMacro("_GNU_SOURCE"); 602 603 DefineStd(Builder, "unix", Opts); 604 Builder.defineMacro("__ELF__"); 605 Builder.defineMacro("__native_client__"); 606 } 607 public: 608 NaClTargetInfo(const std::string &triple) 609 : OSTargetInfo<Target>(triple) { 610 this->UserLabelPrefix = ""; 611 this->LongAlign = 32; 612 this->LongWidth = 32; 613 this->PointerAlign = 32; 614 this->PointerWidth = 32; 615 this->IntMaxType = TargetInfo::SignedLongLong; 616 this->UIntMaxType = TargetInfo::UnsignedLongLong; 617 this->Int64Type = TargetInfo::SignedLongLong; 618 this->DoubleAlign = 64; 619 this->LongDoubleWidth = 64; 620 this->LongDoubleAlign = 64; 621 this->SizeType = TargetInfo::UnsignedInt; 622 this->PtrDiffType = TargetInfo::SignedInt; 623 this->IntPtrType = TargetInfo::SignedInt; 624 this->RegParmMax = 2; 625 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble; 626 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-" 627 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32"; 628 } 629 virtual typename Target::CallingConvCheckResult checkCallingConvention( 630 CallingConv CC) const { 631 return CC == CC_PnaclCall ? Target::CCCR_OK : 632 Target::checkCallingConvention(CC); 633 } 634 }; 635 } // end anonymous namespace. 636 637 //===----------------------------------------------------------------------===// 638 // Specific target implementations. 639 //===----------------------------------------------------------------------===// 640 641 namespace { 642 // PPC abstract base class 643 class PPCTargetInfo : public TargetInfo { 644 static const Builtin::Info BuiltinInfo[]; 645 static const char * const GCCRegNames[]; 646 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 647 std::string CPU; 648 public: 649 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) { 650 LongDoubleWidth = LongDoubleAlign = 128; 651 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble; 652 } 653 654 /// \brief Flags for architecture specific defines. 655 typedef enum { 656 ArchDefineNone = 0, 657 ArchDefineName = 1 << 0, // <name> is substituted for arch name. 658 ArchDefinePpcgr = 1 << 1, 659 ArchDefinePpcsq = 1 << 2, 660 ArchDefine440 = 1 << 3, 661 ArchDefine603 = 1 << 4, 662 ArchDefine604 = 1 << 5, 663 ArchDefinePwr4 = 1 << 6, 664 ArchDefinePwr5 = 1 << 7, 665 ArchDefinePwr5x = 1 << 8, 666 ArchDefinePwr6 = 1 << 9, 667 ArchDefinePwr6x = 1 << 10, 668 ArchDefinePwr7 = 1 << 11, 669 ArchDefineA2 = 1 << 12, 670 ArchDefineA2q = 1 << 13 671 } ArchDefineTypes; 672 673 // Note: GCC recognizes the following additional cpus: 674 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801, 675 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell, 676 // titan, rs64. 677 virtual bool setCPU(const std::string &Name) { 678 bool CPUKnown = llvm::StringSwitch<bool>(Name) 679 .Case("generic", true) 680 .Case("440", true) 681 .Case("450", true) 682 .Case("601", true) 683 .Case("602", true) 684 .Case("603", true) 685 .Case("603e", true) 686 .Case("603ev", true) 687 .Case("604", true) 688 .Case("604e", true) 689 .Case("620", true) 690 .Case("630", true) 691 .Case("g3", true) 692 .Case("7400", true) 693 .Case("g4", true) 694 .Case("7450", true) 695 .Case("g4+", true) 696 .Case("750", true) 697 .Case("970", true) 698 .Case("g5", true) 699 .Case("a2", true) 700 .Case("a2q", true) 701 .Case("e500mc", true) 702 .Case("e5500", true) 703 .Case("power3", true) 704 .Case("pwr3", true) 705 .Case("power4", true) 706 .Case("pwr4", true) 707 .Case("power5", true) 708 .Case("pwr5", true) 709 .Case("power5x", true) 710 .Case("pwr5x", true) 711 .Case("power6", true) 712 .Case("pwr6", true) 713 .Case("power6x", true) 714 .Case("pwr6x", true) 715 .Case("power7", true) 716 .Case("pwr7", true) 717 .Case("powerpc", true) 718 .Case("ppc", true) 719 .Case("powerpc64", true) 720 .Case("ppc64", true) 721 .Default(false); 722 723 if (CPUKnown) 724 CPU = Name; 725 726 return CPUKnown; 727 } 728 729 virtual void getTargetBuiltins(const Builtin::Info *&Records, 730 unsigned &NumRecords) const { 731 Records = BuiltinInfo; 732 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin; 733 } 734 735 virtual bool isCLZForZeroUndef() const { return false; } 736 737 virtual void getTargetDefines(const LangOptions &Opts, 738 MacroBuilder &Builder) const; 739 740 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const; 741 742 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features, 743 StringRef Name, 744 bool Enabled) const; 745 746 virtual bool hasFeature(StringRef Feature) const; 747 748 virtual void getGCCRegNames(const char * const *&Names, 749 unsigned &NumNames) const; 750 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 751 unsigned &NumAliases) const; 752 virtual bool validateAsmConstraint(const char *&Name, 753 TargetInfo::ConstraintInfo &Info) const { 754 switch (*Name) { 755 default: return false; 756 case 'O': // Zero 757 break; 758 case 'b': // Base register 759 case 'f': // Floating point register 760 Info.setAllowsRegister(); 761 break; 762 // FIXME: The following are added to allow parsing. 763 // I just took a guess at what the actions should be. 764 // Also, is more specific checking needed? I.e. specific registers? 765 case 'd': // Floating point register (containing 64-bit value) 766 case 'v': // Altivec vector register 767 Info.setAllowsRegister(); 768 break; 769 case 'w': 770 switch (Name[1]) { 771 case 'd':// VSX vector register to hold vector double data 772 case 'f':// VSX vector register to hold vector float data 773 case 's':// VSX vector register to hold scalar float data 774 case 'a':// Any VSX register 775 break; 776 default: 777 return false; 778 } 779 Info.setAllowsRegister(); 780 Name++; // Skip over 'w'. 781 break; 782 case 'h': // `MQ', `CTR', or `LINK' register 783 case 'q': // `MQ' register 784 case 'c': // `CTR' register 785 case 'l': // `LINK' register 786 case 'x': // `CR' register (condition register) number 0 787 case 'y': // `CR' register (condition register) 788 case 'z': // `XER[CA]' carry bit (part of the XER register) 789 Info.setAllowsRegister(); 790 break; 791 case 'I': // Signed 16-bit constant 792 case 'J': // Unsigned 16-bit constant shifted left 16 bits 793 // (use `L' instead for SImode constants) 794 case 'K': // Unsigned 16-bit constant 795 case 'L': // Signed 16-bit constant shifted left 16 bits 796 case 'M': // Constant larger than 31 797 case 'N': // Exact power of 2 798 case 'P': // Constant whose negation is a signed 16-bit constant 799 case 'G': // Floating point constant that can be loaded into a 800 // register with one instruction per word 801 case 'H': // Integer/Floating point constant that can be loaded 802 // into a register using three instructions 803 break; 804 case 'm': // Memory operand. Note that on PowerPC targets, m can 805 // include addresses that update the base register. It 806 // is therefore only safe to use `m' in an asm statement 807 // if that asm statement accesses the operand exactly once. 808 // The asm statement must also use `%U<opno>' as a 809 // placeholder for the "update" flag in the corresponding 810 // load or store instruction. For example: 811 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val)); 812 // is correct but: 813 // asm ("st %1,%0" : "=m" (mem) : "r" (val)); 814 // is not. Use es rather than m if you don't want the base 815 // register to be updated. 816 case 'e': 817 if (Name[1] != 's') 818 return false; 819 // es: A "stable" memory operand; that is, one which does not 820 // include any automodification of the base register. Unlike 821 // `m', this constraint can be used in asm statements that 822 // might access the operand several times, or that might not 823 // access it at all. 824 Info.setAllowsMemory(); 825 Name++; // Skip over 'e'. 826 break; 827 case 'Q': // Memory operand that is an offset from a register (it is 828 // usually better to use `m' or `es' in asm statements) 829 case 'Z': // Memory operand that is an indexed or indirect from a 830 // register (it is usually better to use `m' or `es' in 831 // asm statements) 832 Info.setAllowsMemory(); 833 Info.setAllowsRegister(); 834 break; 835 case 'R': // AIX TOC entry 836 case 'a': // Address operand that is an indexed or indirect from a 837 // register (`p' is preferable for asm statements) 838 case 'S': // Constant suitable as a 64-bit mask operand 839 case 'T': // Constant suitable as a 32-bit mask operand 840 case 'U': // System V Release 4 small data area reference 841 case 't': // AND masks that can be performed by two rldic{l, r} 842 // instructions 843 case 'W': // Vector constant that does not require memory 844 case 'j': // Vector constant that is all zeros. 845 break; 846 // End FIXME. 847 } 848 return true; 849 } 850 virtual const char *getClobbers() const { 851 return ""; 852 } 853 int getEHDataRegisterNumber(unsigned RegNo) const { 854 if (RegNo == 0) return 3; 855 if (RegNo == 1) return 4; 856 return -1; 857 } 858 }; 859 860 const Builtin::Info PPCTargetInfo::BuiltinInfo[] = { 861 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 862 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 863 ALL_LANGUAGES }, 864 #include "clang/Basic/BuiltinsPPC.def" 865 }; 866 867 868 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific 869 /// #defines that are not tied to a specific subtarget. 870 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts, 871 MacroBuilder &Builder) const { 872 // Target identification. 873 Builder.defineMacro("__ppc__"); 874 Builder.defineMacro("_ARCH_PPC"); 875 Builder.defineMacro("__powerpc__"); 876 Builder.defineMacro("__POWERPC__"); 877 if (PointerWidth == 64) { 878 Builder.defineMacro("_ARCH_PPC64"); 879 Builder.defineMacro("__powerpc64__"); 880 Builder.defineMacro("__ppc64__"); 881 } else { 882 Builder.defineMacro("__ppc__"); 883 } 884 885 // Target properties. 886 if (getTriple().getOS() != llvm::Triple::NetBSD && 887 getTriple().getOS() != llvm::Triple::OpenBSD) 888 Builder.defineMacro("_BIG_ENDIAN"); 889 Builder.defineMacro("__BIG_ENDIAN__"); 890 891 // Subtarget options. 892 Builder.defineMacro("__NATURAL_ALIGNMENT__"); 893 Builder.defineMacro("__REGISTER_PREFIX__", ""); 894 895 // FIXME: Should be controlled by command line option. 896 Builder.defineMacro("__LONG_DOUBLE_128__"); 897 898 if (Opts.AltiVec) { 899 Builder.defineMacro("__VEC__", "10206"); 900 Builder.defineMacro("__ALTIVEC__"); 901 } 902 903 // CPU identification. 904 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU) 905 .Case("440", ArchDefineName) 906 .Case("450", ArchDefineName | ArchDefine440) 907 .Case("601", ArchDefineName) 908 .Case("602", ArchDefineName | ArchDefinePpcgr) 909 .Case("603", ArchDefineName | ArchDefinePpcgr) 910 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr) 911 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr) 912 .Case("604", ArchDefineName | ArchDefinePpcgr) 913 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr) 914 .Case("620", ArchDefineName | ArchDefinePpcgr) 915 .Case("630", ArchDefineName | ArchDefinePpcgr) 916 .Case("7400", ArchDefineName | ArchDefinePpcgr) 917 .Case("7450", ArchDefineName | ArchDefinePpcgr) 918 .Case("750", ArchDefineName | ArchDefinePpcgr) 919 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr 920 | ArchDefinePpcsq) 921 .Case("a2", ArchDefineA2) 922 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q) 923 .Case("pwr3", ArchDefinePpcgr) 924 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq) 925 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr 926 | ArchDefinePpcsq) 927 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4 928 | ArchDefinePpcgr | ArchDefinePpcsq) 929 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5 930 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 931 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x 932 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr 933 | ArchDefinePpcsq) 934 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6 935 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 936 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq) 937 .Case("power3", ArchDefinePpcgr) 938 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 939 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr 940 | ArchDefinePpcsq) 941 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 942 | ArchDefinePpcgr | ArchDefinePpcsq) 943 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 944 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq) 945 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x 946 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr 947 | ArchDefinePpcsq) 948 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6 949 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 950 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq) 951 .Default(ArchDefineNone); 952 953 if (defs & ArchDefineName) 954 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper())); 955 if (defs & ArchDefinePpcgr) 956 Builder.defineMacro("_ARCH_PPCGR"); 957 if (defs & ArchDefinePpcsq) 958 Builder.defineMacro("_ARCH_PPCSQ"); 959 if (defs & ArchDefine440) 960 Builder.defineMacro("_ARCH_440"); 961 if (defs & ArchDefine603) 962 Builder.defineMacro("_ARCH_603"); 963 if (defs & ArchDefine604) 964 Builder.defineMacro("_ARCH_604"); 965 if (defs & ArchDefinePwr4) 966 Builder.defineMacro("_ARCH_PWR4"); 967 if (defs & ArchDefinePwr5) 968 Builder.defineMacro("_ARCH_PWR5"); 969 if (defs & ArchDefinePwr5x) 970 Builder.defineMacro("_ARCH_PWR5X"); 971 if (defs & ArchDefinePwr6) 972 Builder.defineMacro("_ARCH_PWR6"); 973 if (defs & ArchDefinePwr6x) 974 Builder.defineMacro("_ARCH_PWR6X"); 975 if (defs & ArchDefinePwr7) 976 Builder.defineMacro("_ARCH_PWR7"); 977 if (defs & ArchDefineA2) 978 Builder.defineMacro("_ARCH_A2"); 979 if (defs & ArchDefineA2q) { 980 Builder.defineMacro("_ARCH_A2Q"); 981 Builder.defineMacro("_ARCH_QP"); 982 } 983 984 if (getTriple().getVendor() == llvm::Triple::BGQ) { 985 Builder.defineMacro("__bg__"); 986 Builder.defineMacro("__THW_BLUEGENE__"); 987 Builder.defineMacro("__bgq__"); 988 Builder.defineMacro("__TOS_BGQ__"); 989 } 990 991 // FIXME: The following are not yet generated here by Clang, but are 992 // generated by GCC: 993 // 994 // _SOFT_FLOAT_ 995 // __RECIP_PRECISION__ 996 // __APPLE_ALTIVEC__ 997 // __VSX__ 998 // __RECIP__ 999 // __RECIPF__ 1000 // __RSQRTE__ 1001 // __RSQRTEF__ 1002 // _SOFT_DOUBLE_ 1003 // __NO_LWSYNC__ 1004 // __HAVE_BSWAP__ 1005 // __LONGDOUBLE128 1006 // __CMODEL_MEDIUM__ 1007 // __CMODEL_LARGE__ 1008 // _CALL_SYSV 1009 // _CALL_DARWIN 1010 // __NO_FPRS__ 1011 } 1012 1013 void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const { 1014 Features["altivec"] = llvm::StringSwitch<bool>(CPU) 1015 .Case("7400", true) 1016 .Case("g4", true) 1017 .Case("7450", true) 1018 .Case("g4+", true) 1019 .Case("970", true) 1020 .Case("g5", true) 1021 .Case("pwr6", true) 1022 .Case("pwr7", true) 1023 .Case("ppc64", true) 1024 .Default(false); 1025 1026 Features["qpx"] = (CPU == "a2q"); 1027 } 1028 1029 bool PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features, 1030 StringRef Name, 1031 bool Enabled) const { 1032 if (Name == "altivec" || Name == "qpx") { 1033 Features[Name] = Enabled; 1034 return true; 1035 } 1036 1037 return false; 1038 } 1039 1040 bool PPCTargetInfo::hasFeature(StringRef Feature) const { 1041 return Feature == "powerpc"; 1042 } 1043 1044 1045 const char * const PPCTargetInfo::GCCRegNames[] = { 1046 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 1047 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 1048 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 1049 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 1050 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", 1051 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", 1052 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", 1053 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", 1054 "mq", "lr", "ctr", "ap", 1055 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", 1056 "xer", 1057 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", 1058 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", 1059 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", 1060 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", 1061 "vrsave", "vscr", 1062 "spe_acc", "spefscr", 1063 "sfp" 1064 }; 1065 1066 void PPCTargetInfo::getGCCRegNames(const char * const *&Names, 1067 unsigned &NumNames) const { 1068 Names = GCCRegNames; 1069 NumNames = llvm::array_lengthof(GCCRegNames); 1070 } 1071 1072 const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = { 1073 // While some of these aliases do map to different registers 1074 // they still share the same register name. 1075 { { "0" }, "r0" }, 1076 { { "1"}, "r1" }, 1077 { { "2" }, "r2" }, 1078 { { "3" }, "r3" }, 1079 { { "4" }, "r4" }, 1080 { { "5" }, "r5" }, 1081 { { "6" }, "r6" }, 1082 { { "7" }, "r7" }, 1083 { { "8" }, "r8" }, 1084 { { "9" }, "r9" }, 1085 { { "10" }, "r10" }, 1086 { { "11" }, "r11" }, 1087 { { "12" }, "r12" }, 1088 { { "13" }, "r13" }, 1089 { { "14" }, "r14" }, 1090 { { "15" }, "r15" }, 1091 { { "16" }, "r16" }, 1092 { { "17" }, "r17" }, 1093 { { "18" }, "r18" }, 1094 { { "19" }, "r19" }, 1095 { { "20" }, "r20" }, 1096 { { "21" }, "r21" }, 1097 { { "22" }, "r22" }, 1098 { { "23" }, "r23" }, 1099 { { "24" }, "r24" }, 1100 { { "25" }, "r25" }, 1101 { { "26" }, "r26" }, 1102 { { "27" }, "r27" }, 1103 { { "28" }, "r28" }, 1104 { { "29" }, "r29" }, 1105 { { "30" }, "r30" }, 1106 { { "31" }, "r31" }, 1107 { { "fr0" }, "f0" }, 1108 { { "fr1" }, "f1" }, 1109 { { "fr2" }, "f2" }, 1110 { { "fr3" }, "f3" }, 1111 { { "fr4" }, "f4" }, 1112 { { "fr5" }, "f5" }, 1113 { { "fr6" }, "f6" }, 1114 { { "fr7" }, "f7" }, 1115 { { "fr8" }, "f8" }, 1116 { { "fr9" }, "f9" }, 1117 { { "fr10" }, "f10" }, 1118 { { "fr11" }, "f11" }, 1119 { { "fr12" }, "f12" }, 1120 { { "fr13" }, "f13" }, 1121 { { "fr14" }, "f14" }, 1122 { { "fr15" }, "f15" }, 1123 { { "fr16" }, "f16" }, 1124 { { "fr17" }, "f17" }, 1125 { { "fr18" }, "f18" }, 1126 { { "fr19" }, "f19" }, 1127 { { "fr20" }, "f20" }, 1128 { { "fr21" }, "f21" }, 1129 { { "fr22" }, "f22" }, 1130 { { "fr23" }, "f23" }, 1131 { { "fr24" }, "f24" }, 1132 { { "fr25" }, "f25" }, 1133 { { "fr26" }, "f26" }, 1134 { { "fr27" }, "f27" }, 1135 { { "fr28" }, "f28" }, 1136 { { "fr29" }, "f29" }, 1137 { { "fr30" }, "f30" }, 1138 { { "fr31" }, "f31" }, 1139 { { "cc" }, "cr0" }, 1140 }; 1141 1142 void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 1143 unsigned &NumAliases) const { 1144 Aliases = GCCRegAliases; 1145 NumAliases = llvm::array_lengthof(GCCRegAliases); 1146 } 1147 } // end anonymous namespace. 1148 1149 namespace { 1150 class PPC32TargetInfo : public PPCTargetInfo { 1151 public: 1152 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) { 1153 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 1154 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32"; 1155 1156 switch (getTriple().getOS()) { 1157 case llvm::Triple::Linux: 1158 case llvm::Triple::FreeBSD: 1159 case llvm::Triple::NetBSD: 1160 SizeType = UnsignedInt; 1161 PtrDiffType = SignedInt; 1162 IntPtrType = SignedInt; 1163 break; 1164 default: 1165 break; 1166 } 1167 1168 if (getTriple().getOS() == llvm::Triple::FreeBSD) { 1169 LongDoubleWidth = LongDoubleAlign = 64; 1170 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 1171 } 1172 1173 // PPC32 supports atomics up to 4 bytes. 1174 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32; 1175 } 1176 1177 virtual BuiltinVaListKind getBuiltinVaListKind() const { 1178 // This is the ELF definition, and is overridden by the Darwin sub-target 1179 return TargetInfo::PowerABIBuiltinVaList; 1180 } 1181 }; 1182 } // end anonymous namespace. 1183 1184 namespace { 1185 class PPC64TargetInfo : public PPCTargetInfo { 1186 public: 1187 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) { 1188 LongWidth = LongAlign = PointerWidth = PointerAlign = 64; 1189 IntMaxType = SignedLong; 1190 UIntMaxType = UnsignedLong; 1191 Int64Type = SignedLong; 1192 1193 if (getTriple().getOS() == llvm::Triple::FreeBSD) { 1194 LongDoubleWidth = LongDoubleAlign = 64; 1195 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 1196 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 1197 "i64:64:64-f32:32:32-f64:64:64-f128:64:64-" 1198 "v128:128:128-n32:64"; 1199 } else 1200 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 1201 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-" 1202 "v128:128:128-n32:64"; 1203 1204 // PPC64 supports atomics up to 8 bytes. 1205 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 1206 } 1207 virtual BuiltinVaListKind getBuiltinVaListKind() const { 1208 return TargetInfo::CharPtrBuiltinVaList; 1209 } 1210 }; 1211 } // end anonymous namespace. 1212 1213 1214 namespace { 1215 class DarwinPPC32TargetInfo : 1216 public DarwinTargetInfo<PPC32TargetInfo> { 1217 public: 1218 DarwinPPC32TargetInfo(const std::string& triple) 1219 : DarwinTargetInfo<PPC32TargetInfo>(triple) { 1220 HasAlignMac68kSupport = true; 1221 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool? 1222 LongLongAlign = 32; 1223 SuitableAlign = 128; 1224 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 1225 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32"; 1226 } 1227 virtual BuiltinVaListKind getBuiltinVaListKind() const { 1228 return TargetInfo::CharPtrBuiltinVaList; 1229 } 1230 }; 1231 1232 class DarwinPPC64TargetInfo : 1233 public DarwinTargetInfo<PPC64TargetInfo> { 1234 public: 1235 DarwinPPC64TargetInfo(const std::string& triple) 1236 : DarwinTargetInfo<PPC64TargetInfo>(triple) { 1237 HasAlignMac68kSupport = true; 1238 SuitableAlign = 128; 1239 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 1240 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64"; 1241 } 1242 }; 1243 } // end anonymous namespace. 1244 1245 namespace { 1246 static const unsigned NVPTXAddrSpaceMap[] = { 1247 1, // opencl_global 1248 3, // opencl_local 1249 4, // opencl_constant 1250 1, // cuda_device 1251 4, // cuda_constant 1252 3, // cuda_shared 1253 }; 1254 class NVPTXTargetInfo : public TargetInfo { 1255 static const char * const GCCRegNames[]; 1256 static const Builtin::Info BuiltinInfo[]; 1257 std::vector<StringRef> AvailableFeatures; 1258 public: 1259 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) { 1260 BigEndian = false; 1261 TLSSupported = false; 1262 LongWidth = LongAlign = 64; 1263 AddrSpaceMap = &NVPTXAddrSpaceMap; 1264 // Define available target features 1265 // These must be defined in sorted order! 1266 NoAsmVariants = true; 1267 } 1268 virtual void getTargetDefines(const LangOptions &Opts, 1269 MacroBuilder &Builder) const { 1270 Builder.defineMacro("__PTX__"); 1271 Builder.defineMacro("__NVPTX__"); 1272 } 1273 virtual void getTargetBuiltins(const Builtin::Info *&Records, 1274 unsigned &NumRecords) const { 1275 Records = BuiltinInfo; 1276 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin; 1277 } 1278 virtual bool hasFeature(StringRef Feature) const { 1279 return Feature == "ptx" || Feature == "nvptx"; 1280 } 1281 1282 virtual void getGCCRegNames(const char * const *&Names, 1283 unsigned &NumNames) const; 1284 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 1285 unsigned &NumAliases) const { 1286 // No aliases. 1287 Aliases = 0; 1288 NumAliases = 0; 1289 } 1290 virtual bool validateAsmConstraint(const char *&Name, 1291 TargetInfo::ConstraintInfo &info) const { 1292 // FIXME: implement 1293 return true; 1294 } 1295 virtual const char *getClobbers() const { 1296 // FIXME: Is this really right? 1297 return ""; 1298 } 1299 virtual BuiltinVaListKind getBuiltinVaListKind() const { 1300 // FIXME: implement 1301 return TargetInfo::CharPtrBuiltinVaList; 1302 } 1303 virtual bool setCPU(const std::string &Name) { 1304 return Name == "sm_10" || Name == "sm_13" || Name == "sm_20"; 1305 } 1306 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features, 1307 StringRef Name, 1308 bool Enabled) const; 1309 }; 1310 1311 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = { 1312 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 1313 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 1314 ALL_LANGUAGES }, 1315 #include "clang/Basic/BuiltinsNVPTX.def" 1316 }; 1317 1318 const char * const NVPTXTargetInfo::GCCRegNames[] = { 1319 "r0" 1320 }; 1321 1322 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names, 1323 unsigned &NumNames) const { 1324 Names = GCCRegNames; 1325 NumNames = llvm::array_lengthof(GCCRegNames); 1326 } 1327 1328 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features, 1329 StringRef Name, 1330 bool Enabled) const { 1331 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(), 1332 Name)) { 1333 Features[Name] = Enabled; 1334 return true; 1335 } else { 1336 return false; 1337 } 1338 } 1339 1340 class NVPTX32TargetInfo : public NVPTXTargetInfo { 1341 public: 1342 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) { 1343 PointerWidth = PointerAlign = 32; 1344 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt; 1345 DescriptionString 1346 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-" 1347 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-" 1348 "n16:32:64"; 1349 } 1350 }; 1351 1352 class NVPTX64TargetInfo : public NVPTXTargetInfo { 1353 public: 1354 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) { 1355 PointerWidth = PointerAlign = 64; 1356 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong; 1357 DescriptionString 1358 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-" 1359 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-" 1360 "n16:32:64"; 1361 } 1362 }; 1363 } 1364 1365 namespace { 1366 1367 static const unsigned R600AddrSpaceMap[] = { 1368 1, // opencl_global 1369 3, // opencl_local 1370 2, // opencl_constant 1371 1, // cuda_device 1372 2, // cuda_constant 1373 3 // cuda_shared 1374 }; 1375 1376 static const char *DescriptionStringR600 = 1377 "e" 1378 "-p:32:32:32" 1379 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32" 1380 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128" 1381 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048" 1382 "-n32:64"; 1383 1384 static const char *DescriptionStringR600DoubleOps = 1385 "e" 1386 "-p:32:32:32" 1387 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64" 1388 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128" 1389 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048" 1390 "-n32:64"; 1391 1392 static const char *DescriptionStringSI = 1393 "e" 1394 "-p:64:64:64" 1395 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64" 1396 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128" 1397 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048" 1398 "-n32:64"; 1399 1400 class R600TargetInfo : public TargetInfo { 1401 /// \brief The GPU profiles supported by the R600 target. 1402 enum GPUKind { 1403 GK_NONE, 1404 GK_R600, 1405 GK_R600_DOUBLE_OPS, 1406 GK_R700, 1407 GK_R700_DOUBLE_OPS, 1408 GK_EVERGREEN, 1409 GK_EVERGREEN_DOUBLE_OPS, 1410 GK_NORTHERN_ISLANDS, 1411 GK_CAYMAN, 1412 GK_SOUTHERN_ISLANDS 1413 } GPU; 1414 1415 public: 1416 R600TargetInfo(const std::string& triple) 1417 : TargetInfo(triple), 1418 GPU(GK_R600) { 1419 DescriptionString = DescriptionStringR600; 1420 AddrSpaceMap = &R600AddrSpaceMap; 1421 } 1422 1423 virtual const char * getClobbers() const { 1424 return ""; 1425 } 1426 1427 virtual void getGCCRegNames(const char * const *&Names, 1428 unsigned &numNames) const { 1429 Names = NULL; 1430 numNames = 0; 1431 } 1432 1433 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 1434 unsigned &NumAliases) const { 1435 Aliases = NULL; 1436 NumAliases = 0; 1437 } 1438 1439 virtual bool validateAsmConstraint(const char *&Name, 1440 TargetInfo::ConstraintInfo &info) const { 1441 return true; 1442 } 1443 1444 virtual void getTargetBuiltins(const Builtin::Info *&Records, 1445 unsigned &NumRecords) const { 1446 Records = NULL; 1447 NumRecords = 0; 1448 } 1449 1450 1451 virtual void getTargetDefines(const LangOptions &Opts, 1452 MacroBuilder &Builder) const { 1453 Builder.defineMacro("__R600__"); 1454 } 1455 1456 virtual BuiltinVaListKind getBuiltinVaListKind() const { 1457 return TargetInfo::CharPtrBuiltinVaList; 1458 } 1459 1460 virtual bool setCPU(const std::string &Name) { 1461 GPU = llvm::StringSwitch<GPUKind>(Name) 1462 .Case("r600" , GK_R600) 1463 .Case("rv610", GK_R600) 1464 .Case("rv620", GK_R600) 1465 .Case("rv630", GK_R600) 1466 .Case("rv635", GK_R600) 1467 .Case("rs780", GK_R600) 1468 .Case("rs880", GK_R600) 1469 .Case("rv670", GK_R600_DOUBLE_OPS) 1470 .Case("rv710", GK_R700) 1471 .Case("rv730", GK_R700) 1472 .Case("rv740", GK_R700_DOUBLE_OPS) 1473 .Case("rv770", GK_R700_DOUBLE_OPS) 1474 .Case("palm", GK_EVERGREEN) 1475 .Case("cedar", GK_EVERGREEN) 1476 .Case("sumo", GK_EVERGREEN) 1477 .Case("sumo2", GK_EVERGREEN) 1478 .Case("redwood", GK_EVERGREEN) 1479 .Case("juniper", GK_EVERGREEN) 1480 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS) 1481 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS) 1482 .Case("barts", GK_NORTHERN_ISLANDS) 1483 .Case("turks", GK_NORTHERN_ISLANDS) 1484 .Case("caicos", GK_NORTHERN_ISLANDS) 1485 .Case("cayman", GK_CAYMAN) 1486 .Case("aruba", GK_CAYMAN) 1487 .Case("SI", GK_SOUTHERN_ISLANDS) 1488 .Case("pitcairn", GK_SOUTHERN_ISLANDS) 1489 .Case("verde", GK_SOUTHERN_ISLANDS) 1490 .Case("oland", GK_SOUTHERN_ISLANDS) 1491 .Default(GK_NONE); 1492 1493 if (GPU == GK_NONE) { 1494 return false; 1495 } 1496 1497 // Set the correct data layout 1498 switch (GPU) { 1499 case GK_NONE: 1500 case GK_R600: 1501 case GK_R700: 1502 case GK_EVERGREEN: 1503 case GK_NORTHERN_ISLANDS: 1504 DescriptionString = DescriptionStringR600; 1505 break; 1506 case GK_R600_DOUBLE_OPS: 1507 case GK_R700_DOUBLE_OPS: 1508 case GK_EVERGREEN_DOUBLE_OPS: 1509 case GK_CAYMAN: 1510 DescriptionString = DescriptionStringR600DoubleOps; 1511 break; 1512 case GK_SOUTHERN_ISLANDS: 1513 DescriptionString = DescriptionStringSI; 1514 break; 1515 } 1516 1517 return true; 1518 } 1519 }; 1520 1521 } // end anonymous namespace 1522 1523 namespace { 1524 // MBlaze abstract base class 1525 class MBlazeTargetInfo : public TargetInfo { 1526 static const char * const GCCRegNames[]; 1527 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 1528 1529 public: 1530 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) { 1531 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16"; 1532 } 1533 1534 virtual void getTargetBuiltins(const Builtin::Info *&Records, 1535 unsigned &NumRecords) const { 1536 // FIXME: Implement. 1537 Records = 0; 1538 NumRecords = 0; 1539 } 1540 1541 virtual void getTargetDefines(const LangOptions &Opts, 1542 MacroBuilder &Builder) const; 1543 1544 virtual bool hasFeature(StringRef Feature) const { 1545 return Feature == "mblaze"; 1546 } 1547 1548 virtual BuiltinVaListKind getBuiltinVaListKind() const { 1549 return TargetInfo::CharPtrBuiltinVaList; 1550 } 1551 virtual const char *getTargetPrefix() const { 1552 return "mblaze"; 1553 } 1554 virtual void getGCCRegNames(const char * const *&Names, 1555 unsigned &NumNames) const; 1556 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 1557 unsigned &NumAliases) const; 1558 virtual bool validateAsmConstraint(const char *&Name, 1559 TargetInfo::ConstraintInfo &Info) const { 1560 switch (*Name) { 1561 default: return false; 1562 case 'O': // Zero 1563 return true; 1564 case 'b': // Base register 1565 case 'f': // Floating point register 1566 Info.setAllowsRegister(); 1567 return true; 1568 } 1569 } 1570 virtual const char *getClobbers() const { 1571 return ""; 1572 } 1573 }; 1574 1575 /// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific 1576 /// #defines that are not tied to a specific subtarget. 1577 void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts, 1578 MacroBuilder &Builder) const { 1579 // Target identification. 1580 Builder.defineMacro("__microblaze__"); 1581 Builder.defineMacro("_ARCH_MICROBLAZE"); 1582 Builder.defineMacro("__MICROBLAZE__"); 1583 1584 // Target properties. 1585 Builder.defineMacro("_BIG_ENDIAN"); 1586 Builder.defineMacro("__BIG_ENDIAN__"); 1587 1588 // Subtarget options. 1589 Builder.defineMacro("__REGISTER_PREFIX__", ""); 1590 } 1591 1592 1593 const char * const MBlazeTargetInfo::GCCRegNames[] = { 1594 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 1595 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 1596 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 1597 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 1598 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", 1599 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15", 1600 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23", 1601 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31", 1602 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4", 1603 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp" 1604 }; 1605 1606 void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names, 1607 unsigned &NumNames) const { 1608 Names = GCCRegNames; 1609 NumNames = llvm::array_lengthof(GCCRegNames); 1610 } 1611 1612 const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = { 1613 { {"f0"}, "r0" }, 1614 { {"f1"}, "r1" }, 1615 { {"f2"}, "r2" }, 1616 { {"f3"}, "r3" }, 1617 { {"f4"}, "r4" }, 1618 { {"f5"}, "r5" }, 1619 { {"f6"}, "r6" }, 1620 { {"f7"}, "r7" }, 1621 { {"f8"}, "r8" }, 1622 { {"f9"}, "r9" }, 1623 { {"f10"}, "r10" }, 1624 { {"f11"}, "r11" }, 1625 { {"f12"}, "r12" }, 1626 { {"f13"}, "r13" }, 1627 { {"f14"}, "r14" }, 1628 { {"f15"}, "r15" }, 1629 { {"f16"}, "r16" }, 1630 { {"f17"}, "r17" }, 1631 { {"f18"}, "r18" }, 1632 { {"f19"}, "r19" }, 1633 { {"f20"}, "r20" }, 1634 { {"f21"}, "r21" }, 1635 { {"f22"}, "r22" }, 1636 { {"f23"}, "r23" }, 1637 { {"f24"}, "r24" }, 1638 { {"f25"}, "r25" }, 1639 { {"f26"}, "r26" }, 1640 { {"f27"}, "r27" }, 1641 { {"f28"}, "r28" }, 1642 { {"f29"}, "r29" }, 1643 { {"f30"}, "r30" }, 1644 { {"f31"}, "r31" }, 1645 }; 1646 1647 void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 1648 unsigned &NumAliases) const { 1649 Aliases = GCCRegAliases; 1650 NumAliases = llvm::array_lengthof(GCCRegAliases); 1651 } 1652 } // end anonymous namespace. 1653 1654 namespace { 1655 // Namespace for x86 abstract base class 1656 const Builtin::Info BuiltinInfo[] = { 1657 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 1658 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 1659 ALL_LANGUAGES }, 1660 #include "clang/Basic/BuiltinsX86.def" 1661 }; 1662 1663 static const char* const GCCRegNames[] = { 1664 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp", 1665 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)", 1666 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame", 1667 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", 1668 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7", 1669 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 1670 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15", 1671 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7", 1672 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15", 1673 }; 1674 1675 const TargetInfo::AddlRegName AddlRegNames[] = { 1676 { { "al", "ah", "eax", "rax" }, 0 }, 1677 { { "bl", "bh", "ebx", "rbx" }, 3 }, 1678 { { "cl", "ch", "ecx", "rcx" }, 2 }, 1679 { { "dl", "dh", "edx", "rdx" }, 1 }, 1680 { { "esi", "rsi" }, 4 }, 1681 { { "edi", "rdi" }, 5 }, 1682 { { "esp", "rsp" }, 7 }, 1683 { { "ebp", "rbp" }, 6 }, 1684 }; 1685 1686 // X86 target abstract base class; x86-32 and x86-64 are very close, so 1687 // most of the implementation can be shared. 1688 class X86TargetInfo : public TargetInfo { 1689 enum X86SSEEnum { 1690 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2 1691 } SSELevel; 1692 enum MMX3DNowEnum { 1693 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon 1694 } MMX3DNowLevel; 1695 1696 bool HasAES; 1697 bool HasPCLMUL; 1698 bool HasLZCNT; 1699 bool HasRDRND; 1700 bool HasBMI; 1701 bool HasBMI2; 1702 bool HasPOPCNT; 1703 bool HasRTM; 1704 bool HasSSE4a; 1705 bool HasFMA4; 1706 bool HasFMA; 1707 bool HasXOP; 1708 bool HasF16C; 1709 1710 /// \brief Enumeration of all of the X86 CPUs supported by Clang. 1711 /// 1712 /// Each enumeration represents a particular CPU supported by Clang. These 1713 /// loosely correspond to the options passed to '-march' or '-mtune' flags. 1714 enum CPUKind { 1715 CK_Generic, 1716 1717 /// \name i386 1718 /// i386-generation processors. 1719 //@{ 1720 CK_i386, 1721 //@} 1722 1723 /// \name i486 1724 /// i486-generation processors. 1725 //@{ 1726 CK_i486, 1727 CK_WinChipC6, 1728 CK_WinChip2, 1729 CK_C3, 1730 //@} 1731 1732 /// \name i586 1733 /// i586-generation processors, P5 microarchitecture based. 1734 //@{ 1735 CK_i586, 1736 CK_Pentium, 1737 CK_PentiumMMX, 1738 //@} 1739 1740 /// \name i686 1741 /// i686-generation processors, P6 / Pentium M microarchitecture based. 1742 //@{ 1743 CK_i686, 1744 CK_PentiumPro, 1745 CK_Pentium2, 1746 CK_Pentium3, 1747 CK_Pentium3M, 1748 CK_PentiumM, 1749 CK_C3_2, 1750 1751 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah. 1752 /// Clang however has some logic to suport this. 1753 // FIXME: Warn, deprecate, and potentially remove this. 1754 CK_Yonah, 1755 //@} 1756 1757 /// \name Netburst 1758 /// Netburst microarchitecture based processors. 1759 //@{ 1760 CK_Pentium4, 1761 CK_Pentium4M, 1762 CK_Prescott, 1763 CK_Nocona, 1764 //@} 1765 1766 /// \name Core 1767 /// Core microarchitecture based processors. 1768 //@{ 1769 CK_Core2, 1770 1771 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another 1772 /// codename which GCC no longer accepts as an option to -march, but Clang 1773 /// has some logic for recognizing it. 1774 // FIXME: Warn, deprecate, and potentially remove this. 1775 CK_Penryn, 1776 //@} 1777 1778 /// \name Atom 1779 /// Atom processors 1780 //@{ 1781 CK_Atom, 1782 //@} 1783 1784 /// \name Nehalem 1785 /// Nehalem microarchitecture based processors. 1786 //@{ 1787 CK_Corei7, 1788 CK_Corei7AVX, 1789 CK_CoreAVXi, 1790 CK_CoreAVX2, 1791 //@} 1792 1793 /// \name K6 1794 /// K6 architecture processors. 1795 //@{ 1796 CK_K6, 1797 CK_K6_2, 1798 CK_K6_3, 1799 //@} 1800 1801 /// \name K7 1802 /// K7 architecture processors. 1803 //@{ 1804 CK_Athlon, 1805 CK_AthlonThunderbird, 1806 CK_Athlon4, 1807 CK_AthlonXP, 1808 CK_AthlonMP, 1809 //@} 1810 1811 /// \name K8 1812 /// K8 architecture processors. 1813 //@{ 1814 CK_Athlon64, 1815 CK_Athlon64SSE3, 1816 CK_AthlonFX, 1817 CK_K8, 1818 CK_K8SSE3, 1819 CK_Opteron, 1820 CK_OpteronSSE3, 1821 CK_AMDFAM10, 1822 //@} 1823 1824 /// \name Bobcat 1825 /// Bobcat architecture processors. 1826 //@{ 1827 CK_BTVER1, 1828 //@} 1829 1830 /// \name Bulldozer 1831 /// Bulldozer architecture processors. 1832 //@{ 1833 CK_BDVER1, 1834 CK_BDVER2, 1835 //@} 1836 1837 /// This specification is deprecated and will be removed in the future. 1838 /// Users should prefer \see CK_K8. 1839 // FIXME: Warn on this when the CPU is set to it. 1840 CK_x86_64, 1841 //@} 1842 1843 /// \name Geode 1844 /// Geode processors. 1845 //@{ 1846 CK_Geode 1847 //@} 1848 } CPU; 1849 1850 public: 1851 X86TargetInfo(const std::string& triple) 1852 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow), 1853 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false), 1854 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false), 1855 HasSSE4a(false), HasFMA4(false), HasFMA(false), HasXOP(false), 1856 HasF16C(false), CPU(CK_Generic) { 1857 BigEndian = false; 1858 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended; 1859 } 1860 virtual unsigned getFloatEvalMethod() const { 1861 // X87 evaluates with 80 bits "long double" precision. 1862 return SSELevel == NoSSE ? 2 : 0; 1863 } 1864 virtual void getTargetBuiltins(const Builtin::Info *&Records, 1865 unsigned &NumRecords) const { 1866 Records = BuiltinInfo; 1867 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin; 1868 } 1869 virtual void getGCCRegNames(const char * const *&Names, 1870 unsigned &NumNames) const { 1871 Names = GCCRegNames; 1872 NumNames = llvm::array_lengthof(GCCRegNames); 1873 } 1874 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 1875 unsigned &NumAliases) const { 1876 Aliases = 0; 1877 NumAliases = 0; 1878 } 1879 virtual void getGCCAddlRegNames(const AddlRegName *&Names, 1880 unsigned &NumNames) const { 1881 Names = AddlRegNames; 1882 NumNames = llvm::array_lengthof(AddlRegNames); 1883 } 1884 virtual bool validateAsmConstraint(const char *&Name, 1885 TargetInfo::ConstraintInfo &info) const; 1886 virtual std::string convertConstraint(const char *&Constraint) const; 1887 virtual const char *getClobbers() const { 1888 return "~{dirflag},~{fpsr},~{flags}"; 1889 } 1890 virtual void getTargetDefines(const LangOptions &Opts, 1891 MacroBuilder &Builder) const; 1892 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features, 1893 StringRef Name, 1894 bool Enabled) const; 1895 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const; 1896 virtual bool hasFeature(StringRef Feature) const; 1897 virtual void HandleTargetFeatures(std::vector<std::string> &Features); 1898 virtual const char* getABI() const { 1899 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX) 1900 return "avx"; 1901 else if (getTriple().getArch() == llvm::Triple::x86 && 1902 MMX3DNowLevel == NoMMX3DNow) 1903 return "no-mmx"; 1904 return ""; 1905 } 1906 virtual bool setCPU(const std::string &Name) { 1907 CPU = llvm::StringSwitch<CPUKind>(Name) 1908 .Case("i386", CK_i386) 1909 .Case("i486", CK_i486) 1910 .Case("winchip-c6", CK_WinChipC6) 1911 .Case("winchip2", CK_WinChip2) 1912 .Case("c3", CK_C3) 1913 .Case("i586", CK_i586) 1914 .Case("pentium", CK_Pentium) 1915 .Case("pentium-mmx", CK_PentiumMMX) 1916 .Case("i686", CK_i686) 1917 .Case("pentiumpro", CK_PentiumPro) 1918 .Case("pentium2", CK_Pentium2) 1919 .Case("pentium3", CK_Pentium3) 1920 .Case("pentium3m", CK_Pentium3M) 1921 .Case("pentium-m", CK_PentiumM) 1922 .Case("c3-2", CK_C3_2) 1923 .Case("yonah", CK_Yonah) 1924 .Case("pentium4", CK_Pentium4) 1925 .Case("pentium4m", CK_Pentium4M) 1926 .Case("prescott", CK_Prescott) 1927 .Case("nocona", CK_Nocona) 1928 .Case("core2", CK_Core2) 1929 .Case("penryn", CK_Penryn) 1930 .Case("atom", CK_Atom) 1931 .Case("corei7", CK_Corei7) 1932 .Case("corei7-avx", CK_Corei7AVX) 1933 .Case("core-avx-i", CK_CoreAVXi) 1934 .Case("core-avx2", CK_CoreAVX2) 1935 .Case("k6", CK_K6) 1936 .Case("k6-2", CK_K6_2) 1937 .Case("k6-3", CK_K6_3) 1938 .Case("athlon", CK_Athlon) 1939 .Case("athlon-tbird", CK_AthlonThunderbird) 1940 .Case("athlon-4", CK_Athlon4) 1941 .Case("athlon-xp", CK_AthlonXP) 1942 .Case("athlon-mp", CK_AthlonMP) 1943 .Case("athlon64", CK_Athlon64) 1944 .Case("athlon64-sse3", CK_Athlon64SSE3) 1945 .Case("athlon-fx", CK_AthlonFX) 1946 .Case("k8", CK_K8) 1947 .Case("k8-sse3", CK_K8SSE3) 1948 .Case("opteron", CK_Opteron) 1949 .Case("opteron-sse3", CK_OpteronSSE3) 1950 .Case("amdfam10", CK_AMDFAM10) 1951 .Case("btver1", CK_BTVER1) 1952 .Case("bdver1", CK_BDVER1) 1953 .Case("bdver2", CK_BDVER2) 1954 .Case("x86-64", CK_x86_64) 1955 .Case("geode", CK_Geode) 1956 .Default(CK_Generic); 1957 1958 // Perform any per-CPU checks necessary to determine if this CPU is 1959 // acceptable. 1960 // FIXME: This results in terrible diagnostics. Clang just says the CPU is 1961 // invalid without explaining *why*. 1962 switch (CPU) { 1963 case CK_Generic: 1964 // No processor selected! 1965 return false; 1966 1967 case CK_i386: 1968 case CK_i486: 1969 case CK_WinChipC6: 1970 case CK_WinChip2: 1971 case CK_C3: 1972 case CK_i586: 1973 case CK_Pentium: 1974 case CK_PentiumMMX: 1975 case CK_i686: 1976 case CK_PentiumPro: 1977 case CK_Pentium2: 1978 case CK_Pentium3: 1979 case CK_Pentium3M: 1980 case CK_PentiumM: 1981 case CK_Yonah: 1982 case CK_C3_2: 1983 case CK_Pentium4: 1984 case CK_Pentium4M: 1985 case CK_Prescott: 1986 case CK_K6: 1987 case CK_K6_2: 1988 case CK_K6_3: 1989 case CK_Athlon: 1990 case CK_AthlonThunderbird: 1991 case CK_Athlon4: 1992 case CK_AthlonXP: 1993 case CK_AthlonMP: 1994 case CK_Geode: 1995 // Only accept certain architectures when compiling in 32-bit mode. 1996 if (getTriple().getArch() != llvm::Triple::x86) 1997 return false; 1998 1999 // Fallthrough 2000 case CK_Nocona: 2001 case CK_Core2: 2002 case CK_Penryn: 2003 case CK_Atom: 2004 case CK_Corei7: 2005 case CK_Corei7AVX: 2006 case CK_CoreAVXi: 2007 case CK_CoreAVX2: 2008 case CK_Athlon64: 2009 case CK_Athlon64SSE3: 2010 case CK_AthlonFX: 2011 case CK_K8: 2012 case CK_K8SSE3: 2013 case CK_Opteron: 2014 case CK_OpteronSSE3: 2015 case CK_AMDFAM10: 2016 case CK_BTVER1: 2017 case CK_BDVER1: 2018 case CK_BDVER2: 2019 case CK_x86_64: 2020 return true; 2021 } 2022 llvm_unreachable("Unhandled CPU kind"); 2023 } 2024 2025 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const { 2026 // We accept all non-ARM calling conventions 2027 return (CC == CC_X86ThisCall || 2028 CC == CC_X86FastCall || 2029 CC == CC_X86StdCall || 2030 CC == CC_C || 2031 CC == CC_X86Pascal || 2032 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning; 2033 } 2034 2035 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const { 2036 return MT == CCMT_Member ? CC_X86ThisCall : CC_C; 2037 } 2038 }; 2039 2040 void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const { 2041 // FIXME: This should not be here. 2042 Features["3dnow"] = false; 2043 Features["3dnowa"] = false; 2044 Features["mmx"] = false; 2045 Features["sse"] = false; 2046 Features["sse2"] = false; 2047 Features["sse3"] = false; 2048 Features["ssse3"] = false; 2049 Features["sse41"] = false; 2050 Features["sse42"] = false; 2051 Features["sse4a"] = false; 2052 Features["aes"] = false; 2053 Features["pclmul"] = false; 2054 Features["avx"] = false; 2055 Features["avx2"] = false; 2056 Features["lzcnt"] = false; 2057 Features["rdrand"] = false; 2058 Features["bmi"] = false; 2059 Features["bmi2"] = false; 2060 Features["popcnt"] = false; 2061 Features["rtm"] = false; 2062 Features["fma4"] = false; 2063 Features["fma"] = false; 2064 Features["xop"] = false; 2065 Features["f16c"] = false; 2066 2067 // FIXME: This *really* should not be here. 2068 2069 // X86_64 always has SSE2. 2070 if (getTriple().getArch() == llvm::Triple::x86_64) 2071 setFeatureEnabled(Features, "sse2", true); 2072 2073 switch (CPU) { 2074 case CK_Generic: 2075 case CK_i386: 2076 case CK_i486: 2077 case CK_i586: 2078 case CK_Pentium: 2079 case CK_i686: 2080 case CK_PentiumPro: 2081 break; 2082 case CK_PentiumMMX: 2083 case CK_Pentium2: 2084 setFeatureEnabled(Features, "mmx", true); 2085 break; 2086 case CK_Pentium3: 2087 case CK_Pentium3M: 2088 setFeatureEnabled(Features, "sse", true); 2089 break; 2090 case CK_PentiumM: 2091 case CK_Pentium4: 2092 case CK_Pentium4M: 2093 case CK_x86_64: 2094 setFeatureEnabled(Features, "sse2", true); 2095 break; 2096 case CK_Yonah: 2097 case CK_Prescott: 2098 case CK_Nocona: 2099 setFeatureEnabled(Features, "sse3", true); 2100 break; 2101 case CK_Core2: 2102 setFeatureEnabled(Features, "ssse3", true); 2103 break; 2104 case CK_Penryn: 2105 setFeatureEnabled(Features, "sse4.1", true); 2106 break; 2107 case CK_Atom: 2108 setFeatureEnabled(Features, "ssse3", true); 2109 break; 2110 case CK_Corei7: 2111 setFeatureEnabled(Features, "sse4", true); 2112 break; 2113 case CK_Corei7AVX: 2114 setFeatureEnabled(Features, "avx", true); 2115 setFeatureEnabled(Features, "aes", true); 2116 setFeatureEnabled(Features, "pclmul", true); 2117 break; 2118 case CK_CoreAVXi: 2119 setFeatureEnabled(Features, "avx", true); 2120 setFeatureEnabled(Features, "aes", true); 2121 setFeatureEnabled(Features, "pclmul", true); 2122 setFeatureEnabled(Features, "rdrnd", true); 2123 setFeatureEnabled(Features, "f16c", true); 2124 break; 2125 case CK_CoreAVX2: 2126 setFeatureEnabled(Features, "avx2", true); 2127 setFeatureEnabled(Features, "aes", true); 2128 setFeatureEnabled(Features, "pclmul", true); 2129 setFeatureEnabled(Features, "lzcnt", true); 2130 setFeatureEnabled(Features, "rdrnd", true); 2131 setFeatureEnabled(Features, "f16c", true); 2132 setFeatureEnabled(Features, "bmi", true); 2133 setFeatureEnabled(Features, "bmi2", true); 2134 setFeatureEnabled(Features, "rtm", true); 2135 setFeatureEnabled(Features, "fma", true); 2136 break; 2137 case CK_K6: 2138 case CK_WinChipC6: 2139 setFeatureEnabled(Features, "mmx", true); 2140 break; 2141 case CK_K6_2: 2142 case CK_K6_3: 2143 case CK_WinChip2: 2144 case CK_C3: 2145 setFeatureEnabled(Features, "3dnow", true); 2146 break; 2147 case CK_Athlon: 2148 case CK_AthlonThunderbird: 2149 case CK_Geode: 2150 setFeatureEnabled(Features, "3dnowa", true); 2151 break; 2152 case CK_Athlon4: 2153 case CK_AthlonXP: 2154 case CK_AthlonMP: 2155 setFeatureEnabled(Features, "sse", true); 2156 setFeatureEnabled(Features, "3dnowa", true); 2157 break; 2158 case CK_K8: 2159 case CK_Opteron: 2160 case CK_Athlon64: 2161 case CK_AthlonFX: 2162 setFeatureEnabled(Features, "sse2", true); 2163 setFeatureEnabled(Features, "3dnowa", true); 2164 break; 2165 case CK_K8SSE3: 2166 case CK_OpteronSSE3: 2167 case CK_Athlon64SSE3: 2168 setFeatureEnabled(Features, "sse3", true); 2169 setFeatureEnabled(Features, "3dnowa", true); 2170 break; 2171 case CK_AMDFAM10: 2172 setFeatureEnabled(Features, "sse3", true); 2173 setFeatureEnabled(Features, "sse4a", true); 2174 setFeatureEnabled(Features, "3dnowa", true); 2175 setFeatureEnabled(Features, "lzcnt", true); 2176 setFeatureEnabled(Features, "popcnt", true); 2177 break; 2178 case CK_BTVER1: 2179 setFeatureEnabled(Features, "ssse3", true); 2180 setFeatureEnabled(Features, "sse4a", true); 2181 setFeatureEnabled(Features, "lzcnt", true); 2182 setFeatureEnabled(Features, "popcnt", true); 2183 break; 2184 case CK_BDVER1: 2185 setFeatureEnabled(Features, "xop", true); 2186 setFeatureEnabled(Features, "lzcnt", true); 2187 setFeatureEnabled(Features, "aes", true); 2188 setFeatureEnabled(Features, "pclmul", true); 2189 break; 2190 case CK_BDVER2: 2191 setFeatureEnabled(Features, "xop", true); 2192 setFeatureEnabled(Features, "lzcnt", true); 2193 setFeatureEnabled(Features, "aes", true); 2194 setFeatureEnabled(Features, "pclmul", true); 2195 setFeatureEnabled(Features, "bmi", true); 2196 setFeatureEnabled(Features, "fma", true); 2197 setFeatureEnabled(Features, "f16c", true); 2198 break; 2199 case CK_C3_2: 2200 setFeatureEnabled(Features, "sse", true); 2201 break; 2202 } 2203 } 2204 2205 bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features, 2206 StringRef Name, 2207 bool Enabled) const { 2208 // FIXME: This *really* should not be here. We need some way of translating 2209 // options into llvm subtarget features. 2210 if (!Features.count(Name) && 2211 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" && 2212 Name != "rdrnd")) 2213 return false; 2214 2215 // FIXME: this should probably use a switch with fall through. 2216 2217 if (Enabled) { 2218 if (Name == "mmx") 2219 Features["mmx"] = true; 2220 else if (Name == "sse") 2221 Features["mmx"] = Features["sse"] = true; 2222 else if (Name == "sse2") 2223 Features["mmx"] = Features["sse"] = Features["sse2"] = true; 2224 else if (Name == "sse3") 2225 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2226 true; 2227 else if (Name == "ssse3") 2228 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2229 Features["ssse3"] = true; 2230 else if (Name == "sse4" || Name == "sse4.2") 2231 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2232 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2233 Features["popcnt"] = true; 2234 else if (Name == "sse4.1") 2235 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2236 Features["ssse3"] = Features["sse41"] = true; 2237 else if (Name == "3dnow") 2238 Features["mmx"] = Features["3dnow"] = true; 2239 else if (Name == "3dnowa") 2240 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true; 2241 else if (Name == "aes") 2242 Features["sse"] = Features["sse2"] = Features["aes"] = true; 2243 else if (Name == "pclmul") 2244 Features["sse"] = Features["sse2"] = Features["pclmul"] = true; 2245 else if (Name == "avx") 2246 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2247 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2248 Features["popcnt"] = Features["avx"] = true; 2249 else if (Name == "avx2") 2250 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2251 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2252 Features["popcnt"] = Features["avx"] = Features["avx2"] = true; 2253 else if (Name == "fma") 2254 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2255 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2256 Features["popcnt"] = Features["avx"] = Features["fma"] = true; 2257 else if (Name == "fma4") 2258 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2259 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2260 Features["popcnt"] = Features["avx"] = Features["sse4a"] = 2261 Features["fma4"] = true; 2262 else if (Name == "xop") 2263 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2264 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2265 Features["popcnt"] = Features["avx"] = Features["sse4a"] = 2266 Features["fma4"] = Features["xop"] = true; 2267 else if (Name == "sse4a") 2268 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] = 2269 Features["sse4a"] = true; 2270 else if (Name == "lzcnt") 2271 Features["lzcnt"] = true; 2272 else if (Name == "rdrnd") 2273 Features["rdrand"] = true; 2274 else if (Name == "bmi") 2275 Features["bmi"] = true; 2276 else if (Name == "bmi2") 2277 Features["bmi2"] = true; 2278 else if (Name == "popcnt") 2279 Features["popcnt"] = true; 2280 else if (Name == "f16c") 2281 Features["f16c"] = true; 2282 else if (Name == "rtm") 2283 Features["rtm"] = true; 2284 } else { 2285 if (Name == "mmx") 2286 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false; 2287 else if (Name == "sse") 2288 Features["sse"] = Features["sse2"] = Features["sse3"] = 2289 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2290 Features["sse4a"] = Features["avx"] = Features["avx2"] = 2291 Features["fma"] = Features["fma4"] = Features["aes"] = 2292 Features["pclmul"] = Features["xop"] = false; 2293 else if (Name == "sse2") 2294 Features["sse2"] = Features["sse3"] = Features["ssse3"] = 2295 Features["sse41"] = Features["sse42"] = Features["sse4a"] = 2296 Features["avx"] = Features["avx2"] = Features["fma"] = 2297 Features["fma4"] = Features["aes"] = Features["pclmul"] = 2298 Features["xop"] = false; 2299 else if (Name == "sse3") 2300 Features["sse3"] = Features["ssse3"] = Features["sse41"] = 2301 Features["sse42"] = Features["sse4a"] = Features["avx"] = 2302 Features["avx2"] = Features["fma"] = Features["fma4"] = 2303 Features["xop"] = false; 2304 else if (Name == "ssse3") 2305 Features["ssse3"] = Features["sse41"] = Features["sse42"] = 2306 Features["avx"] = Features["avx2"] = Features["fma"] = false; 2307 else if (Name == "sse4" || Name == "sse4.1") 2308 Features["sse41"] = Features["sse42"] = Features["avx"] = 2309 Features["avx2"] = Features["fma"] = false; 2310 else if (Name == "sse4.2") 2311 Features["sse42"] = Features["avx"] = Features["avx2"] = 2312 Features["fma"] = false; 2313 else if (Name == "3dnow") 2314 Features["3dnow"] = Features["3dnowa"] = false; 2315 else if (Name == "3dnowa") 2316 Features["3dnowa"] = false; 2317 else if (Name == "aes") 2318 Features["aes"] = false; 2319 else if (Name == "pclmul") 2320 Features["pclmul"] = false; 2321 else if (Name == "avx") 2322 Features["avx"] = Features["avx2"] = Features["fma"] = 2323 Features["fma4"] = Features["xop"] = false; 2324 else if (Name == "avx2") 2325 Features["avx2"] = false; 2326 else if (Name == "fma") 2327 Features["fma"] = false; 2328 else if (Name == "sse4a") 2329 Features["sse4a"] = Features["fma4"] = Features["xop"] = false; 2330 else if (Name == "lzcnt") 2331 Features["lzcnt"] = false; 2332 else if (Name == "rdrnd") 2333 Features["rdrand"] = false; 2334 else if (Name == "bmi") 2335 Features["bmi"] = false; 2336 else if (Name == "bmi2") 2337 Features["bmi2"] = false; 2338 else if (Name == "popcnt") 2339 Features["popcnt"] = false; 2340 else if (Name == "fma4") 2341 Features["fma4"] = Features["xop"] = false; 2342 else if (Name == "xop") 2343 Features["xop"] = false; 2344 else if (Name == "f16c") 2345 Features["f16c"] = false; 2346 else if (Name == "rtm") 2347 Features["rtm"] = false; 2348 } 2349 2350 return true; 2351 } 2352 2353 /// HandleTargetOptions - Perform initialization based on the user 2354 /// configured set of features. 2355 void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) { 2356 // Remember the maximum enabled sselevel. 2357 for (unsigned i = 0, e = Features.size(); i !=e; ++i) { 2358 // Ignore disabled features. 2359 if (Features[i][0] == '-') 2360 continue; 2361 2362 StringRef Feature = StringRef(Features[i]).substr(1); 2363 2364 if (Feature == "aes") { 2365 HasAES = true; 2366 continue; 2367 } 2368 2369 if (Feature == "pclmul") { 2370 HasPCLMUL = true; 2371 continue; 2372 } 2373 2374 if (Feature == "lzcnt") { 2375 HasLZCNT = true; 2376 continue; 2377 } 2378 2379 if (Feature == "rdrand") { 2380 HasRDRND = true; 2381 continue; 2382 } 2383 2384 if (Feature == "bmi") { 2385 HasBMI = true; 2386 continue; 2387 } 2388 2389 if (Feature == "bmi2") { 2390 HasBMI2 = true; 2391 continue; 2392 } 2393 2394 if (Feature == "popcnt") { 2395 HasPOPCNT = true; 2396 continue; 2397 } 2398 2399 if (Feature == "rtm") { 2400 HasRTM = true; 2401 continue; 2402 } 2403 2404 if (Feature == "sse4a") { 2405 HasSSE4a = true; 2406 continue; 2407 } 2408 2409 if (Feature == "fma4") { 2410 HasFMA4 = true; 2411 continue; 2412 } 2413 2414 if (Feature == "fma") { 2415 HasFMA = true; 2416 continue; 2417 } 2418 2419 if (Feature == "xop") { 2420 HasXOP = true; 2421 continue; 2422 } 2423 2424 if (Feature == "f16c") { 2425 HasF16C = true; 2426 continue; 2427 } 2428 2429 assert(Features[i][0] == '+' && "Invalid target feature!"); 2430 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature) 2431 .Case("avx2", AVX2) 2432 .Case("avx", AVX) 2433 .Case("sse42", SSE42) 2434 .Case("sse41", SSE41) 2435 .Case("ssse3", SSSE3) 2436 .Case("sse3", SSE3) 2437 .Case("sse2", SSE2) 2438 .Case("sse", SSE1) 2439 .Default(NoSSE); 2440 SSELevel = std::max(SSELevel, Level); 2441 2442 MMX3DNowEnum ThreeDNowLevel = 2443 llvm::StringSwitch<MMX3DNowEnum>(Feature) 2444 .Case("3dnowa", AMD3DNowAthlon) 2445 .Case("3dnow", AMD3DNow) 2446 .Case("mmx", MMX) 2447 .Default(NoMMX3DNow); 2448 2449 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel); 2450 } 2451 2452 // Don't tell the backend if we're turning off mmx; it will end up disabling 2453 // SSE, which we don't want. 2454 std::vector<std::string>::iterator it; 2455 it = std::find(Features.begin(), Features.end(), "-mmx"); 2456 if (it != Features.end()) 2457 Features.erase(it); 2458 } 2459 2460 /// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro 2461 /// definitions for this particular subtarget. 2462 void X86TargetInfo::getTargetDefines(const LangOptions &Opts, 2463 MacroBuilder &Builder) const { 2464 // Target identification. 2465 if (getTriple().getArch() == llvm::Triple::x86_64) { 2466 Builder.defineMacro("__amd64__"); 2467 Builder.defineMacro("__amd64"); 2468 Builder.defineMacro("__x86_64"); 2469 Builder.defineMacro("__x86_64__"); 2470 } else { 2471 DefineStd(Builder, "i386", Opts); 2472 } 2473 2474 // Subtarget options. 2475 // FIXME: We are hard-coding the tune parameters based on the CPU, but they 2476 // truly should be based on -mtune options. 2477 switch (CPU) { 2478 case CK_Generic: 2479 break; 2480 case CK_i386: 2481 // The rest are coming from the i386 define above. 2482 Builder.defineMacro("__tune_i386__"); 2483 break; 2484 case CK_i486: 2485 case CK_WinChipC6: 2486 case CK_WinChip2: 2487 case CK_C3: 2488 defineCPUMacros(Builder, "i486"); 2489 break; 2490 case CK_PentiumMMX: 2491 Builder.defineMacro("__pentium_mmx__"); 2492 Builder.defineMacro("__tune_pentium_mmx__"); 2493 // Fallthrough 2494 case CK_i586: 2495 case CK_Pentium: 2496 defineCPUMacros(Builder, "i586"); 2497 defineCPUMacros(Builder, "pentium"); 2498 break; 2499 case CK_Pentium3: 2500 case CK_Pentium3M: 2501 case CK_PentiumM: 2502 Builder.defineMacro("__tune_pentium3__"); 2503 // Fallthrough 2504 case CK_Pentium2: 2505 case CK_C3_2: 2506 Builder.defineMacro("__tune_pentium2__"); 2507 // Fallthrough 2508 case CK_PentiumPro: 2509 Builder.defineMacro("__tune_i686__"); 2510 Builder.defineMacro("__tune_pentiumpro__"); 2511 // Fallthrough 2512 case CK_i686: 2513 Builder.defineMacro("__i686"); 2514 Builder.defineMacro("__i686__"); 2515 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686. 2516 Builder.defineMacro("__pentiumpro"); 2517 Builder.defineMacro("__pentiumpro__"); 2518 break; 2519 case CK_Pentium4: 2520 case CK_Pentium4M: 2521 defineCPUMacros(Builder, "pentium4"); 2522 break; 2523 case CK_Yonah: 2524 case CK_Prescott: 2525 case CK_Nocona: 2526 defineCPUMacros(Builder, "nocona"); 2527 break; 2528 case CK_Core2: 2529 case CK_Penryn: 2530 defineCPUMacros(Builder, "core2"); 2531 break; 2532 case CK_Atom: 2533 defineCPUMacros(Builder, "atom"); 2534 break; 2535 case CK_Corei7: 2536 case CK_Corei7AVX: 2537 case CK_CoreAVXi: 2538 case CK_CoreAVX2: 2539 defineCPUMacros(Builder, "corei7"); 2540 break; 2541 case CK_K6_2: 2542 Builder.defineMacro("__k6_2__"); 2543 Builder.defineMacro("__tune_k6_2__"); 2544 // Fallthrough 2545 case CK_K6_3: 2546 if (CPU != CK_K6_2) { // In case of fallthrough 2547 // FIXME: GCC may be enabling these in cases where some other k6 2548 // architecture is specified but -m3dnow is explicitly provided. The 2549 // exact semantics need to be determined and emulated here. 2550 Builder.defineMacro("__k6_3__"); 2551 Builder.defineMacro("__tune_k6_3__"); 2552 } 2553 // Fallthrough 2554 case CK_K6: 2555 defineCPUMacros(Builder, "k6"); 2556 break; 2557 case CK_Athlon: 2558 case CK_AthlonThunderbird: 2559 case CK_Athlon4: 2560 case CK_AthlonXP: 2561 case CK_AthlonMP: 2562 defineCPUMacros(Builder, "athlon"); 2563 if (SSELevel != NoSSE) { 2564 Builder.defineMacro("__athlon_sse__"); 2565 Builder.defineMacro("__tune_athlon_sse__"); 2566 } 2567 break; 2568 case CK_K8: 2569 case CK_K8SSE3: 2570 case CK_x86_64: 2571 case CK_Opteron: 2572 case CK_OpteronSSE3: 2573 case CK_Athlon64: 2574 case CK_Athlon64SSE3: 2575 case CK_AthlonFX: 2576 defineCPUMacros(Builder, "k8"); 2577 break; 2578 case CK_AMDFAM10: 2579 defineCPUMacros(Builder, "amdfam10"); 2580 break; 2581 case CK_BTVER1: 2582 defineCPUMacros(Builder, "btver1"); 2583 break; 2584 case CK_BDVER1: 2585 defineCPUMacros(Builder, "bdver1"); 2586 break; 2587 case CK_BDVER2: 2588 defineCPUMacros(Builder, "bdver2"); 2589 break; 2590 case CK_Geode: 2591 defineCPUMacros(Builder, "geode"); 2592 break; 2593 } 2594 2595 // Target properties. 2596 Builder.defineMacro("__LITTLE_ENDIAN__"); 2597 Builder.defineMacro("__REGISTER_PREFIX__", ""); 2598 2599 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline 2600 // functions in glibc header files that use FP Stack inline asm which the 2601 // backend can't deal with (PR879). 2602 Builder.defineMacro("__NO_MATH_INLINES"); 2603 2604 if (HasAES) 2605 Builder.defineMacro("__AES__"); 2606 2607 if (HasPCLMUL) 2608 Builder.defineMacro("__PCLMUL__"); 2609 2610 if (HasLZCNT) 2611 Builder.defineMacro("__LZCNT__"); 2612 2613 if (HasRDRND) 2614 Builder.defineMacro("__RDRND__"); 2615 2616 if (HasBMI) 2617 Builder.defineMacro("__BMI__"); 2618 2619 if (HasBMI2) 2620 Builder.defineMacro("__BMI2__"); 2621 2622 if (HasPOPCNT) 2623 Builder.defineMacro("__POPCNT__"); 2624 2625 if (HasRTM) 2626 Builder.defineMacro("__RTM__"); 2627 2628 if (HasSSE4a) 2629 Builder.defineMacro("__SSE4A__"); 2630 2631 if (HasFMA4) 2632 Builder.defineMacro("__FMA4__"); 2633 2634 if (HasFMA) 2635 Builder.defineMacro("__FMA__"); 2636 2637 if (HasXOP) 2638 Builder.defineMacro("__XOP__"); 2639 2640 if (HasF16C) 2641 Builder.defineMacro("__F16C__"); 2642 2643 // Each case falls through to the previous one here. 2644 switch (SSELevel) { 2645 case AVX2: 2646 Builder.defineMacro("__AVX2__"); 2647 case AVX: 2648 Builder.defineMacro("__AVX__"); 2649 case SSE42: 2650 Builder.defineMacro("__SSE4_2__"); 2651 case SSE41: 2652 Builder.defineMacro("__SSE4_1__"); 2653 case SSSE3: 2654 Builder.defineMacro("__SSSE3__"); 2655 case SSE3: 2656 Builder.defineMacro("__SSE3__"); 2657 case SSE2: 2658 Builder.defineMacro("__SSE2__"); 2659 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied. 2660 case SSE1: 2661 Builder.defineMacro("__SSE__"); 2662 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied. 2663 case NoSSE: 2664 break; 2665 } 2666 2667 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) { 2668 switch (SSELevel) { 2669 case AVX2: 2670 case AVX: 2671 case SSE42: 2672 case SSE41: 2673 case SSSE3: 2674 case SSE3: 2675 case SSE2: 2676 Builder.defineMacro("_M_IX86_FP", Twine(2)); 2677 break; 2678 case SSE1: 2679 Builder.defineMacro("_M_IX86_FP", Twine(1)); 2680 break; 2681 default: 2682 Builder.defineMacro("_M_IX86_FP", Twine(0)); 2683 } 2684 } 2685 2686 // Each case falls through to the previous one here. 2687 switch (MMX3DNowLevel) { 2688 case AMD3DNowAthlon: 2689 Builder.defineMacro("__3dNOW_A__"); 2690 case AMD3DNow: 2691 Builder.defineMacro("__3dNOW__"); 2692 case MMX: 2693 Builder.defineMacro("__MMX__"); 2694 case NoMMX3DNow: 2695 break; 2696 } 2697 } 2698 2699 bool X86TargetInfo::hasFeature(StringRef Feature) const { 2700 return llvm::StringSwitch<bool>(Feature) 2701 .Case("aes", HasAES) 2702 .Case("avx", SSELevel >= AVX) 2703 .Case("avx2", SSELevel >= AVX2) 2704 .Case("bmi", HasBMI) 2705 .Case("bmi2", HasBMI2) 2706 .Case("fma", HasFMA) 2707 .Case("fma4", HasFMA4) 2708 .Case("lzcnt", HasLZCNT) 2709 .Case("rdrnd", HasRDRND) 2710 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow) 2711 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon) 2712 .Case("mmx", MMX3DNowLevel >= MMX) 2713 .Case("pclmul", HasPCLMUL) 2714 .Case("popcnt", HasPOPCNT) 2715 .Case("rtm", HasRTM) 2716 .Case("sse", SSELevel >= SSE1) 2717 .Case("sse2", SSELevel >= SSE2) 2718 .Case("sse3", SSELevel >= SSE3) 2719 .Case("ssse3", SSELevel >= SSSE3) 2720 .Case("sse41", SSELevel >= SSE41) 2721 .Case("sse42", SSELevel >= SSE42) 2722 .Case("sse4a", HasSSE4a) 2723 .Case("x86", true) 2724 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86) 2725 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64) 2726 .Case("xop", HasXOP) 2727 .Case("f16c", HasF16C) 2728 .Default(false); 2729 } 2730 2731 bool 2732 X86TargetInfo::validateAsmConstraint(const char *&Name, 2733 TargetInfo::ConstraintInfo &Info) const { 2734 switch (*Name) { 2735 default: return false; 2736 case 'Y': // first letter of a pair: 2737 switch (*(Name+1)) { 2738 default: return false; 2739 case '0': // First SSE register. 2740 case 't': // Any SSE register, when SSE2 is enabled. 2741 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled. 2742 case 'm': // any MMX register, when inter-unit moves enabled. 2743 break; // falls through to setAllowsRegister. 2744 } 2745 case 'a': // eax. 2746 case 'b': // ebx. 2747 case 'c': // ecx. 2748 case 'd': // edx. 2749 case 'S': // esi. 2750 case 'D': // edi. 2751 case 'A': // edx:eax. 2752 case 'f': // any x87 floating point stack register. 2753 case 't': // top of floating point stack. 2754 case 'u': // second from top of floating point stack. 2755 case 'q': // Any register accessible as [r]l: a, b, c, and d. 2756 case 'y': // Any MMX register. 2757 case 'x': // Any SSE register. 2758 case 'Q': // Any register accessible as [r]h: a, b, c, and d. 2759 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp. 2760 case 'l': // "Index" registers: any general register that can be used as an 2761 // index in a base+index memory access. 2762 Info.setAllowsRegister(); 2763 return true; 2764 case 'C': // SSE floating point constant. 2765 case 'G': // x87 floating point constant. 2766 case 'e': // 32-bit signed integer constant for use with zero-extending 2767 // x86_64 instructions. 2768 case 'Z': // 32-bit unsigned integer constant for use with zero-extending 2769 // x86_64 instructions. 2770 return true; 2771 } 2772 } 2773 2774 2775 std::string 2776 X86TargetInfo::convertConstraint(const char *&Constraint) const { 2777 switch (*Constraint) { 2778 case 'a': return std::string("{ax}"); 2779 case 'b': return std::string("{bx}"); 2780 case 'c': return std::string("{cx}"); 2781 case 'd': return std::string("{dx}"); 2782 case 'S': return std::string("{si}"); 2783 case 'D': return std::string("{di}"); 2784 case 'p': // address 2785 return std::string("im"); 2786 case 't': // top of floating point stack. 2787 return std::string("{st}"); 2788 case 'u': // second from top of floating point stack. 2789 return std::string("{st(1)}"); // second from top of floating point stack. 2790 default: 2791 return std::string(1, *Constraint); 2792 } 2793 } 2794 } // end anonymous namespace 2795 2796 namespace { 2797 // X86-32 generic target 2798 class X86_32TargetInfo : public X86TargetInfo { 2799 public: 2800 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) { 2801 DoubleAlign = LongLongAlign = 32; 2802 LongDoubleWidth = 96; 2803 LongDoubleAlign = 32; 2804 SuitableAlign = 128; 2805 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 2806 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-" 2807 "a0:0:64-f80:32:32-n8:16:32-S128"; 2808 SizeType = UnsignedInt; 2809 PtrDiffType = SignedInt; 2810 IntPtrType = SignedInt; 2811 RegParmMax = 3; 2812 2813 // Use fpret for all types. 2814 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) | 2815 (1 << TargetInfo::Double) | 2816 (1 << TargetInfo::LongDouble)); 2817 2818 // x86-32 has atomics up to 8 bytes 2819 // FIXME: Check that we actually have cmpxchg8b before setting 2820 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.) 2821 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 2822 } 2823 virtual BuiltinVaListKind getBuiltinVaListKind() const { 2824 return TargetInfo::CharPtrBuiltinVaList; 2825 } 2826 2827 int getEHDataRegisterNumber(unsigned RegNo) const { 2828 if (RegNo == 0) return 0; 2829 if (RegNo == 1) return 2; 2830 return -1; 2831 } 2832 virtual bool validateInputSize(StringRef Constraint, 2833 unsigned Size) const { 2834 switch (Constraint[0]) { 2835 default: break; 2836 case 'a': 2837 case 'b': 2838 case 'c': 2839 case 'd': 2840 return Size <= 32; 2841 } 2842 2843 return true; 2844 } 2845 }; 2846 } // end anonymous namespace 2847 2848 namespace { 2849 class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> { 2850 public: 2851 NetBSDI386TargetInfo(const std::string &triple) : 2852 NetBSDTargetInfo<X86_32TargetInfo>(triple) { 2853 } 2854 2855 virtual unsigned getFloatEvalMethod() const { 2856 // NetBSD defaults to "double" rounding 2857 return 1; 2858 } 2859 }; 2860 } // end anonymous namespace 2861 2862 namespace { 2863 class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> { 2864 public: 2865 OpenBSDI386TargetInfo(const std::string& triple) : 2866 OpenBSDTargetInfo<X86_32TargetInfo>(triple) { 2867 SizeType = UnsignedLong; 2868 IntPtrType = SignedLong; 2869 PtrDiffType = SignedLong; 2870 } 2871 }; 2872 } // end anonymous namespace 2873 2874 namespace { 2875 class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> { 2876 public: 2877 BitrigI386TargetInfo(const std::string& triple) : 2878 BitrigTargetInfo<X86_32TargetInfo>(triple) { 2879 SizeType = UnsignedLong; 2880 IntPtrType = SignedLong; 2881 PtrDiffType = SignedLong; 2882 } 2883 }; 2884 } // end anonymous namespace 2885 2886 namespace { 2887 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> { 2888 public: 2889 DarwinI386TargetInfo(const std::string& triple) : 2890 DarwinTargetInfo<X86_32TargetInfo>(triple) { 2891 LongDoubleWidth = 128; 2892 LongDoubleAlign = 128; 2893 SuitableAlign = 128; 2894 MaxVectorAlign = 256; 2895 SizeType = UnsignedLong; 2896 IntPtrType = SignedLong; 2897 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 2898 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-" 2899 "a0:0:64-f80:128:128-n8:16:32-S128"; 2900 HasAlignMac68kSupport = true; 2901 } 2902 2903 }; 2904 } // end anonymous namespace 2905 2906 namespace { 2907 // x86-32 Windows target 2908 class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> { 2909 public: 2910 WindowsX86_32TargetInfo(const std::string& triple) 2911 : WindowsTargetInfo<X86_32TargetInfo>(triple) { 2912 TLSSupported = false; 2913 WCharType = UnsignedShort; 2914 DoubleAlign = LongLongAlign = 64; 2915 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 2916 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-" 2917 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32"; 2918 } 2919 virtual void getTargetDefines(const LangOptions &Opts, 2920 MacroBuilder &Builder) const { 2921 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder); 2922 } 2923 }; 2924 } // end anonymous namespace 2925 2926 namespace { 2927 2928 // x86-32 Windows Visual Studio target 2929 class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo { 2930 public: 2931 VisualStudioWindowsX86_32TargetInfo(const std::string& triple) 2932 : WindowsX86_32TargetInfo(triple) { 2933 LongDoubleWidth = LongDoubleAlign = 64; 2934 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 2935 } 2936 virtual void getTargetDefines(const LangOptions &Opts, 2937 MacroBuilder &Builder) const { 2938 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder); 2939 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder); 2940 // The value of the following reflects processor type. 2941 // 300=386, 400=486, 500=Pentium, 600=Blend (default) 2942 // We lost the original triple, so we use the default. 2943 Builder.defineMacro("_M_IX86", "600"); 2944 } 2945 }; 2946 } // end anonymous namespace 2947 2948 namespace { 2949 // x86-32 MinGW target 2950 class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo { 2951 public: 2952 MinGWX86_32TargetInfo(const std::string& triple) 2953 : WindowsX86_32TargetInfo(triple) { 2954 } 2955 virtual void getTargetDefines(const LangOptions &Opts, 2956 MacroBuilder &Builder) const { 2957 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder); 2958 DefineStd(Builder, "WIN32", Opts); 2959 DefineStd(Builder, "WINNT", Opts); 2960 Builder.defineMacro("_X86_"); 2961 Builder.defineMacro("__MSVCRT__"); 2962 Builder.defineMacro("__MINGW32__"); 2963 2964 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)). 2965 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions. 2966 if (Opts.MicrosoftExt) 2967 // Provide "as-is" __declspec. 2968 Builder.defineMacro("__declspec", "__declspec"); 2969 else 2970 // Provide alias of __attribute__ like mingw32-gcc. 2971 Builder.defineMacro("__declspec(a)", "__attribute__((a))"); 2972 } 2973 }; 2974 } // end anonymous namespace 2975 2976 namespace { 2977 // x86-32 Cygwin target 2978 class CygwinX86_32TargetInfo : public X86_32TargetInfo { 2979 public: 2980 CygwinX86_32TargetInfo(const std::string& triple) 2981 : X86_32TargetInfo(triple) { 2982 TLSSupported = false; 2983 WCharType = UnsignedShort; 2984 DoubleAlign = LongLongAlign = 64; 2985 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 2986 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-" 2987 "a0:0:64-f80:32:32-n8:16:32-S32"; 2988 } 2989 virtual void getTargetDefines(const LangOptions &Opts, 2990 MacroBuilder &Builder) const { 2991 X86_32TargetInfo::getTargetDefines(Opts, Builder); 2992 Builder.defineMacro("_X86_"); 2993 Builder.defineMacro("__CYGWIN__"); 2994 Builder.defineMacro("__CYGWIN32__"); 2995 DefineStd(Builder, "unix", Opts); 2996 if (Opts.CPlusPlus) 2997 Builder.defineMacro("_GNU_SOURCE"); 2998 } 2999 }; 3000 } // end anonymous namespace 3001 3002 namespace { 3003 // x86-32 Haiku target 3004 class HaikuX86_32TargetInfo : public X86_32TargetInfo { 3005 public: 3006 HaikuX86_32TargetInfo(const std::string& triple) 3007 : X86_32TargetInfo(triple) { 3008 SizeType = UnsignedLong; 3009 IntPtrType = SignedLong; 3010 PtrDiffType = SignedLong; 3011 ProcessIDType = SignedLong; 3012 this->UserLabelPrefix = ""; 3013 this->TLSSupported = false; 3014 } 3015 virtual void getTargetDefines(const LangOptions &Opts, 3016 MacroBuilder &Builder) const { 3017 X86_32TargetInfo::getTargetDefines(Opts, Builder); 3018 Builder.defineMacro("__INTEL__"); 3019 Builder.defineMacro("__HAIKU__"); 3020 } 3021 }; 3022 } // end anonymous namespace 3023 3024 // RTEMS Target 3025 template<typename Target> 3026 class RTEMSTargetInfo : public OSTargetInfo<Target> { 3027 protected: 3028 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 3029 MacroBuilder &Builder) const { 3030 // RTEMS defines; list based off of gcc output 3031 3032 Builder.defineMacro("__rtems__"); 3033 Builder.defineMacro("__ELF__"); 3034 } 3035 public: 3036 RTEMSTargetInfo(const std::string &triple) 3037 : OSTargetInfo<Target>(triple) { 3038 this->UserLabelPrefix = ""; 3039 3040 llvm::Triple Triple(triple); 3041 switch (Triple.getArch()) { 3042 default: 3043 case llvm::Triple::x86: 3044 // this->MCountName = ".mcount"; 3045 break; 3046 case llvm::Triple::mips: 3047 case llvm::Triple::mipsel: 3048 case llvm::Triple::ppc: 3049 case llvm::Triple::ppc64: 3050 // this->MCountName = "_mcount"; 3051 break; 3052 case llvm::Triple::arm: 3053 // this->MCountName = "__mcount"; 3054 break; 3055 } 3056 3057 } 3058 }; 3059 3060 namespace { 3061 // x86-32 RTEMS target 3062 class RTEMSX86_32TargetInfo : public X86_32TargetInfo { 3063 public: 3064 RTEMSX86_32TargetInfo(const std::string& triple) 3065 : X86_32TargetInfo(triple) { 3066 SizeType = UnsignedLong; 3067 IntPtrType = SignedLong; 3068 PtrDiffType = SignedLong; 3069 this->UserLabelPrefix = ""; 3070 } 3071 virtual void getTargetDefines(const LangOptions &Opts, 3072 MacroBuilder &Builder) const { 3073 X86_32TargetInfo::getTargetDefines(Opts, Builder); 3074 Builder.defineMacro("__INTEL__"); 3075 Builder.defineMacro("__rtems__"); 3076 } 3077 }; 3078 } // end anonymous namespace 3079 3080 namespace { 3081 // x86-64 generic target 3082 class X86_64TargetInfo : public X86TargetInfo { 3083 public: 3084 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) { 3085 LongWidth = LongAlign = PointerWidth = PointerAlign = 64; 3086 LongDoubleWidth = 128; 3087 LongDoubleAlign = 128; 3088 LargeArrayMinWidth = 128; 3089 LargeArrayAlign = 128; 3090 SuitableAlign = 128; 3091 IntMaxType = SignedLong; 3092 UIntMaxType = UnsignedLong; 3093 Int64Type = SignedLong; 3094 RegParmMax = 6; 3095 3096 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 3097 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-" 3098 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"; 3099 3100 // Use fpret only for long double. 3101 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble); 3102 3103 // Use fp2ret for _Complex long double. 3104 ComplexLongDoubleUsesFP2Ret = true; 3105 3106 // x86-64 has atomics up to 16 bytes. 3107 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128 3108 // on CPUs with cmpxchg16b 3109 MaxAtomicPromoteWidth = 128; 3110 MaxAtomicInlineWidth = 64; 3111 } 3112 virtual BuiltinVaListKind getBuiltinVaListKind() const { 3113 return TargetInfo::X86_64ABIBuiltinVaList; 3114 } 3115 3116 int getEHDataRegisterNumber(unsigned RegNo) const { 3117 if (RegNo == 0) return 0; 3118 if (RegNo == 1) return 1; 3119 return -1; 3120 } 3121 3122 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const { 3123 return (CC == CC_Default || 3124 CC == CC_C || 3125 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning; 3126 } 3127 3128 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const { 3129 return CC_C; 3130 } 3131 3132 }; 3133 } // end anonymous namespace 3134 3135 namespace { 3136 // x86-64 Windows target 3137 class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> { 3138 public: 3139 WindowsX86_64TargetInfo(const std::string& triple) 3140 : WindowsTargetInfo<X86_64TargetInfo>(triple) { 3141 TLSSupported = false; 3142 WCharType = UnsignedShort; 3143 LongWidth = LongAlign = 32; 3144 DoubleAlign = LongLongAlign = 64; 3145 IntMaxType = SignedLongLong; 3146 UIntMaxType = UnsignedLongLong; 3147 Int64Type = SignedLongLong; 3148 SizeType = UnsignedLongLong; 3149 PtrDiffType = SignedLongLong; 3150 IntPtrType = SignedLongLong; 3151 this->UserLabelPrefix = ""; 3152 } 3153 virtual void getTargetDefines(const LangOptions &Opts, 3154 MacroBuilder &Builder) const { 3155 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder); 3156 Builder.defineMacro("_WIN64"); 3157 } 3158 virtual BuiltinVaListKind getBuiltinVaListKind() const { 3159 return TargetInfo::CharPtrBuiltinVaList; 3160 } 3161 }; 3162 } // end anonymous namespace 3163 3164 namespace { 3165 // x86-64 Windows Visual Studio target 3166 class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo { 3167 public: 3168 VisualStudioWindowsX86_64TargetInfo(const std::string& triple) 3169 : WindowsX86_64TargetInfo(triple) { 3170 LongDoubleWidth = LongDoubleAlign = 64; 3171 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 3172 } 3173 virtual void getTargetDefines(const LangOptions &Opts, 3174 MacroBuilder &Builder) const { 3175 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder); 3176 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder); 3177 Builder.defineMacro("_M_X64"); 3178 Builder.defineMacro("_M_AMD64"); 3179 } 3180 }; 3181 } // end anonymous namespace 3182 3183 namespace { 3184 // x86-64 MinGW target 3185 class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo { 3186 public: 3187 MinGWX86_64TargetInfo(const std::string& triple) 3188 : WindowsX86_64TargetInfo(triple) { 3189 } 3190 virtual void getTargetDefines(const LangOptions &Opts, 3191 MacroBuilder &Builder) const { 3192 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder); 3193 DefineStd(Builder, "WIN64", Opts); 3194 Builder.defineMacro("__MSVCRT__"); 3195 Builder.defineMacro("__MINGW32__"); 3196 Builder.defineMacro("__MINGW64__"); 3197 3198 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)). 3199 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions. 3200 if (Opts.MicrosoftExt) 3201 // Provide "as-is" __declspec. 3202 Builder.defineMacro("__declspec", "__declspec"); 3203 else 3204 // Provide alias of __attribute__ like mingw32-gcc. 3205 Builder.defineMacro("__declspec(a)", "__attribute__((a))"); 3206 } 3207 }; 3208 } // end anonymous namespace 3209 3210 namespace { 3211 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> { 3212 public: 3213 DarwinX86_64TargetInfo(const std::string& triple) 3214 : DarwinTargetInfo<X86_64TargetInfo>(triple) { 3215 Int64Type = SignedLongLong; 3216 MaxVectorAlign = 256; 3217 } 3218 }; 3219 } // end anonymous namespace 3220 3221 namespace { 3222 class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> { 3223 public: 3224 OpenBSDX86_64TargetInfo(const std::string& triple) 3225 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) { 3226 IntMaxType = SignedLongLong; 3227 UIntMaxType = UnsignedLongLong; 3228 Int64Type = SignedLongLong; 3229 } 3230 }; 3231 } // end anonymous namespace 3232 3233 namespace { 3234 class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> { 3235 public: 3236 BitrigX86_64TargetInfo(const std::string& triple) 3237 : BitrigTargetInfo<X86_64TargetInfo>(triple) { 3238 IntMaxType = SignedLongLong; 3239 UIntMaxType = UnsignedLongLong; 3240 Int64Type = SignedLongLong; 3241 } 3242 }; 3243 } 3244 3245 namespace { 3246 class AArch64TargetInfo : public TargetInfo { 3247 static const char * const GCCRegNames[]; 3248 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 3249 public: 3250 AArch64TargetInfo(const std::string& triple) : TargetInfo(triple) { 3251 BigEndian = false; 3252 LongWidth = LongAlign = 64; 3253 LongDoubleWidth = LongDoubleAlign = 128; 3254 PointerWidth = PointerAlign = 64; 3255 SuitableAlign = 128; 3256 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 3257 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-" 3258 "f128:128:128-n32:64-S128"; 3259 3260 WCharType = UnsignedInt; 3261 LongDoubleFormat = &llvm::APFloat::IEEEquad; 3262 3263 // AArch64 backend supports 64-bit operations at the moment. In principle 3264 // 128-bit is possible if register-pairs are used. 3265 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 3266 3267 TheCXXABI.set(TargetCXXABI::GenericAArch64); 3268 } 3269 virtual void getTargetDefines(const LangOptions &Opts, 3270 MacroBuilder &Builder) const { 3271 // GCC defines theses currently 3272 Builder.defineMacro("__aarch64__"); 3273 Builder.defineMacro("__AARCH64EL__"); 3274 3275 // ACLE predefines. Many can only have one possible value on v8 AArch64. 3276 3277 // FIXME: these were written based on an unreleased version of a 32-bit ACLE 3278 // which was intended to be compatible with a 64-bit implementation. They 3279 // will need updating when a real 64-bit ACLE exists. Particularly pressing 3280 // instances are: __AARCH_ISA_A32, __AARCH_ISA_T32, __ARCH_PCS. 3281 Builder.defineMacro("__AARCH_ACLE", "101"); 3282 Builder.defineMacro("__AARCH", "8"); 3283 Builder.defineMacro("__AARCH_PROFILE", "'A'"); 3284 3285 Builder.defineMacro("__AARCH_FEATURE_UNALIGNED"); 3286 Builder.defineMacro("__AARCH_FEATURE_CLZ"); 3287 Builder.defineMacro("__AARCH_FEATURE_FMA"); 3288 3289 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean 3290 // 128-bit LDXP present, at which point this becomes 0x1f. 3291 Builder.defineMacro("__AARCH_FEATURE_LDREX", "0xf"); 3292 3293 // 0xe implies support for half, single and double precision operations. 3294 Builder.defineMacro("__AARCH_FP", "0xe"); 3295 3296 // PCS specifies this for SysV variants, which is all we support. Other ABIs 3297 // may choose __AARCH_FP16_FORMAT_ALTERNATIVE. 3298 Builder.defineMacro("__AARCH_FP16_FORMAT_IEEE"); 3299 3300 if (Opts.FastMath || Opts.FiniteMathOnly) 3301 Builder.defineMacro("__AARCH_FP_FAST"); 3302 3303 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding) 3304 Builder.defineMacro("__AARCH_FP_FENV_ROUNDING"); 3305 3306 Builder.defineMacro("__AARCH_SIZEOF_WCHAR_T", 3307 Opts.ShortWChar ? "2" : "4"); 3308 3309 Builder.defineMacro("__AARCH_SIZEOF_MINIMAL_ENUM", 3310 Opts.ShortEnums ? "1" : "4"); 3311 3312 if (BigEndian) 3313 Builder.defineMacro("__AARCH_BIG_ENDIAN"); 3314 } 3315 virtual void getTargetBuiltins(const Builtin::Info *&Records, 3316 unsigned &NumRecords) const { 3317 Records = 0; 3318 NumRecords = 0; 3319 } 3320 virtual bool hasFeature(StringRef Feature) const { 3321 return Feature == "aarch64"; 3322 } 3323 virtual void getGCCRegNames(const char * const *&Names, 3324 unsigned &NumNames) const; 3325 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 3326 unsigned &NumAliases) const; 3327 3328 virtual bool isCLZForZeroUndef() const { return false; } 3329 3330 virtual bool validateAsmConstraint(const char *&Name, 3331 TargetInfo::ConstraintInfo &Info) const { 3332 switch (*Name) { 3333 default: return false; 3334 case 'w': // An FP/SIMD vector register 3335 Info.setAllowsRegister(); 3336 return true; 3337 case 'I': // Constant that can be used with an ADD instruction 3338 case 'J': // Constant that can be used with a SUB instruction 3339 case 'K': // Constant that can be used with a 32-bit logical instruction 3340 case 'L': // Constant that can be used with a 64-bit logical instruction 3341 case 'M': // Constant that can be used as a 32-bit MOV immediate 3342 case 'N': // Constant that can be used as a 64-bit MOV immediate 3343 case 'Y': // Floating point constant zero 3344 case 'Z': // Integer constant zero 3345 return true; 3346 case 'Q': // A memory reference with base register and no offset 3347 Info.setAllowsMemory(); 3348 return true; 3349 case 'S': // A symbolic address 3350 Info.setAllowsRegister(); 3351 return true; 3352 case 'U': 3353 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be 3354 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be 3355 // Usa: An absolute symbolic address 3356 // Ush: The high part (bits 32:12) of a pc-relative symbolic address 3357 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints"); 3358 } 3359 } 3360 3361 virtual const char *getClobbers() const { 3362 // There are no AArch64 clobbers shared by all asm statements. 3363 return ""; 3364 } 3365 3366 virtual BuiltinVaListKind getBuiltinVaListKind() const { 3367 return TargetInfo::AArch64ABIBuiltinVaList; 3368 } 3369 }; 3370 3371 const char * const AArch64TargetInfo::GCCRegNames[] = { 3372 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", 3373 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15", 3374 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23", 3375 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr", 3376 3377 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", 3378 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", 3379 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", 3380 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr", 3381 3382 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", 3383 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15", 3384 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23", 3385 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31", 3386 3387 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7", 3388 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15", 3389 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23", 3390 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31", 3391 3392 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", 3393 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15", 3394 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23", 3395 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", 3396 3397 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", 3398 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15", 3399 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23", 3400 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31", 3401 3402 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", 3403 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15", 3404 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23", 3405 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31" 3406 }; 3407 3408 void AArch64TargetInfo::getGCCRegNames(const char * const *&Names, 3409 unsigned &NumNames) const { 3410 Names = GCCRegNames; 3411 NumNames = llvm::array_lengthof(GCCRegNames); 3412 } 3413 3414 const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = { 3415 { { "x16" }, "ip0"}, 3416 { { "x17" }, "ip1"}, 3417 { { "x29" }, "fp" }, 3418 { { "x30" }, "lr" } 3419 }; 3420 3421 void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 3422 unsigned &NumAliases) const { 3423 Aliases = GCCRegAliases; 3424 NumAliases = llvm::array_lengthof(GCCRegAliases); 3425 3426 } 3427 } // end anonymous namespace 3428 3429 namespace { 3430 class ARMTargetInfo : public TargetInfo { 3431 // Possible FPU choices. 3432 enum FPUMode { 3433 VFP2FPU = (1 << 0), 3434 VFP3FPU = (1 << 1), 3435 VFP4FPU = (1 << 2), 3436 NeonFPU = (1 << 3) 3437 }; 3438 3439 static bool FPUModeIsVFP(FPUMode Mode) { 3440 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU); 3441 } 3442 3443 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 3444 static const char * const GCCRegNames[]; 3445 3446 std::string ABI, CPU; 3447 3448 unsigned FPU : 4; 3449 3450 unsigned IsAAPCS : 1; 3451 unsigned IsThumb : 1; 3452 3453 // Initialized via features. 3454 unsigned SoftFloat : 1; 3455 unsigned SoftFloatABI : 1; 3456 3457 static const Builtin::Info BuiltinInfo[]; 3458 3459 public: 3460 ARMTargetInfo(const std::string &TripleStr) 3461 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s"), IsAAPCS(true) 3462 { 3463 BigEndian = false; 3464 SizeType = UnsignedInt; 3465 PtrDiffType = SignedInt; 3466 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int. 3467 WCharType = UnsignedInt; 3468 3469 // {} in inline assembly are neon specifiers, not assembly variant 3470 // specifiers. 3471 NoAsmVariants = true; 3472 3473 // FIXME: Should we just treat this as a feature? 3474 IsThumb = getTriple().getArchName().startswith("thumb"); 3475 if (IsThumb) { 3476 // Thumb1 add sp, #imm requires the immediate value be multiple of 4, 3477 // so set preferred for small types to 32. 3478 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-" 3479 "i64:64:64-f32:32:32-f64:64:64-" 3480 "v64:64:64-v128:64:128-a0:0:32-n32-S64"); 3481 } else { 3482 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 3483 "i64:64:64-f32:32:32-f64:64:64-" 3484 "v64:64:64-v128:64:128-a0:0:64-n32-S64"); 3485 } 3486 3487 // ARM targets default to using the ARM C++ ABI. 3488 TheCXXABI.set(TargetCXXABI::GenericARM); 3489 3490 // ARM has atomics up to 8 bytes 3491 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e 3492 MaxAtomicPromoteWidth = 64; 3493 3494 // Do force alignment of members that follow zero length bitfields. If 3495 // the alignment of the zero-length bitfield is greater than the member 3496 // that follows it, `bar', `bar' will be aligned as the type of the 3497 // zero length bitfield. 3498 UseZeroLengthBitfieldAlignment = true; 3499 } 3500 virtual const char *getABI() const { return ABI.c_str(); } 3501 virtual bool setABI(const std::string &Name) { 3502 ABI = Name; 3503 3504 // The defaults (above) are for AAPCS, check if we need to change them. 3505 // 3506 // FIXME: We need support for -meabi... we could just mangle it into the 3507 // name. 3508 if (Name == "apcs-gnu") { 3509 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32; 3510 // size_t is unsigned int on FreeBSD. 3511 if (getTriple().getOS() != llvm::Triple::FreeBSD) 3512 SizeType = UnsignedLong; 3513 3514 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour. 3515 WCharType = SignedInt; 3516 3517 // Do not respect the alignment of bit-field types when laying out 3518 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc. 3519 UseBitFieldTypeAlignment = false; 3520 3521 /// gcc forces the alignment to 4 bytes, regardless of the type of the 3522 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in 3523 /// gcc. 3524 ZeroLengthBitfieldBoundary = 32; 3525 3526 IsAAPCS = false; 3527 3528 if (IsThumb) { 3529 // Thumb1 add sp, #imm requires the immediate value be multiple of 4, 3530 // so set preferred for small types to 32. 3531 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-" 3532 "i64:32:64-f32:32:32-f64:32:64-" 3533 "v64:32:64-v128:32:128-a0:0:32-n32-S32"); 3534 } else { 3535 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 3536 "i64:32:64-f32:32:32-f64:32:64-" 3537 "v64:32:64-v128:32:128-a0:0:32-n32-S32"); 3538 } 3539 3540 // FIXME: Override "preferred align" for double and long long. 3541 } else if (Name == "aapcs" || Name == "aapcs-vfp") { 3542 IsAAPCS = true; 3543 // FIXME: Enumerated types are variable width in straight AAPCS. 3544 } else if (Name == "aapcs-linux") { 3545 IsAAPCS = true; 3546 } else 3547 return false; 3548 3549 return true; 3550 } 3551 3552 void getDefaultFeatures(llvm::StringMap<bool> &Features) const { 3553 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore") 3554 Features["vfp2"] = true; 3555 else if (CPU == "cortex-a8" || CPU == "cortex-a15" || 3556 CPU == "cortex-a9" || CPU == "cortex-a9-mp") 3557 Features["neon"] = true; 3558 else if (CPU == "swift" || CPU == "cortex-a7") { 3559 Features["vfp4"] = true; 3560 Features["neon"] = true; 3561 } 3562 } 3563 3564 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features, 3565 StringRef Name, 3566 bool Enabled) const { 3567 if (Name == "soft-float" || Name == "soft-float-abi" || 3568 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" || 3569 Name == "d16" || Name == "neonfp") { 3570 Features[Name] = Enabled; 3571 } else 3572 return false; 3573 3574 return true; 3575 } 3576 3577 virtual void HandleTargetFeatures(std::vector<std::string> &Features) { 3578 FPU = 0; 3579 SoftFloat = SoftFloatABI = false; 3580 for (unsigned i = 0, e = Features.size(); i != e; ++i) { 3581 if (Features[i] == "+soft-float") 3582 SoftFloat = true; 3583 else if (Features[i] == "+soft-float-abi") 3584 SoftFloatABI = true; 3585 else if (Features[i] == "+vfp2") 3586 FPU |= VFP2FPU; 3587 else if (Features[i] == "+vfp3") 3588 FPU |= VFP3FPU; 3589 else if (Features[i] == "+vfp4") 3590 FPU |= VFP4FPU; 3591 else if (Features[i] == "+neon") 3592 FPU |= NeonFPU; 3593 } 3594 3595 // Remove front-end specific options which the backend handles differently. 3596 std::vector<std::string>::iterator it; 3597 it = std::find(Features.begin(), Features.end(), "+soft-float"); 3598 if (it != Features.end()) 3599 Features.erase(it); 3600 it = std::find(Features.begin(), Features.end(), "+soft-float-abi"); 3601 if (it != Features.end()) 3602 Features.erase(it); 3603 } 3604 3605 virtual bool hasFeature(StringRef Feature) const { 3606 return llvm::StringSwitch<bool>(Feature) 3607 .Case("arm", true) 3608 .Case("softfloat", SoftFloat) 3609 .Case("thumb", IsThumb) 3610 .Case("neon", FPU == NeonFPU && !SoftFloat && 3611 StringRef(getCPUDefineSuffix(CPU)).startswith("7")) 3612 .Default(false); 3613 } 3614 // FIXME: Should we actually have some table instead of these switches? 3615 static const char *getCPUDefineSuffix(StringRef Name) { 3616 return llvm::StringSwitch<const char*>(Name) 3617 .Cases("arm8", "arm810", "4") 3618 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4") 3619 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T") 3620 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T") 3621 .Case("ep9312", "4T") 3622 .Cases("arm10tdmi", "arm1020t", "5T") 3623 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE") 3624 .Case("arm926ej-s", "5TEJ") 3625 .Cases("arm10e", "arm1020e", "arm1022e", "5TE") 3626 .Cases("xscale", "iwmmxt", "5TE") 3627 .Case("arm1136j-s", "6J") 3628 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK") 3629 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K") 3630 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2") 3631 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A") 3632 .Cases("cortex-a9", "cortex-a15", "7A") 3633 .Case("cortex-r5", "7R") 3634 .Case("cortex-a9-mp", "7F") 3635 .Case("swift", "7S") 3636 .Cases("cortex-m3", "cortex-m4", "7M") 3637 .Case("cortex-m0", "6M") 3638 .Default(0); 3639 } 3640 static const char *getCPUProfile(StringRef Name) { 3641 return llvm::StringSwitch<const char*>(Name) 3642 .Cases("cortex-a8", "cortex-a9", "A") 3643 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M") 3644 .Case("cortex-r5", "R") 3645 .Default(""); 3646 } 3647 virtual bool setCPU(const std::string &Name) { 3648 if (!getCPUDefineSuffix(Name)) 3649 return false; 3650 3651 CPU = Name; 3652 return true; 3653 } 3654 virtual void getTargetDefines(const LangOptions &Opts, 3655 MacroBuilder &Builder) const { 3656 // Target identification. 3657 Builder.defineMacro("__arm"); 3658 Builder.defineMacro("__arm__"); 3659 3660 // Target properties. 3661 Builder.defineMacro("__ARMEL__"); 3662 Builder.defineMacro("__LITTLE_ENDIAN__"); 3663 Builder.defineMacro("__REGISTER_PREFIX__", ""); 3664 3665 StringRef CPUArch = getCPUDefineSuffix(CPU); 3666 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__"); 3667 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1)); 3668 StringRef CPUProfile = getCPUProfile(CPU); 3669 if (!CPUProfile.empty()) 3670 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile); 3671 3672 // Subtarget options. 3673 3674 // FIXME: It's more complicated than this and we don't really support 3675 // interworking. 3676 if ('5' <= CPUArch[0] && CPUArch[0] <= '7') 3677 Builder.defineMacro("__THUMB_INTERWORK__"); 3678 3679 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") { 3680 // M-class CPUs on Darwin follow AAPCS, but not EABI. 3681 if (!(getTriple().isOSDarwin() && CPUProfile == "M")) 3682 Builder.defineMacro("__ARM_EABI__"); 3683 Builder.defineMacro("__ARM_PCS", "1"); 3684 3685 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp") 3686 Builder.defineMacro("__ARM_PCS_VFP", "1"); 3687 } 3688 3689 if (SoftFloat) 3690 Builder.defineMacro("__SOFTFP__"); 3691 3692 if (CPU == "xscale") 3693 Builder.defineMacro("__XSCALE__"); 3694 3695 bool IsARMv7 = CPUArch.startswith("7"); 3696 if (IsThumb) { 3697 Builder.defineMacro("__THUMBEL__"); 3698 Builder.defineMacro("__thumb__"); 3699 if (CPUArch == "6T2" || IsARMv7) 3700 Builder.defineMacro("__thumb2__"); 3701 } 3702 3703 // Note, this is always on in gcc, even though it doesn't make sense. 3704 Builder.defineMacro("__APCS_32__"); 3705 3706 if (FPUModeIsVFP((FPUMode) FPU)) { 3707 Builder.defineMacro("__VFP_FP__"); 3708 if (FPU & VFP2FPU) 3709 Builder.defineMacro("__ARM_VFPV2__"); 3710 if (FPU & VFP3FPU) 3711 Builder.defineMacro("__ARM_VFPV3__"); 3712 if (FPU & VFP4FPU) 3713 Builder.defineMacro("__ARM_VFPV4__"); 3714 } 3715 3716 // This only gets set when Neon instructions are actually available, unlike 3717 // the VFP define, hence the soft float and arch check. This is subtly 3718 // different from gcc, we follow the intent which was that it should be set 3719 // when Neon instructions are actually available. 3720 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7) 3721 Builder.defineMacro("__ARM_NEON__"); 3722 } 3723 virtual void getTargetBuiltins(const Builtin::Info *&Records, 3724 unsigned &NumRecords) const { 3725 Records = BuiltinInfo; 3726 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin; 3727 } 3728 virtual bool isCLZForZeroUndef() const { return false; } 3729 virtual BuiltinVaListKind getBuiltinVaListKind() const { 3730 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList; 3731 } 3732 virtual void getGCCRegNames(const char * const *&Names, 3733 unsigned &NumNames) const; 3734 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 3735 unsigned &NumAliases) const; 3736 virtual bool validateAsmConstraint(const char *&Name, 3737 TargetInfo::ConstraintInfo &Info) const { 3738 switch (*Name) { 3739 default: break; 3740 case 'l': // r0-r7 3741 case 'h': // r8-r15 3742 case 'w': // VFP Floating point register single precision 3743 case 'P': // VFP Floating point register double precision 3744 Info.setAllowsRegister(); 3745 return true; 3746 case 'Q': // A memory address that is a single base register. 3747 Info.setAllowsMemory(); 3748 return true; 3749 case 'U': // a memory reference... 3750 switch (Name[1]) { 3751 case 'q': // ...ARMV4 ldrsb 3752 case 'v': // ...VFP load/store (reg+constant offset) 3753 case 'y': // ...iWMMXt load/store 3754 case 't': // address valid for load/store opaque types wider 3755 // than 128-bits 3756 case 'n': // valid address for Neon doubleword vector load/store 3757 case 'm': // valid address for Neon element and structure load/store 3758 case 's': // valid address for non-offset loads/stores of quad-word 3759 // values in four ARM registers 3760 Info.setAllowsMemory(); 3761 Name++; 3762 return true; 3763 } 3764 } 3765 return false; 3766 } 3767 virtual std::string convertConstraint(const char *&Constraint) const { 3768 std::string R; 3769 switch (*Constraint) { 3770 case 'U': // Two-character constraint; add "^" hint for later parsing. 3771 R = std::string("^") + std::string(Constraint, 2); 3772 Constraint++; 3773 break; 3774 case 'p': // 'p' should be translated to 'r' by default. 3775 R = std::string("r"); 3776 break; 3777 default: 3778 return std::string(1, *Constraint); 3779 } 3780 return R; 3781 } 3782 virtual bool validateConstraintModifier(StringRef Constraint, 3783 const char Modifier, 3784 unsigned Size) const { 3785 bool isOutput = (Constraint[0] == '='); 3786 bool isInOut = (Constraint[0] == '+'); 3787 3788 // Strip off constraint modifiers. 3789 while (Constraint[0] == '=' || 3790 Constraint[0] == '+' || 3791 Constraint[0] == '&') 3792 Constraint = Constraint.substr(1); 3793 3794 switch (Constraint[0]) { 3795 default: break; 3796 case 'r': { 3797 switch (Modifier) { 3798 default: 3799 return isInOut || (isOutput && Size >= 32) || 3800 (!isOutput && !isInOut && Size <= 32); 3801 case 'q': 3802 // A register of size 32 cannot fit a vector type. 3803 return false; 3804 } 3805 } 3806 } 3807 3808 return true; 3809 } 3810 virtual const char *getClobbers() const { 3811 // FIXME: Is this really right? 3812 return ""; 3813 } 3814 3815 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const { 3816 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning; 3817 } 3818 3819 virtual int getEHDataRegisterNumber(unsigned RegNo) const { 3820 if (RegNo == 0) return 0; 3821 if (RegNo == 1) return 1; 3822 return -1; 3823 } 3824 }; 3825 3826 const char * const ARMTargetInfo::GCCRegNames[] = { 3827 // Integer registers 3828 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 3829 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc", 3830 3831 // Float registers 3832 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", 3833 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15", 3834 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23", 3835 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", 3836 3837 // Double registers 3838 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", 3839 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15", 3840 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23", 3841 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31", 3842 3843 // Quad registers 3844 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", 3845 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" 3846 }; 3847 3848 void ARMTargetInfo::getGCCRegNames(const char * const *&Names, 3849 unsigned &NumNames) const { 3850 Names = GCCRegNames; 3851 NumNames = llvm::array_lengthof(GCCRegNames); 3852 } 3853 3854 const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = { 3855 { { "a1" }, "r0" }, 3856 { { "a2" }, "r1" }, 3857 { { "a3" }, "r2" }, 3858 { { "a4" }, "r3" }, 3859 { { "v1" }, "r4" }, 3860 { { "v2" }, "r5" }, 3861 { { "v3" }, "r6" }, 3862 { { "v4" }, "r7" }, 3863 { { "v5" }, "r8" }, 3864 { { "v6", "rfp" }, "r9" }, 3865 { { "sl" }, "r10" }, 3866 { { "fp" }, "r11" }, 3867 { { "ip" }, "r12" }, 3868 { { "r13" }, "sp" }, 3869 { { "r14" }, "lr" }, 3870 { { "r15" }, "pc" }, 3871 // The S, D and Q registers overlap, but aren't really aliases; we 3872 // don't want to substitute one of these for a different-sized one. 3873 }; 3874 3875 void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 3876 unsigned &NumAliases) const { 3877 Aliases = GCCRegAliases; 3878 NumAliases = llvm::array_lengthof(GCCRegAliases); 3879 } 3880 3881 const Builtin::Info ARMTargetInfo::BuiltinInfo[] = { 3882 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 3883 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 3884 ALL_LANGUAGES }, 3885 #include "clang/Basic/BuiltinsARM.def" 3886 }; 3887 } // end anonymous namespace. 3888 3889 namespace { 3890 class DarwinARMTargetInfo : 3891 public DarwinTargetInfo<ARMTargetInfo> { 3892 protected: 3893 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, 3894 MacroBuilder &Builder) const { 3895 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion); 3896 } 3897 3898 public: 3899 DarwinARMTargetInfo(const std::string& triple) 3900 : DarwinTargetInfo<ARMTargetInfo>(triple) { 3901 HasAlignMac68kSupport = true; 3902 // iOS always has 64-bit atomic instructions. 3903 // FIXME: This should be based off of the target features in ARMTargetInfo. 3904 MaxAtomicInlineWidth = 64; 3905 3906 // Darwin on iOS uses a variant of the ARM C++ ABI. 3907 TheCXXABI.set(TargetCXXABI::iOS); 3908 } 3909 }; 3910 } // end anonymous namespace. 3911 3912 3913 namespace { 3914 // Hexagon abstract base class 3915 class HexagonTargetInfo : public TargetInfo { 3916 static const Builtin::Info BuiltinInfo[]; 3917 static const char * const GCCRegNames[]; 3918 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 3919 std::string CPU; 3920 public: 3921 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) { 3922 BigEndian = false; 3923 DescriptionString = ("e-p:32:32:32-" 3924 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-" 3925 "f64:64:64-f32:32:32-a0:0-n32"); 3926 3927 // {} in inline assembly are packet specifiers, not assembly variant 3928 // specifiers. 3929 NoAsmVariants = true; 3930 } 3931 3932 virtual void getTargetBuiltins(const Builtin::Info *&Records, 3933 unsigned &NumRecords) const { 3934 Records = BuiltinInfo; 3935 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin; 3936 } 3937 3938 virtual bool validateAsmConstraint(const char *&Name, 3939 TargetInfo::ConstraintInfo &Info) const { 3940 return true; 3941 } 3942 3943 virtual void getTargetDefines(const LangOptions &Opts, 3944 MacroBuilder &Builder) const; 3945 3946 virtual bool hasFeature(StringRef Feature) const { 3947 return Feature == "hexagon"; 3948 } 3949 3950 virtual BuiltinVaListKind getBuiltinVaListKind() const { 3951 return TargetInfo::CharPtrBuiltinVaList; 3952 } 3953 virtual void getGCCRegNames(const char * const *&Names, 3954 unsigned &NumNames) const; 3955 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 3956 unsigned &NumAliases) const; 3957 virtual const char *getClobbers() const { 3958 return ""; 3959 } 3960 3961 static const char *getHexagonCPUSuffix(StringRef Name) { 3962 return llvm::StringSwitch<const char*>(Name) 3963 .Case("hexagonv4", "4") 3964 .Case("hexagonv5", "5") 3965 .Default(0); 3966 } 3967 3968 virtual bool setCPU(const std::string &Name) { 3969 if (!getHexagonCPUSuffix(Name)) 3970 return false; 3971 3972 CPU = Name; 3973 return true; 3974 } 3975 }; 3976 3977 void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts, 3978 MacroBuilder &Builder) const { 3979 Builder.defineMacro("qdsp6"); 3980 Builder.defineMacro("__qdsp6", "1"); 3981 Builder.defineMacro("__qdsp6__", "1"); 3982 3983 Builder.defineMacro("hexagon"); 3984 Builder.defineMacro("__hexagon", "1"); 3985 Builder.defineMacro("__hexagon__", "1"); 3986 3987 if(CPU == "hexagonv1") { 3988 Builder.defineMacro("__HEXAGON_V1__"); 3989 Builder.defineMacro("__HEXAGON_ARCH__", "1"); 3990 if(Opts.HexagonQdsp6Compat) { 3991 Builder.defineMacro("__QDSP6_V1__"); 3992 Builder.defineMacro("__QDSP6_ARCH__", "1"); 3993 } 3994 } 3995 else if(CPU == "hexagonv2") { 3996 Builder.defineMacro("__HEXAGON_V2__"); 3997 Builder.defineMacro("__HEXAGON_ARCH__", "2"); 3998 if(Opts.HexagonQdsp6Compat) { 3999 Builder.defineMacro("__QDSP6_V2__"); 4000 Builder.defineMacro("__QDSP6_ARCH__", "2"); 4001 } 4002 } 4003 else if(CPU == "hexagonv3") { 4004 Builder.defineMacro("__HEXAGON_V3__"); 4005 Builder.defineMacro("__HEXAGON_ARCH__", "3"); 4006 if(Opts.HexagonQdsp6Compat) { 4007 Builder.defineMacro("__QDSP6_V3__"); 4008 Builder.defineMacro("__QDSP6_ARCH__", "3"); 4009 } 4010 } 4011 else if(CPU == "hexagonv4") { 4012 Builder.defineMacro("__HEXAGON_V4__"); 4013 Builder.defineMacro("__HEXAGON_ARCH__", "4"); 4014 if(Opts.HexagonQdsp6Compat) { 4015 Builder.defineMacro("__QDSP6_V4__"); 4016 Builder.defineMacro("__QDSP6_ARCH__", "4"); 4017 } 4018 } 4019 else if(CPU == "hexagonv5") { 4020 Builder.defineMacro("__HEXAGON_V5__"); 4021 Builder.defineMacro("__HEXAGON_ARCH__", "5"); 4022 if(Opts.HexagonQdsp6Compat) { 4023 Builder.defineMacro("__QDSP6_V5__"); 4024 Builder.defineMacro("__QDSP6_ARCH__", "5"); 4025 } 4026 } 4027 } 4028 4029 const char * const HexagonTargetInfo::GCCRegNames[] = { 4030 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 4031 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 4032 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 4033 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 4034 "p0", "p1", "p2", "p3", 4035 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp" 4036 }; 4037 4038 void HexagonTargetInfo::getGCCRegNames(const char * const *&Names, 4039 unsigned &NumNames) const { 4040 Names = GCCRegNames; 4041 NumNames = llvm::array_lengthof(GCCRegNames); 4042 } 4043 4044 4045 const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = { 4046 { { "sp" }, "r29" }, 4047 { { "fp" }, "r30" }, 4048 { { "lr" }, "r31" }, 4049 }; 4050 4051 void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 4052 unsigned &NumAliases) const { 4053 Aliases = GCCRegAliases; 4054 NumAliases = llvm::array_lengthof(GCCRegAliases); 4055 } 4056 4057 4058 const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = { 4059 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 4060 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 4061 ALL_LANGUAGES }, 4062 #include "clang/Basic/BuiltinsHexagon.def" 4063 }; 4064 } 4065 4066 4067 namespace { 4068 class SparcV8TargetInfo : public TargetInfo { 4069 static const TargetInfo::GCCRegAlias GCCRegAliases[]; 4070 static const char * const GCCRegNames[]; 4071 bool SoftFloat; 4072 public: 4073 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) { 4074 // FIXME: Support Sparc quad-precision long double? 4075 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 4076 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32"; 4077 } 4078 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features, 4079 StringRef Name, 4080 bool Enabled) const { 4081 if (Name == "soft-float") 4082 Features[Name] = Enabled; 4083 else 4084 return false; 4085 4086 return true; 4087 } 4088 virtual void HandleTargetFeatures(std::vector<std::string> &Features) { 4089 SoftFloat = false; 4090 for (unsigned i = 0, e = Features.size(); i != e; ++i) 4091 if (Features[i] == "+soft-float") 4092 SoftFloat = true; 4093 } 4094 virtual void getTargetDefines(const LangOptions &Opts, 4095 MacroBuilder &Builder) const { 4096 DefineStd(Builder, "sparc", Opts); 4097 Builder.defineMacro("__sparcv8"); 4098 Builder.defineMacro("__REGISTER_PREFIX__", ""); 4099 4100 if (SoftFloat) 4101 Builder.defineMacro("SOFT_FLOAT", "1"); 4102 } 4103 4104 virtual bool hasFeature(StringRef Feature) const { 4105 return llvm::StringSwitch<bool>(Feature) 4106 .Case("softfloat", SoftFloat) 4107 .Case("sparc", true) 4108 .Default(false); 4109 } 4110 4111 virtual void getTargetBuiltins(const Builtin::Info *&Records, 4112 unsigned &NumRecords) const { 4113 // FIXME: Implement! 4114 } 4115 virtual BuiltinVaListKind getBuiltinVaListKind() const { 4116 return TargetInfo::VoidPtrBuiltinVaList; 4117 } 4118 virtual void getGCCRegNames(const char * const *&Names, 4119 unsigned &NumNames) const; 4120 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4121 unsigned &NumAliases) const; 4122 virtual bool validateAsmConstraint(const char *&Name, 4123 TargetInfo::ConstraintInfo &info) const { 4124 // FIXME: Implement! 4125 return false; 4126 } 4127 virtual const char *getClobbers() const { 4128 // FIXME: Implement! 4129 return ""; 4130 } 4131 }; 4132 4133 const char * const SparcV8TargetInfo::GCCRegNames[] = { 4134 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 4135 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 4136 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 4137 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31" 4138 }; 4139 4140 void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names, 4141 unsigned &NumNames) const { 4142 Names = GCCRegNames; 4143 NumNames = llvm::array_lengthof(GCCRegNames); 4144 } 4145 4146 const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = { 4147 { { "g0" }, "r0" }, 4148 { { "g1" }, "r1" }, 4149 { { "g2" }, "r2" }, 4150 { { "g3" }, "r3" }, 4151 { { "g4" }, "r4" }, 4152 { { "g5" }, "r5" }, 4153 { { "g6" }, "r6" }, 4154 { { "g7" }, "r7" }, 4155 { { "o0" }, "r8" }, 4156 { { "o1" }, "r9" }, 4157 { { "o2" }, "r10" }, 4158 { { "o3" }, "r11" }, 4159 { { "o4" }, "r12" }, 4160 { { "o5" }, "r13" }, 4161 { { "o6", "sp" }, "r14" }, 4162 { { "o7" }, "r15" }, 4163 { { "l0" }, "r16" }, 4164 { { "l1" }, "r17" }, 4165 { { "l2" }, "r18" }, 4166 { { "l3" }, "r19" }, 4167 { { "l4" }, "r20" }, 4168 { { "l5" }, "r21" }, 4169 { { "l6" }, "r22" }, 4170 { { "l7" }, "r23" }, 4171 { { "i0" }, "r24" }, 4172 { { "i1" }, "r25" }, 4173 { { "i2" }, "r26" }, 4174 { { "i3" }, "r27" }, 4175 { { "i4" }, "r28" }, 4176 { { "i5" }, "r29" }, 4177 { { "i6", "fp" }, "r30" }, 4178 { { "i7" }, "r31" }, 4179 }; 4180 4181 void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 4182 unsigned &NumAliases) const { 4183 Aliases = GCCRegAliases; 4184 NumAliases = llvm::array_lengthof(GCCRegAliases); 4185 } 4186 } // end anonymous namespace. 4187 4188 namespace { 4189 class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> { 4190 public: 4191 AuroraUXSparcV8TargetInfo(const std::string& triple) : 4192 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) { 4193 SizeType = UnsignedInt; 4194 PtrDiffType = SignedInt; 4195 } 4196 }; 4197 class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> { 4198 public: 4199 SolarisSparcV8TargetInfo(const std::string& triple) : 4200 SolarisTargetInfo<SparcV8TargetInfo>(triple) { 4201 SizeType = UnsignedInt; 4202 PtrDiffType = SignedInt; 4203 } 4204 }; 4205 } // end anonymous namespace. 4206 4207 namespace { 4208 class MSP430TargetInfo : public TargetInfo { 4209 static const char * const GCCRegNames[]; 4210 public: 4211 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) { 4212 BigEndian = false; 4213 TLSSupported = false; 4214 IntWidth = 16; IntAlign = 16; 4215 LongWidth = 32; LongLongWidth = 64; 4216 LongAlign = LongLongAlign = 16; 4217 PointerWidth = 16; PointerAlign = 16; 4218 SuitableAlign = 16; 4219 SizeType = UnsignedInt; 4220 IntMaxType = SignedLong; 4221 UIntMaxType = UnsignedLong; 4222 IntPtrType = SignedShort; 4223 PtrDiffType = SignedInt; 4224 SigAtomicType = SignedLong; 4225 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16"; 4226 } 4227 virtual void getTargetDefines(const LangOptions &Opts, 4228 MacroBuilder &Builder) const { 4229 Builder.defineMacro("MSP430"); 4230 Builder.defineMacro("__MSP430__"); 4231 // FIXME: defines for different 'flavours' of MCU 4232 } 4233 virtual void getTargetBuiltins(const Builtin::Info *&Records, 4234 unsigned &NumRecords) const { 4235 // FIXME: Implement. 4236 Records = 0; 4237 NumRecords = 0; 4238 } 4239 virtual bool hasFeature(StringRef Feature) const { 4240 return Feature == "msp430"; 4241 } 4242 virtual void getGCCRegNames(const char * const *&Names, 4243 unsigned &NumNames) const; 4244 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4245 unsigned &NumAliases) const { 4246 // No aliases. 4247 Aliases = 0; 4248 NumAliases = 0; 4249 } 4250 virtual bool validateAsmConstraint(const char *&Name, 4251 TargetInfo::ConstraintInfo &info) const { 4252 // No target constraints for now. 4253 return false; 4254 } 4255 virtual const char *getClobbers() const { 4256 // FIXME: Is this really right? 4257 return ""; 4258 } 4259 virtual BuiltinVaListKind getBuiltinVaListKind() const { 4260 // FIXME: implement 4261 return TargetInfo::CharPtrBuiltinVaList; 4262 } 4263 }; 4264 4265 const char * const MSP430TargetInfo::GCCRegNames[] = { 4266 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 4267 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 4268 }; 4269 4270 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names, 4271 unsigned &NumNames) const { 4272 Names = GCCRegNames; 4273 NumNames = llvm::array_lengthof(GCCRegNames); 4274 } 4275 } 4276 4277 namespace { 4278 4279 // LLVM and Clang cannot be used directly to output native binaries for 4280 // target, but is used to compile C code to llvm bitcode with correct 4281 // type and alignment information. 4282 // 4283 // TCE uses the llvm bitcode as input and uses it for generating customized 4284 // target processor and program binary. TCE co-design environment is 4285 // publicly available in http://tce.cs.tut.fi 4286 4287 static const unsigned TCEOpenCLAddrSpaceMap[] = { 4288 3, // opencl_global 4289 4, // opencl_local 4290 5, // opencl_constant 4291 0, // cuda_device 4292 0, // cuda_constant 4293 0 // cuda_shared 4294 }; 4295 4296 class TCETargetInfo : public TargetInfo{ 4297 public: 4298 TCETargetInfo(const std::string& triple) : TargetInfo(triple) { 4299 TLSSupported = false; 4300 IntWidth = 32; 4301 LongWidth = LongLongWidth = 32; 4302 PointerWidth = 32; 4303 IntAlign = 32; 4304 LongAlign = LongLongAlign = 32; 4305 PointerAlign = 32; 4306 SuitableAlign = 32; 4307 SizeType = UnsignedInt; 4308 IntMaxType = SignedLong; 4309 UIntMaxType = UnsignedLong; 4310 IntPtrType = SignedInt; 4311 PtrDiffType = SignedInt; 4312 FloatWidth = 32; 4313 FloatAlign = 32; 4314 DoubleWidth = 32; 4315 DoubleAlign = 32; 4316 LongDoubleWidth = 32; 4317 LongDoubleAlign = 32; 4318 FloatFormat = &llvm::APFloat::IEEEsingle; 4319 DoubleFormat = &llvm::APFloat::IEEEsingle; 4320 LongDoubleFormat = &llvm::APFloat::IEEEsingle; 4321 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-" 4322 "i16:16:32-i32:32:32-i64:32:32-" 4323 "f32:32:32-f64:32:32-v64:32:32-" 4324 "v128:32:32-a0:0:32-n32"; 4325 AddrSpaceMap = &TCEOpenCLAddrSpaceMap; 4326 } 4327 4328 virtual void getTargetDefines(const LangOptions &Opts, 4329 MacroBuilder &Builder) const { 4330 DefineStd(Builder, "tce", Opts); 4331 Builder.defineMacro("__TCE__"); 4332 Builder.defineMacro("__TCE_V1__"); 4333 } 4334 virtual bool hasFeature(StringRef Feature) const { 4335 return Feature == "tce"; 4336 } 4337 4338 virtual void getTargetBuiltins(const Builtin::Info *&Records, 4339 unsigned &NumRecords) const {} 4340 virtual const char *getClobbers() const { 4341 return ""; 4342 } 4343 virtual BuiltinVaListKind getBuiltinVaListKind() const { 4344 return TargetInfo::VoidPtrBuiltinVaList; 4345 } 4346 virtual void getGCCRegNames(const char * const *&Names, 4347 unsigned &NumNames) const {} 4348 virtual bool validateAsmConstraint(const char *&Name, 4349 TargetInfo::ConstraintInfo &info) const { 4350 return true; 4351 } 4352 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4353 unsigned &NumAliases) const {} 4354 }; 4355 } 4356 4357 namespace { 4358 class MipsTargetInfoBase : public TargetInfo { 4359 static const Builtin::Info BuiltinInfo[]; 4360 std::string CPU; 4361 bool IsMips16; 4362 enum MipsFloatABI { 4363 HardFloat, SingleFloat, SoftFloat 4364 } FloatABI; 4365 enum DspRevEnum { 4366 NoDSP, DSP1, DSP2 4367 } DspRev; 4368 4369 protected: 4370 std::string ABI; 4371 4372 public: 4373 MipsTargetInfoBase(const std::string& triple, 4374 const std::string& ABIStr, 4375 const std::string& CPUStr) 4376 : TargetInfo(triple), 4377 CPU(CPUStr), 4378 IsMips16(false), 4379 FloatABI(HardFloat), 4380 DspRev(NoDSP), 4381 ABI(ABIStr) 4382 {} 4383 4384 virtual const char *getABI() const { return ABI.c_str(); } 4385 virtual bool setABI(const std::string &Name) = 0; 4386 virtual bool setCPU(const std::string &Name) { 4387 CPU = Name; 4388 return true; 4389 } 4390 void getDefaultFeatures(llvm::StringMap<bool> &Features) const { 4391 Features[ABI] = true; 4392 Features[CPU] = true; 4393 } 4394 4395 virtual void getTargetDefines(const LangOptions &Opts, 4396 MacroBuilder &Builder) const { 4397 DefineStd(Builder, "mips", Opts); 4398 Builder.defineMacro("_mips"); 4399 Builder.defineMacro("__REGISTER_PREFIX__", ""); 4400 4401 switch (FloatABI) { 4402 case HardFloat: 4403 Builder.defineMacro("__mips_hard_float", Twine(1)); 4404 break; 4405 case SingleFloat: 4406 Builder.defineMacro("__mips_hard_float", Twine(1)); 4407 Builder.defineMacro("__mips_single_float", Twine(1)); 4408 break; 4409 case SoftFloat: 4410 Builder.defineMacro("__mips_soft_float", Twine(1)); 4411 break; 4412 } 4413 4414 if (IsMips16) 4415 Builder.defineMacro("__mips16", Twine(1)); 4416 4417 switch (DspRev) { 4418 default: 4419 break; 4420 case DSP1: 4421 Builder.defineMacro("__mips_dsp_rev", Twine(1)); 4422 Builder.defineMacro("__mips_dsp", Twine(1)); 4423 break; 4424 case DSP2: 4425 Builder.defineMacro("__mips_dsp_rev", Twine(2)); 4426 Builder.defineMacro("__mips_dspr2", Twine(1)); 4427 Builder.defineMacro("__mips_dsp", Twine(1)); 4428 break; 4429 } 4430 4431 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0))); 4432 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth())); 4433 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth())); 4434 4435 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\""); 4436 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper()); 4437 } 4438 4439 virtual void getTargetBuiltins(const Builtin::Info *&Records, 4440 unsigned &NumRecords) const { 4441 Records = BuiltinInfo; 4442 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin; 4443 } 4444 virtual bool hasFeature(StringRef Feature) const { 4445 return Feature == "mips"; 4446 } 4447 virtual BuiltinVaListKind getBuiltinVaListKind() const { 4448 return TargetInfo::VoidPtrBuiltinVaList; 4449 } 4450 virtual void getGCCRegNames(const char * const *&Names, 4451 unsigned &NumNames) const { 4452 static const char * const GCCRegNames[] = { 4453 // CPU register names 4454 // Must match second column of GCCRegAliases 4455 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7", 4456 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", 4457 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23", 4458 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31", 4459 // Floating point register names 4460 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", 4461 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15", 4462 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23", 4463 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31", 4464 // Hi/lo and condition register names 4465 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4", 4466 "$fcc5","$fcc6","$fcc7" 4467 }; 4468 Names = GCCRegNames; 4469 NumNames = llvm::array_lengthof(GCCRegNames); 4470 } 4471 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4472 unsigned &NumAliases) const = 0; 4473 virtual bool validateAsmConstraint(const char *&Name, 4474 TargetInfo::ConstraintInfo &Info) const { 4475 switch (*Name) { 4476 default: 4477 return false; 4478 4479 case 'r': // CPU registers. 4480 case 'd': // Equivalent to "r" unless generating MIPS16 code. 4481 case 'y': // Equivalent to "r", backwards compatibility only. 4482 case 'f': // floating-point registers. 4483 case 'c': // $25 for indirect jumps 4484 case 'l': // lo register 4485 case 'x': // hilo register pair 4486 Info.setAllowsRegister(); 4487 return true; 4488 case 'R': // An address that can be used in a non-macro load or store 4489 Info.setAllowsMemory(); 4490 return true; 4491 } 4492 } 4493 4494 virtual const char *getClobbers() const { 4495 // FIXME: Implement! 4496 return ""; 4497 } 4498 4499 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features, 4500 StringRef Name, 4501 bool Enabled) const { 4502 if (Name == "soft-float" || Name == "single-float" || 4503 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" || 4504 Name == "mips32" || Name == "mips32r2" || 4505 Name == "mips64" || Name == "mips64r2" || 4506 Name == "mips16" || Name == "dsp" || Name == "dspr2") { 4507 Features[Name] = Enabled; 4508 return true; 4509 } else if (Name == "32") { 4510 Features["o32"] = Enabled; 4511 return true; 4512 } else if (Name == "64") { 4513 Features["n64"] = Enabled; 4514 return true; 4515 } 4516 return false; 4517 } 4518 4519 virtual void HandleTargetFeatures(std::vector<std::string> &Features) { 4520 IsMips16 = false; 4521 FloatABI = HardFloat; 4522 DspRev = NoDSP; 4523 4524 for (std::vector<std::string>::iterator it = Features.begin(), 4525 ie = Features.end(); it != ie; ++it) { 4526 if (*it == "+single-float") 4527 FloatABI = SingleFloat; 4528 else if (*it == "+soft-float") 4529 FloatABI = SoftFloat; 4530 else if (*it == "+mips16") 4531 IsMips16 = true; 4532 else if (*it == "+dsp") 4533 DspRev = std::max(DspRev, DSP1); 4534 else if (*it == "+dspr2") 4535 DspRev = std::max(DspRev, DSP2); 4536 } 4537 4538 // Remove front-end specific option. 4539 std::vector<std::string>::iterator it = 4540 std::find(Features.begin(), Features.end(), "+soft-float"); 4541 if (it != Features.end()) 4542 Features.erase(it); 4543 } 4544 4545 virtual int getEHDataRegisterNumber(unsigned RegNo) const { 4546 if (RegNo == 0) return 4; 4547 if (RegNo == 1) return 5; 4548 return -1; 4549 } 4550 }; 4551 4552 const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = { 4553 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES }, 4554 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\ 4555 ALL_LANGUAGES }, 4556 #include "clang/Basic/BuiltinsMips.def" 4557 }; 4558 4559 class Mips32TargetInfoBase : public MipsTargetInfoBase { 4560 public: 4561 Mips32TargetInfoBase(const std::string& triple) : 4562 MipsTargetInfoBase(triple, "o32", "mips32") { 4563 SizeType = UnsignedInt; 4564 PtrDiffType = SignedInt; 4565 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32; 4566 } 4567 virtual bool setABI(const std::string &Name) { 4568 if ((Name == "o32") || (Name == "eabi")) { 4569 ABI = Name; 4570 return true; 4571 } else if (Name == "32") { 4572 ABI = "o32"; 4573 return true; 4574 } else 4575 return false; 4576 } 4577 virtual void getTargetDefines(const LangOptions &Opts, 4578 MacroBuilder &Builder) const { 4579 MipsTargetInfoBase::getTargetDefines(Opts, Builder); 4580 4581 if (ABI == "o32") { 4582 Builder.defineMacro("__mips_o32"); 4583 Builder.defineMacro("_ABIO32", "1"); 4584 Builder.defineMacro("_MIPS_SIM", "_ABIO32"); 4585 } 4586 else if (ABI == "eabi") 4587 Builder.defineMacro("__mips_eabi"); 4588 else 4589 llvm_unreachable("Invalid ABI for Mips32."); 4590 } 4591 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4592 unsigned &NumAliases) const { 4593 static const TargetInfo::GCCRegAlias GCCRegAliases[] = { 4594 { { "at" }, "$1" }, 4595 { { "v0" }, "$2" }, 4596 { { "v1" }, "$3" }, 4597 { { "a0" }, "$4" }, 4598 { { "a1" }, "$5" }, 4599 { { "a2" }, "$6" }, 4600 { { "a3" }, "$7" }, 4601 { { "t0" }, "$8" }, 4602 { { "t1" }, "$9" }, 4603 { { "t2" }, "$10" }, 4604 { { "t3" }, "$11" }, 4605 { { "t4" }, "$12" }, 4606 { { "t5" }, "$13" }, 4607 { { "t6" }, "$14" }, 4608 { { "t7" }, "$15" }, 4609 { { "s0" }, "$16" }, 4610 { { "s1" }, "$17" }, 4611 { { "s2" }, "$18" }, 4612 { { "s3" }, "$19" }, 4613 { { "s4" }, "$20" }, 4614 { { "s5" }, "$21" }, 4615 { { "s6" }, "$22" }, 4616 { { "s7" }, "$23" }, 4617 { { "t8" }, "$24" }, 4618 { { "t9" }, "$25" }, 4619 { { "k0" }, "$26" }, 4620 { { "k1" }, "$27" }, 4621 { { "gp" }, "$28" }, 4622 { { "sp","$sp" }, "$29" }, 4623 { { "fp","$fp" }, "$30" }, 4624 { { "ra" }, "$31" } 4625 }; 4626 Aliases = GCCRegAliases; 4627 NumAliases = llvm::array_lengthof(GCCRegAliases); 4628 } 4629 }; 4630 4631 class Mips32EBTargetInfo : public Mips32TargetInfoBase { 4632 public: 4633 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) { 4634 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-" 4635 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64"; 4636 } 4637 virtual void getTargetDefines(const LangOptions &Opts, 4638 MacroBuilder &Builder) const { 4639 DefineStd(Builder, "MIPSEB", Opts); 4640 Builder.defineMacro("_MIPSEB"); 4641 Mips32TargetInfoBase::getTargetDefines(Opts, Builder); 4642 } 4643 }; 4644 4645 class Mips32ELTargetInfo : public Mips32TargetInfoBase { 4646 public: 4647 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) { 4648 BigEndian = false; 4649 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-" 4650 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64"; 4651 } 4652 virtual void getTargetDefines(const LangOptions &Opts, 4653 MacroBuilder &Builder) const { 4654 DefineStd(Builder, "MIPSEL", Opts); 4655 Builder.defineMacro("_MIPSEL"); 4656 Mips32TargetInfoBase::getTargetDefines(Opts, Builder); 4657 } 4658 }; 4659 4660 class Mips64TargetInfoBase : public MipsTargetInfoBase { 4661 virtual void SetDescriptionString(const std::string &Name) = 0; 4662 public: 4663 Mips64TargetInfoBase(const std::string& triple) : 4664 MipsTargetInfoBase(triple, "n64", "mips64") { 4665 LongWidth = LongAlign = 64; 4666 PointerWidth = PointerAlign = 64; 4667 LongDoubleWidth = LongDoubleAlign = 128; 4668 LongDoubleFormat = &llvm::APFloat::IEEEquad; 4669 if (getTriple().getOS() == llvm::Triple::FreeBSD) { 4670 LongDoubleWidth = LongDoubleAlign = 64; 4671 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 4672 } 4673 SuitableAlign = 128; 4674 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; 4675 } 4676 virtual bool setABI(const std::string &Name) { 4677 SetDescriptionString(Name); 4678 if (Name == "n32") { 4679 LongWidth = LongAlign = 32; 4680 PointerWidth = PointerAlign = 32; 4681 ABI = Name; 4682 return true; 4683 } else if (Name == "n64") { 4684 ABI = Name; 4685 return true; 4686 } else if (Name == "64") { 4687 ABI = "n64"; 4688 return true; 4689 } else 4690 return false; 4691 } 4692 virtual void getTargetDefines(const LangOptions &Opts, 4693 MacroBuilder &Builder) const { 4694 MipsTargetInfoBase::getTargetDefines(Opts, Builder); 4695 4696 Builder.defineMacro("__mips64"); 4697 Builder.defineMacro("__mips64__"); 4698 4699 if (ABI == "n32") { 4700 Builder.defineMacro("__mips_n32"); 4701 Builder.defineMacro("_ABIN32", "2"); 4702 Builder.defineMacro("_MIPS_SIM", "_ABIN32"); 4703 } 4704 else if (ABI == "n64") { 4705 Builder.defineMacro("__mips_n64"); 4706 Builder.defineMacro("_ABI64", "3"); 4707 Builder.defineMacro("_MIPS_SIM", "_ABI64"); 4708 } 4709 else 4710 llvm_unreachable("Invalid ABI for Mips64."); 4711 } 4712 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4713 unsigned &NumAliases) const { 4714 static const TargetInfo::GCCRegAlias GCCRegAliases[] = { 4715 { { "at" }, "$1" }, 4716 { { "v0" }, "$2" }, 4717 { { "v1" }, "$3" }, 4718 { { "a0" }, "$4" }, 4719 { { "a1" }, "$5" }, 4720 { { "a2" }, "$6" }, 4721 { { "a3" }, "$7" }, 4722 { { "a4" }, "$8" }, 4723 { { "a5" }, "$9" }, 4724 { { "a6" }, "$10" }, 4725 { { "a7" }, "$11" }, 4726 { { "t0" }, "$12" }, 4727 { { "t1" }, "$13" }, 4728 { { "t2" }, "$14" }, 4729 { { "t3" }, "$15" }, 4730 { { "s0" }, "$16" }, 4731 { { "s1" }, "$17" }, 4732 { { "s2" }, "$18" }, 4733 { { "s3" }, "$19" }, 4734 { { "s4" }, "$20" }, 4735 { { "s5" }, "$21" }, 4736 { { "s6" }, "$22" }, 4737 { { "s7" }, "$23" }, 4738 { { "t8" }, "$24" }, 4739 { { "t9" }, "$25" }, 4740 { { "k0" }, "$26" }, 4741 { { "k1" }, "$27" }, 4742 { { "gp" }, "$28" }, 4743 { { "sp","$sp" }, "$29" }, 4744 { { "fp","$fp" }, "$30" }, 4745 { { "ra" }, "$31" } 4746 }; 4747 Aliases = GCCRegAliases; 4748 NumAliases = llvm::array_lengthof(GCCRegAliases); 4749 } 4750 }; 4751 4752 class Mips64EBTargetInfo : public Mips64TargetInfoBase { 4753 virtual void SetDescriptionString(const std::string &Name) { 4754 // Change DescriptionString only if ABI is n32. 4755 if (Name == "n32") 4756 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-" 4757 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-" 4758 "v64:64:64-n32:64-S128"; 4759 } 4760 public: 4761 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) { 4762 // Default ABI is n64. 4763 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-" 4764 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-" 4765 "v64:64:64-n32:64-S128"; 4766 } 4767 virtual void getTargetDefines(const LangOptions &Opts, 4768 MacroBuilder &Builder) const { 4769 DefineStd(Builder, "MIPSEB", Opts); 4770 Builder.defineMacro("_MIPSEB"); 4771 Mips64TargetInfoBase::getTargetDefines(Opts, Builder); 4772 } 4773 }; 4774 4775 class Mips64ELTargetInfo : public Mips64TargetInfoBase { 4776 virtual void SetDescriptionString(const std::string &Name) { 4777 // Change DescriptionString only if ABI is n32. 4778 if (Name == "n32") 4779 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-" 4780 "i64:64:64-f32:32:32-f64:64:64-f128:128:128" 4781 "-v64:64:64-n32:64-S128"; 4782 } 4783 public: 4784 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) { 4785 // Default ABI is n64. 4786 BigEndian = false; 4787 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-" 4788 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-" 4789 "v64:64:64-n32:64-S128"; 4790 } 4791 virtual void getTargetDefines(const LangOptions &Opts, 4792 MacroBuilder &Builder) const { 4793 DefineStd(Builder, "MIPSEL", Opts); 4794 Builder.defineMacro("_MIPSEL"); 4795 Mips64TargetInfoBase::getTargetDefines(Opts, Builder); 4796 } 4797 }; 4798 } // end anonymous namespace. 4799 4800 namespace { 4801 class PNaClTargetInfo : public TargetInfo { 4802 public: 4803 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) { 4804 BigEndian = false; 4805 this->UserLabelPrefix = ""; 4806 this->LongAlign = 32; 4807 this->LongWidth = 32; 4808 this->PointerAlign = 32; 4809 this->PointerWidth = 32; 4810 this->IntMaxType = TargetInfo::SignedLongLong; 4811 this->UIntMaxType = TargetInfo::UnsignedLongLong; 4812 this->Int64Type = TargetInfo::SignedLongLong; 4813 this->DoubleAlign = 64; 4814 this->LongDoubleWidth = 64; 4815 this->LongDoubleAlign = 64; 4816 this->SizeType = TargetInfo::UnsignedInt; 4817 this->PtrDiffType = TargetInfo::SignedInt; 4818 this->IntPtrType = TargetInfo::SignedInt; 4819 this->RegParmMax = 2; 4820 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-" 4821 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32"; 4822 } 4823 4824 void getDefaultFeatures(llvm::StringMap<bool> &Features) const { 4825 } 4826 virtual void getArchDefines(const LangOptions &Opts, 4827 MacroBuilder &Builder) const { 4828 Builder.defineMacro("__le32__"); 4829 Builder.defineMacro("__pnacl__"); 4830 } 4831 virtual void getTargetDefines(const LangOptions &Opts, 4832 MacroBuilder &Builder) const { 4833 Builder.defineMacro("__LITTLE_ENDIAN__"); 4834 getArchDefines(Opts, Builder); 4835 } 4836 virtual bool hasFeature(StringRef Feature) const { 4837 return Feature == "pnacl"; 4838 } 4839 virtual void getTargetBuiltins(const Builtin::Info *&Records, 4840 unsigned &NumRecords) const { 4841 } 4842 virtual BuiltinVaListKind getBuiltinVaListKind() const { 4843 return TargetInfo::PNaClABIBuiltinVaList; 4844 } 4845 virtual void getGCCRegNames(const char * const *&Names, 4846 unsigned &NumNames) const; 4847 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4848 unsigned &NumAliases) const; 4849 virtual bool validateAsmConstraint(const char *&Name, 4850 TargetInfo::ConstraintInfo &Info) const { 4851 return false; 4852 } 4853 4854 virtual const char *getClobbers() const { 4855 return ""; 4856 } 4857 }; 4858 4859 void PNaClTargetInfo::getGCCRegNames(const char * const *&Names, 4860 unsigned &NumNames) const { 4861 Names = NULL; 4862 NumNames = 0; 4863 } 4864 4865 void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases, 4866 unsigned &NumAliases) const { 4867 Aliases = NULL; 4868 NumAliases = 0; 4869 } 4870 } // end anonymous namespace. 4871 4872 namespace { 4873 static const unsigned SPIRAddrSpaceMap[] = { 4874 1, // opencl_global 4875 3, // opencl_local 4876 2, // opencl_constant 4877 0, // cuda_device 4878 0, // cuda_constant 4879 0 // cuda_shared 4880 }; 4881 class SPIRTargetInfo : public TargetInfo { 4882 static const char * const GCCRegNames[]; 4883 static const Builtin::Info BuiltinInfo[]; 4884 std::vector<StringRef> AvailableFeatures; 4885 public: 4886 SPIRTargetInfo(const std::string& triple) : TargetInfo(triple) { 4887 assert(getTriple().getOS() == llvm::Triple::UnknownOS && 4888 "SPIR target must use unknown OS"); 4889 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment && 4890 "SPIR target must use unknown environment type"); 4891 BigEndian = false; 4892 TLSSupported = false; 4893 LongWidth = LongAlign = 64; 4894 AddrSpaceMap = &SPIRAddrSpaceMap; 4895 // Define available target features 4896 // These must be defined in sorted order! 4897 NoAsmVariants = true; 4898 } 4899 virtual void getTargetDefines(const LangOptions &Opts, 4900 MacroBuilder &Builder) const { 4901 DefineStd(Builder, "SPIR", Opts); 4902 } 4903 virtual bool hasFeature(StringRef Feature) const { 4904 return Feature == "spir"; 4905 } 4906 4907 virtual void getTargetBuiltins(const Builtin::Info *&Records, 4908 unsigned &NumRecords) const {} 4909 virtual const char *getClobbers() const { 4910 return ""; 4911 } 4912 virtual void getGCCRegNames(const char * const *&Names, 4913 unsigned &NumNames) const {} 4914 virtual bool validateAsmConstraint(const char *&Name, 4915 TargetInfo::ConstraintInfo &info) const { 4916 return true; 4917 } 4918 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, 4919 unsigned &NumAliases) const {} 4920 virtual BuiltinVaListKind getBuiltinVaListKind() const { 4921 return TargetInfo::VoidPtrBuiltinVaList; 4922 } 4923 }; 4924 4925 4926 class SPIR32TargetInfo : public SPIRTargetInfo { 4927 public: 4928 SPIR32TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) { 4929 PointerWidth = PointerAlign = 32; 4930 SizeType = TargetInfo::UnsignedInt; 4931 PtrDiffType = IntPtrType = TargetInfo::SignedInt; 4932 DescriptionString 4933 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-" 4934 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-" 4935 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-" 4936 "v512:512:512-v1024:1024:1024"; 4937 } 4938 virtual void getTargetDefines(const LangOptions &Opts, 4939 MacroBuilder &Builder) const { 4940 DefineStd(Builder, "SPIR32", Opts); 4941 } 4942 }; 4943 4944 class SPIR64TargetInfo : public SPIRTargetInfo { 4945 public: 4946 SPIR64TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) { 4947 PointerWidth = PointerAlign = 64; 4948 SizeType = TargetInfo::UnsignedLong; 4949 PtrDiffType = IntPtrType = TargetInfo::SignedLong; 4950 DescriptionString 4951 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-" 4952 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-" 4953 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-" 4954 "v512:512:512-v1024:1024:1024"; 4955 } 4956 virtual void getTargetDefines(const LangOptions &Opts, 4957 MacroBuilder &Builder) const { 4958 DefineStd(Builder, "SPIR64", Opts); 4959 } 4960 }; 4961 } 4962 4963 4964 //===----------------------------------------------------------------------===// 4965 // Driver code 4966 //===----------------------------------------------------------------------===// 4967 4968 static TargetInfo *AllocateTarget(const std::string &T) { 4969 llvm::Triple Triple(T); 4970 llvm::Triple::OSType os = Triple.getOS(); 4971 4972 switch (Triple.getArch()) { 4973 default: 4974 return NULL; 4975 4976 case llvm::Triple::hexagon: 4977 return new HexagonTargetInfo(T); 4978 4979 case llvm::Triple::aarch64: 4980 switch (os) { 4981 case llvm::Triple::Linux: 4982 return new LinuxTargetInfo<AArch64TargetInfo>(T); 4983 default: 4984 return new AArch64TargetInfo(T); 4985 } 4986 4987 case llvm::Triple::arm: 4988 case llvm::Triple::thumb: 4989 if (Triple.isOSDarwin()) 4990 return new DarwinARMTargetInfo(T); 4991 4992 switch (os) { 4993 case llvm::Triple::Linux: 4994 return new LinuxTargetInfo<ARMTargetInfo>(T); 4995 case llvm::Triple::FreeBSD: 4996 return new FreeBSDTargetInfo<ARMTargetInfo>(T); 4997 case llvm::Triple::NetBSD: 4998 return new NetBSDTargetInfo<ARMTargetInfo>(T); 4999 case llvm::Triple::OpenBSD: 5000 return new OpenBSDTargetInfo<ARMTargetInfo>(T); 5001 case llvm::Triple::Bitrig: 5002 return new BitrigTargetInfo<ARMTargetInfo>(T); 5003 case llvm::Triple::RTEMS: 5004 return new RTEMSTargetInfo<ARMTargetInfo>(T); 5005 case llvm::Triple::NaCl: 5006 return new NaClTargetInfo<ARMTargetInfo>(T); 5007 default: 5008 return new ARMTargetInfo(T); 5009 } 5010 5011 case llvm::Triple::msp430: 5012 return new MSP430TargetInfo(T); 5013 5014 case llvm::Triple::mips: 5015 switch (os) { 5016 case llvm::Triple::Linux: 5017 return new LinuxTargetInfo<Mips32EBTargetInfo>(T); 5018 case llvm::Triple::RTEMS: 5019 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T); 5020 case llvm::Triple::FreeBSD: 5021 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T); 5022 case llvm::Triple::NetBSD: 5023 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T); 5024 default: 5025 return new Mips32EBTargetInfo(T); 5026 } 5027 5028 case llvm::Triple::mipsel: 5029 switch (os) { 5030 case llvm::Triple::Linux: 5031 return new LinuxTargetInfo<Mips32ELTargetInfo>(T); 5032 case llvm::Triple::RTEMS: 5033 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T); 5034 case llvm::Triple::FreeBSD: 5035 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T); 5036 case llvm::Triple::NetBSD: 5037 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T); 5038 default: 5039 return new Mips32ELTargetInfo(T); 5040 } 5041 5042 case llvm::Triple::mips64: 5043 switch (os) { 5044 case llvm::Triple::Linux: 5045 return new LinuxTargetInfo<Mips64EBTargetInfo>(T); 5046 case llvm::Triple::RTEMS: 5047 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T); 5048 case llvm::Triple::FreeBSD: 5049 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T); 5050 case llvm::Triple::NetBSD: 5051 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T); 5052 case llvm::Triple::OpenBSD: 5053 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(T); 5054 default: 5055 return new Mips64EBTargetInfo(T); 5056 } 5057 5058 case llvm::Triple::mips64el: 5059 switch (os) { 5060 case llvm::Triple::Linux: 5061 return new LinuxTargetInfo<Mips64ELTargetInfo>(T); 5062 case llvm::Triple::RTEMS: 5063 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T); 5064 case llvm::Triple::FreeBSD: 5065 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T); 5066 case llvm::Triple::NetBSD: 5067 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T); 5068 case llvm::Triple::OpenBSD: 5069 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(T); 5070 default: 5071 return new Mips64ELTargetInfo(T); 5072 } 5073 5074 case llvm::Triple::le32: 5075 switch (os) { 5076 case llvm::Triple::NaCl: 5077 return new NaClTargetInfo<PNaClTargetInfo>(T); 5078 default: 5079 return NULL; 5080 } 5081 5082 case llvm::Triple::ppc: 5083 if (Triple.isOSDarwin()) 5084 return new DarwinPPC32TargetInfo(T); 5085 switch (os) { 5086 case llvm::Triple::Linux: 5087 return new LinuxTargetInfo<PPC32TargetInfo>(T); 5088 case llvm::Triple::FreeBSD: 5089 return new FreeBSDTargetInfo<PPC32TargetInfo>(T); 5090 case llvm::Triple::NetBSD: 5091 return new NetBSDTargetInfo<PPC32TargetInfo>(T); 5092 case llvm::Triple::OpenBSD: 5093 return new OpenBSDTargetInfo<PPC32TargetInfo>(T); 5094 case llvm::Triple::RTEMS: 5095 return new RTEMSTargetInfo<PPC32TargetInfo>(T); 5096 default: 5097 return new PPC32TargetInfo(T); 5098 } 5099 5100 case llvm::Triple::ppc64: 5101 if (Triple.isOSDarwin()) 5102 return new DarwinPPC64TargetInfo(T); 5103 switch (os) { 5104 case llvm::Triple::Linux: 5105 return new LinuxTargetInfo<PPC64TargetInfo>(T); 5106 case llvm::Triple::Lv2: 5107 return new PS3PPUTargetInfo<PPC64TargetInfo>(T); 5108 case llvm::Triple::FreeBSD: 5109 return new FreeBSDTargetInfo<PPC64TargetInfo>(T); 5110 case llvm::Triple::NetBSD: 5111 return new NetBSDTargetInfo<PPC64TargetInfo>(T); 5112 default: 5113 return new PPC64TargetInfo(T); 5114 } 5115 5116 case llvm::Triple::nvptx: 5117 return new NVPTX32TargetInfo(T); 5118 case llvm::Triple::nvptx64: 5119 return new NVPTX64TargetInfo(T); 5120 5121 case llvm::Triple::mblaze: 5122 return new MBlazeTargetInfo(T); 5123 5124 case llvm::Triple::r600: 5125 return new R600TargetInfo(T); 5126 5127 case llvm::Triple::sparc: 5128 switch (os) { 5129 case llvm::Triple::Linux: 5130 return new LinuxTargetInfo<SparcV8TargetInfo>(T); 5131 case llvm::Triple::AuroraUX: 5132 return new AuroraUXSparcV8TargetInfo(T); 5133 case llvm::Triple::Solaris: 5134 return new SolarisSparcV8TargetInfo(T); 5135 case llvm::Triple::NetBSD: 5136 return new NetBSDTargetInfo<SparcV8TargetInfo>(T); 5137 case llvm::Triple::OpenBSD: 5138 return new OpenBSDTargetInfo<SparcV8TargetInfo>(T); 5139 case llvm::Triple::RTEMS: 5140 return new RTEMSTargetInfo<SparcV8TargetInfo>(T); 5141 default: 5142 return new SparcV8TargetInfo(T); 5143 } 5144 5145 case llvm::Triple::tce: 5146 return new TCETargetInfo(T); 5147 5148 case llvm::Triple::x86: 5149 if (Triple.isOSDarwin()) 5150 return new DarwinI386TargetInfo(T); 5151 5152 switch (os) { 5153 case llvm::Triple::AuroraUX: 5154 return new AuroraUXTargetInfo<X86_32TargetInfo>(T); 5155 case llvm::Triple::Linux: 5156 return new LinuxTargetInfo<X86_32TargetInfo>(T); 5157 case llvm::Triple::DragonFly: 5158 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T); 5159 case llvm::Triple::NetBSD: 5160 return new NetBSDI386TargetInfo(T); 5161 case llvm::Triple::OpenBSD: 5162 return new OpenBSDI386TargetInfo(T); 5163 case llvm::Triple::Bitrig: 5164 return new BitrigI386TargetInfo(T); 5165 case llvm::Triple::FreeBSD: 5166 return new FreeBSDTargetInfo<X86_32TargetInfo>(T); 5167 case llvm::Triple::Minix: 5168 return new MinixTargetInfo<X86_32TargetInfo>(T); 5169 case llvm::Triple::Solaris: 5170 return new SolarisTargetInfo<X86_32TargetInfo>(T); 5171 case llvm::Triple::Cygwin: 5172 return new CygwinX86_32TargetInfo(T); 5173 case llvm::Triple::MinGW32: 5174 return new MinGWX86_32TargetInfo(T); 5175 case llvm::Triple::Win32: 5176 return new VisualStudioWindowsX86_32TargetInfo(T); 5177 case llvm::Triple::Haiku: 5178 return new HaikuX86_32TargetInfo(T); 5179 case llvm::Triple::RTEMS: 5180 return new RTEMSX86_32TargetInfo(T); 5181 case llvm::Triple::NaCl: 5182 return new NaClTargetInfo<X86_32TargetInfo>(T); 5183 default: 5184 return new X86_32TargetInfo(T); 5185 } 5186 5187 case llvm::Triple::x86_64: 5188 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO) 5189 return new DarwinX86_64TargetInfo(T); 5190 5191 switch (os) { 5192 case llvm::Triple::AuroraUX: 5193 return new AuroraUXTargetInfo<X86_64TargetInfo>(T); 5194 case llvm::Triple::Linux: 5195 return new LinuxTargetInfo<X86_64TargetInfo>(T); 5196 case llvm::Triple::DragonFly: 5197 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T); 5198 case llvm::Triple::NetBSD: 5199 return new NetBSDTargetInfo<X86_64TargetInfo>(T); 5200 case llvm::Triple::OpenBSD: 5201 return new OpenBSDX86_64TargetInfo(T); 5202 case llvm::Triple::Bitrig: 5203 return new BitrigX86_64TargetInfo(T); 5204 case llvm::Triple::FreeBSD: 5205 return new FreeBSDTargetInfo<X86_64TargetInfo>(T); 5206 case llvm::Triple::Solaris: 5207 return new SolarisTargetInfo<X86_64TargetInfo>(T); 5208 case llvm::Triple::MinGW32: 5209 return new MinGWX86_64TargetInfo(T); 5210 case llvm::Triple::Win32: // This is what Triple.h supports now. 5211 return new VisualStudioWindowsX86_64TargetInfo(T); 5212 case llvm::Triple::NaCl: 5213 return new NaClTargetInfo<X86_64TargetInfo>(T); 5214 default: 5215 return new X86_64TargetInfo(T); 5216 } 5217 5218 case llvm::Triple::spir: { 5219 llvm::Triple Triple(T); 5220 if (Triple.getOS() != llvm::Triple::UnknownOS || 5221 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 5222 return NULL; 5223 return new SPIR32TargetInfo(T); 5224 } 5225 case llvm::Triple::spir64: { 5226 llvm::Triple Triple(T); 5227 if (Triple.getOS() != llvm::Triple::UnknownOS || 5228 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) 5229 return NULL; 5230 return new SPIR64TargetInfo(T); 5231 } 5232 } 5233 } 5234 5235 /// CreateTargetInfo - Return the target info object for the specified target 5236 /// triple. 5237 TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, 5238 TargetOptions *Opts) { 5239 llvm::Triple Triple(Opts->Triple); 5240 5241 // Construct the target 5242 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str())); 5243 if (!Target) { 5244 Diags.Report(diag::err_target_unknown_triple) << Triple.str(); 5245 return 0; 5246 } 5247 Target->setTargetOpts(Opts); 5248 5249 // Set the target CPU if specified. 5250 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) { 5251 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; 5252 return 0; 5253 } 5254 5255 // Set the target ABI if specified. 5256 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) { 5257 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; 5258 return 0; 5259 } 5260 5261 // Set the target C++ ABI. 5262 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) { 5263 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI; 5264 return 0; 5265 } 5266 5267 // Compute the default target features, we need the target to handle this 5268 // because features may have dependencies on one another. 5269 llvm::StringMap<bool> Features; 5270 Target->getDefaultFeatures(Features); 5271 5272 // Apply the user specified deltas. 5273 // First the enables. 5274 for (std::vector<std::string>::const_iterator 5275 it = Opts->FeaturesAsWritten.begin(), 5276 ie = Opts->FeaturesAsWritten.end(); 5277 it != ie; ++it) { 5278 const char *Name = it->c_str(); 5279 5280 if (Name[0] != '+') 5281 continue; 5282 5283 // Apply the feature via the target. 5284 if (!Target->setFeatureEnabled(Features, Name + 1, true)) { 5285 Diags.Report(diag::err_target_invalid_feature) << Name; 5286 return 0; 5287 } 5288 } 5289 5290 // Then the disables. 5291 for (std::vector<std::string>::const_iterator 5292 it = Opts->FeaturesAsWritten.begin(), 5293 ie = Opts->FeaturesAsWritten.end(); 5294 it != ie; ++it) { 5295 const char *Name = it->c_str(); 5296 5297 if (Name[0] == '+') 5298 continue; 5299 5300 // Apply the feature via the target. 5301 if (Name[0] != '-' || 5302 !Target->setFeatureEnabled(Features, Name + 1, false)) { 5303 Diags.Report(diag::err_target_invalid_feature) << Name; 5304 return 0; 5305 } 5306 } 5307 5308 // Add the features to the compile options. 5309 // 5310 // FIXME: If we are completely confident that we have the right set, we only 5311 // need to pass the minuses. 5312 Opts->Features.clear(); 5313 for (llvm::StringMap<bool>::const_iterator it = Features.begin(), 5314 ie = Features.end(); it != ie; ++it) 5315 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str()); 5316 Target->HandleTargetFeatures(Opts->Features); 5317 5318 return Target.take(); 5319 } 5320