1 //===--- Triple.cpp - Target triple helper class --------------------------===// 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 #include "llvm/ADT/Triple.h" 11 #include "llvm/ADT/STLExtras.h" 12 #include "llvm/ADT/SmallString.h" 13 #include "llvm/ADT/StringSwitch.h" 14 #include "llvm/Support/ErrorHandling.h" 15 #include "llvm/Support/TargetParser.h" 16 #include "llvm/Support/Host.h" 17 #include <cstring> 18 using namespace llvm; 19 20 StringRef Triple::getArchTypeName(ArchType Kind) { 21 switch (Kind) { 22 case UnknownArch: return "unknown"; 23 24 case aarch64: return "aarch64"; 25 case aarch64_be: return "aarch64_be"; 26 case arm: return "arm"; 27 case armeb: return "armeb"; 28 case avr: return "avr"; 29 case bpfel: return "bpfel"; 30 case bpfeb: return "bpfeb"; 31 case hexagon: return "hexagon"; 32 case mips: return "mips"; 33 case mipsel: return "mipsel"; 34 case mips64: return "mips64"; 35 case mips64el: return "mips64el"; 36 case msp430: return "msp430"; 37 case ppc64: return "powerpc64"; 38 case ppc64le: return "powerpc64le"; 39 case ppc: return "powerpc"; 40 case r600: return "r600"; 41 case amdgcn: return "amdgcn"; 42 case riscv32: return "riscv32"; 43 case riscv64: return "riscv64"; 44 case sparc: return "sparc"; 45 case sparcv9: return "sparcv9"; 46 case sparcel: return "sparcel"; 47 case systemz: return "s390x"; 48 case tce: return "tce"; 49 case thumb: return "thumb"; 50 case thumbeb: return "thumbeb"; 51 case x86: return "i386"; 52 case x86_64: return "x86_64"; 53 case xcore: return "xcore"; 54 case nvptx: return "nvptx"; 55 case nvptx64: return "nvptx64"; 56 case le32: return "le32"; 57 case le64: return "le64"; 58 case amdil: return "amdil"; 59 case amdil64: return "amdil64"; 60 case hsail: return "hsail"; 61 case hsail64: return "hsail64"; 62 case spir: return "spir"; 63 case spir64: return "spir64"; 64 case kalimba: return "kalimba"; 65 case lanai: return "lanai"; 66 case shave: return "shave"; 67 case wasm32: return "wasm32"; 68 case wasm64: return "wasm64"; 69 case renderscript32: return "renderscript32"; 70 case renderscript64: return "renderscript64"; 71 } 72 73 llvm_unreachable("Invalid ArchType!"); 74 } 75 76 StringRef Triple::getArchTypePrefix(ArchType Kind) { 77 switch (Kind) { 78 default: 79 return StringRef(); 80 81 case aarch64: 82 case aarch64_be: return "aarch64"; 83 84 case arm: 85 case armeb: 86 case thumb: 87 case thumbeb: return "arm"; 88 89 case avr: return "avr"; 90 91 case ppc64: 92 case ppc64le: 93 case ppc: return "ppc"; 94 95 case mips: 96 case mipsel: 97 case mips64: 98 case mips64el: return "mips"; 99 100 case hexagon: return "hexagon"; 101 102 case amdgcn: return "amdgcn"; 103 case r600: return "r600"; 104 105 case bpfel: 106 case bpfeb: return "bpf"; 107 108 case sparcv9: 109 case sparcel: 110 case sparc: return "sparc"; 111 112 case systemz: return "s390"; 113 114 case x86: 115 case x86_64: return "x86"; 116 117 case xcore: return "xcore"; 118 119 // NVPTX intrinsics are namespaced under nvvm. 120 case nvptx: return "nvvm"; 121 case nvptx64: return "nvvm"; 122 123 case le32: return "le32"; 124 case le64: return "le64"; 125 126 case amdil: 127 case amdil64: return "amdil"; 128 129 case hsail: 130 case hsail64: return "hsail"; 131 132 case spir: 133 case spir64: return "spir"; 134 case kalimba: return "kalimba"; 135 case lanai: return "lanai"; 136 case shave: return "shave"; 137 case wasm32: 138 case wasm64: return "wasm"; 139 140 case riscv32: 141 case riscv64: return "riscv"; 142 } 143 } 144 145 StringRef Triple::getVendorTypeName(VendorType Kind) { 146 switch (Kind) { 147 case UnknownVendor: return "unknown"; 148 149 case Apple: return "apple"; 150 case PC: return "pc"; 151 case SCEI: return "scei"; 152 case BGP: return "bgp"; 153 case BGQ: return "bgq"; 154 case Freescale: return "fsl"; 155 case IBM: return "ibm"; 156 case ImaginationTechnologies: return "img"; 157 case MipsTechnologies: return "mti"; 158 case NVIDIA: return "nvidia"; 159 case CSR: return "csr"; 160 case Myriad: return "myriad"; 161 case AMD: return "amd"; 162 case Mesa: return "mesa"; 163 } 164 165 llvm_unreachable("Invalid VendorType!"); 166 } 167 168 StringRef Triple::getOSTypeName(OSType Kind) { 169 switch (Kind) { 170 case UnknownOS: return "unknown"; 171 172 case CloudABI: return "cloudabi"; 173 case Darwin: return "darwin"; 174 case DragonFly: return "dragonfly"; 175 case FreeBSD: return "freebsd"; 176 case Fuchsia: return "fuchsia"; 177 case IOS: return "ios"; 178 case KFreeBSD: return "kfreebsd"; 179 case Linux: return "linux"; 180 case Lv2: return "lv2"; 181 case MacOSX: return "macosx"; 182 case NetBSD: return "netbsd"; 183 case OpenBSD: return "openbsd"; 184 case Solaris: return "solaris"; 185 case Win32: return "windows"; 186 case Haiku: return "haiku"; 187 case Minix: return "minix"; 188 case RTEMS: return "rtems"; 189 case NaCl: return "nacl"; 190 case CNK: return "cnk"; 191 case Bitrig: return "bitrig"; 192 case AIX: return "aix"; 193 case CUDA: return "cuda"; 194 case NVCL: return "nvcl"; 195 case AMDHSA: return "amdhsa"; 196 case PS4: return "ps4"; 197 case ELFIAMCU: return "elfiamcu"; 198 case TvOS: return "tvos"; 199 case WatchOS: return "watchos"; 200 case Mesa3D: return "mesa3d"; 201 case Contiki: return "contiki"; 202 } 203 204 llvm_unreachable("Invalid OSType"); 205 } 206 207 StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) { 208 switch (Kind) { 209 case UnknownEnvironment: return "unknown"; 210 case GNU: return "gnu"; 211 case GNUABI64: return "gnuabi64"; 212 case GNUEABIHF: return "gnueabihf"; 213 case GNUEABI: return "gnueabi"; 214 case GNUX32: return "gnux32"; 215 case CODE16: return "code16"; 216 case EABI: return "eabi"; 217 case EABIHF: return "eabihf"; 218 case Android: return "android"; 219 case Musl: return "musl"; 220 case MuslEABI: return "musleabi"; 221 case MuslEABIHF: return "musleabihf"; 222 case MSVC: return "msvc"; 223 case Itanium: return "itanium"; 224 case Cygnus: return "cygnus"; 225 case AMDOpenCL: return "amdopencl"; 226 case CoreCLR: return "coreclr"; 227 case OpenCL: return "opencl"; 228 } 229 230 llvm_unreachable("Invalid EnvironmentType!"); 231 } 232 233 static Triple::ArchType parseBPFArch(StringRef ArchName) { 234 if (ArchName.equals("bpf")) { 235 if (sys::IsLittleEndianHost) 236 return Triple::bpfel; 237 else 238 return Triple::bpfeb; 239 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) { 240 return Triple::bpfeb; 241 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) { 242 return Triple::bpfel; 243 } else { 244 return Triple::UnknownArch; 245 } 246 } 247 248 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) { 249 Triple::ArchType BPFArch(parseBPFArch(Name)); 250 return StringSwitch<Triple::ArchType>(Name) 251 .Case("aarch64", aarch64) 252 .Case("aarch64_be", aarch64_be) 253 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64" 254 .Case("arm", arm) 255 .Case("armeb", armeb) 256 .Case("avr", avr) 257 .StartsWith("bpf", BPFArch) 258 .Case("mips", mips) 259 .Case("mipsel", mipsel) 260 .Case("mips64", mips64) 261 .Case("mips64el", mips64el) 262 .Case("msp430", msp430) 263 .Case("ppc64", ppc64) 264 .Case("ppc32", ppc) 265 .Case("ppc", ppc) 266 .Case("ppc64le", ppc64le) 267 .Case("r600", r600) 268 .Case("amdgcn", amdgcn) 269 .Case("riscv32", riscv32) 270 .Case("riscv64", riscv64) 271 .Case("hexagon", hexagon) 272 .Case("sparc", sparc) 273 .Case("sparcel", sparcel) 274 .Case("sparcv9", sparcv9) 275 .Case("systemz", systemz) 276 .Case("tce", tce) 277 .Case("thumb", thumb) 278 .Case("thumbeb", thumbeb) 279 .Case("x86", x86) 280 .Case("x86-64", x86_64) 281 .Case("xcore", xcore) 282 .Case("nvptx", nvptx) 283 .Case("nvptx64", nvptx64) 284 .Case("le32", le32) 285 .Case("le64", le64) 286 .Case("amdil", amdil) 287 .Case("amdil64", amdil64) 288 .Case("hsail", hsail) 289 .Case("hsail64", hsail64) 290 .Case("spir", spir) 291 .Case("spir64", spir64) 292 .Case("kalimba", kalimba) 293 .Case("lanai", lanai) 294 .Case("shave", shave) 295 .Case("wasm32", wasm32) 296 .Case("wasm64", wasm64) 297 .Case("renderscript32", renderscript32) 298 .Case("renderscript64", renderscript64) 299 .Default(UnknownArch); 300 } 301 302 static Triple::ArchType parseARMArch(StringRef ArchName) { 303 unsigned ISA = ARM::parseArchISA(ArchName); 304 unsigned ENDIAN = ARM::parseArchEndian(ArchName); 305 306 Triple::ArchType arch = Triple::UnknownArch; 307 switch (ENDIAN) { 308 case ARM::EK_LITTLE: { 309 switch (ISA) { 310 case ARM::IK_ARM: 311 arch = Triple::arm; 312 break; 313 case ARM::IK_THUMB: 314 arch = Triple::thumb; 315 break; 316 case ARM::IK_AARCH64: 317 arch = Triple::aarch64; 318 break; 319 } 320 break; 321 } 322 case ARM::EK_BIG: { 323 switch (ISA) { 324 case ARM::IK_ARM: 325 arch = Triple::armeb; 326 break; 327 case ARM::IK_THUMB: 328 arch = Triple::thumbeb; 329 break; 330 case ARM::IK_AARCH64: 331 arch = Triple::aarch64_be; 332 break; 333 } 334 break; 335 } 336 } 337 338 ArchName = ARM::getCanonicalArchName(ArchName); 339 if (ArchName.empty()) 340 return Triple::UnknownArch; 341 342 // Thumb only exists in v4+ 343 if (ISA == ARM::IK_THUMB && 344 (ArchName.startswith("v2") || ArchName.startswith("v3"))) 345 return Triple::UnknownArch; 346 347 // Thumb only for v6m 348 unsigned Profile = ARM::parseArchProfile(ArchName); 349 unsigned Version = ARM::parseArchVersion(ArchName); 350 if (Profile == ARM::PK_M && Version == 6) { 351 if (ENDIAN == ARM::EK_BIG) 352 return Triple::thumbeb; 353 else 354 return Triple::thumb; 355 } 356 357 return arch; 358 } 359 360 static Triple::ArchType parseArch(StringRef ArchName) { 361 auto AT = StringSwitch<Triple::ArchType>(ArchName) 362 .Cases("i386", "i486", "i586", "i686", Triple::x86) 363 // FIXME: Do we need to support these? 364 .Cases("i786", "i886", "i986", Triple::x86) 365 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64) 366 .Cases("powerpc", "ppc32", Triple::ppc) 367 .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64) 368 .Cases("powerpc64le", "ppc64le", Triple::ppc64le) 369 .Case("xscale", Triple::arm) 370 .Case("xscaleeb", Triple::armeb) 371 .Case("aarch64", Triple::aarch64) 372 .Case("aarch64_be", Triple::aarch64_be) 373 .Case("arm64", Triple::aarch64) 374 .Case("arm", Triple::arm) 375 .Case("armeb", Triple::armeb) 376 .Case("thumb", Triple::thumb) 377 .Case("thumbeb", Triple::thumbeb) 378 .Case("avr", Triple::avr) 379 .Case("msp430", Triple::msp430) 380 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips) 381 .Cases("mipsel", "mipsallegrexel", Triple::mipsel) 382 .Cases("mips64", "mips64eb", Triple::mips64) 383 .Case("mips64el", Triple::mips64el) 384 .Case("r600", Triple::r600) 385 .Case("amdgcn", Triple::amdgcn) 386 .Case("riscv32", Triple::riscv32) 387 .Case("riscv64", Triple::riscv64) 388 .Case("hexagon", Triple::hexagon) 389 .Cases("s390x", "systemz", Triple::systemz) 390 .Case("sparc", Triple::sparc) 391 .Case("sparcel", Triple::sparcel) 392 .Cases("sparcv9", "sparc64", Triple::sparcv9) 393 .Case("tce", Triple::tce) 394 .Case("xcore", Triple::xcore) 395 .Case("nvptx", Triple::nvptx) 396 .Case("nvptx64", Triple::nvptx64) 397 .Case("le32", Triple::le32) 398 .Case("le64", Triple::le64) 399 .Case("amdil", Triple::amdil) 400 .Case("amdil64", Triple::amdil64) 401 .Case("hsail", Triple::hsail) 402 .Case("hsail64", Triple::hsail64) 403 .Case("spir", Triple::spir) 404 .Case("spir64", Triple::spir64) 405 .StartsWith("kalimba", Triple::kalimba) 406 .Case("lanai", Triple::lanai) 407 .Case("shave", Triple::shave) 408 .Case("wasm32", Triple::wasm32) 409 .Case("wasm64", Triple::wasm64) 410 .Case("renderscript32", Triple::renderscript32) 411 .Case("renderscript64", Triple::renderscript64) 412 .Default(Triple::UnknownArch); 413 414 // Some architectures require special parsing logic just to compute the 415 // ArchType result. 416 if (AT == Triple::UnknownArch) { 417 if (ArchName.startswith("arm") || ArchName.startswith("thumb") || 418 ArchName.startswith("aarch64")) 419 return parseARMArch(ArchName); 420 if (ArchName.startswith("bpf")) 421 return parseBPFArch(ArchName); 422 } 423 424 return AT; 425 } 426 427 static Triple::VendorType parseVendor(StringRef VendorName) { 428 return StringSwitch<Triple::VendorType>(VendorName) 429 .Case("apple", Triple::Apple) 430 .Case("pc", Triple::PC) 431 .Case("scei", Triple::SCEI) 432 .Case("bgp", Triple::BGP) 433 .Case("bgq", Triple::BGQ) 434 .Case("fsl", Triple::Freescale) 435 .Case("ibm", Triple::IBM) 436 .Case("img", Triple::ImaginationTechnologies) 437 .Case("mti", Triple::MipsTechnologies) 438 .Case("nvidia", Triple::NVIDIA) 439 .Case("csr", Triple::CSR) 440 .Case("myriad", Triple::Myriad) 441 .Case("amd", Triple::AMD) 442 .Case("mesa", Triple::Mesa) 443 .Default(Triple::UnknownVendor); 444 } 445 446 static Triple::OSType parseOS(StringRef OSName) { 447 return StringSwitch<Triple::OSType>(OSName) 448 .StartsWith("cloudabi", Triple::CloudABI) 449 .StartsWith("darwin", Triple::Darwin) 450 .StartsWith("dragonfly", Triple::DragonFly) 451 .StartsWith("freebsd", Triple::FreeBSD) 452 .StartsWith("fuchsia", Triple::Fuchsia) 453 .StartsWith("ios", Triple::IOS) 454 .StartsWith("kfreebsd", Triple::KFreeBSD) 455 .StartsWith("linux", Triple::Linux) 456 .StartsWith("lv2", Triple::Lv2) 457 .StartsWith("macosx", Triple::MacOSX) 458 .StartsWith("netbsd", Triple::NetBSD) 459 .StartsWith("openbsd", Triple::OpenBSD) 460 .StartsWith("solaris", Triple::Solaris) 461 .StartsWith("win32", Triple::Win32) 462 .StartsWith("windows", Triple::Win32) 463 .StartsWith("haiku", Triple::Haiku) 464 .StartsWith("minix", Triple::Minix) 465 .StartsWith("rtems", Triple::RTEMS) 466 .StartsWith("nacl", Triple::NaCl) 467 .StartsWith("cnk", Triple::CNK) 468 .StartsWith("bitrig", Triple::Bitrig) 469 .StartsWith("aix", Triple::AIX) 470 .StartsWith("cuda", Triple::CUDA) 471 .StartsWith("nvcl", Triple::NVCL) 472 .StartsWith("amdhsa", Triple::AMDHSA) 473 .StartsWith("ps4", Triple::PS4) 474 .StartsWith("elfiamcu", Triple::ELFIAMCU) 475 .StartsWith("tvos", Triple::TvOS) 476 .StartsWith("watchos", Triple::WatchOS) 477 .StartsWith("mesa3d", Triple::Mesa3D) 478 .StartsWith("contiki", Triple::Contiki) 479 .Default(Triple::UnknownOS); 480 } 481 482 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) { 483 return StringSwitch<Triple::EnvironmentType>(EnvironmentName) 484 .StartsWith("eabihf", Triple::EABIHF) 485 .StartsWith("eabi", Triple::EABI) 486 .StartsWith("gnuabi64", Triple::GNUABI64) 487 .StartsWith("gnueabihf", Triple::GNUEABIHF) 488 .StartsWith("gnueabi", Triple::GNUEABI) 489 .StartsWith("gnux32", Triple::GNUX32) 490 .StartsWith("code16", Triple::CODE16) 491 .StartsWith("gnu", Triple::GNU) 492 .StartsWith("android", Triple::Android) 493 .StartsWith("musleabihf", Triple::MuslEABIHF) 494 .StartsWith("musleabi", Triple::MuslEABI) 495 .StartsWith("musl", Triple::Musl) 496 .StartsWith("msvc", Triple::MSVC) 497 .StartsWith("itanium", Triple::Itanium) 498 .StartsWith("cygnus", Triple::Cygnus) 499 .StartsWith("amdopencl", Triple::AMDOpenCL) 500 .StartsWith("coreclr", Triple::CoreCLR) 501 .StartsWith("opencl", Triple::OpenCL) 502 .Default(Triple::UnknownEnvironment); 503 } 504 505 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) { 506 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName) 507 .EndsWith("coff", Triple::COFF) 508 .EndsWith("elf", Triple::ELF) 509 .EndsWith("macho", Triple::MachO) 510 .Default(Triple::UnknownObjectFormat); 511 } 512 513 static Triple::SubArchType parseSubArch(StringRef SubArchName) { 514 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName); 515 516 // For now, this is the small part. Early return. 517 if (ARMSubArch.empty()) 518 return StringSwitch<Triple::SubArchType>(SubArchName) 519 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3) 520 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4) 521 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5) 522 .Default(Triple::NoSubArch); 523 524 // ARM sub arch. 525 switch(ARM::parseArch(ARMSubArch)) { 526 case ARM::AK_ARMV4: 527 return Triple::NoSubArch; 528 case ARM::AK_ARMV4T: 529 return Triple::ARMSubArch_v4t; 530 case ARM::AK_ARMV5T: 531 return Triple::ARMSubArch_v5; 532 case ARM::AK_ARMV5TE: 533 case ARM::AK_IWMMXT: 534 case ARM::AK_IWMMXT2: 535 case ARM::AK_XSCALE: 536 case ARM::AK_ARMV5TEJ: 537 return Triple::ARMSubArch_v5te; 538 case ARM::AK_ARMV6: 539 return Triple::ARMSubArch_v6; 540 case ARM::AK_ARMV6K: 541 case ARM::AK_ARMV6KZ: 542 return Triple::ARMSubArch_v6k; 543 case ARM::AK_ARMV6T2: 544 return Triple::ARMSubArch_v6t2; 545 case ARM::AK_ARMV6M: 546 return Triple::ARMSubArch_v6m; 547 case ARM::AK_ARMV7A: 548 case ARM::AK_ARMV7R: 549 return Triple::ARMSubArch_v7; 550 case ARM::AK_ARMV7K: 551 return Triple::ARMSubArch_v7k; 552 case ARM::AK_ARMV7M: 553 return Triple::ARMSubArch_v7m; 554 case ARM::AK_ARMV7S: 555 return Triple::ARMSubArch_v7s; 556 case ARM::AK_ARMV7EM: 557 return Triple::ARMSubArch_v7em; 558 case ARM::AK_ARMV8A: 559 return Triple::ARMSubArch_v8; 560 case ARM::AK_ARMV8_1A: 561 return Triple::ARMSubArch_v8_1a; 562 case ARM::AK_ARMV8_2A: 563 return Triple::ARMSubArch_v8_2a; 564 case ARM::AK_ARMV8R: 565 return Triple::ARMSubArch_v8r; 566 case ARM::AK_ARMV8MBaseline: 567 return Triple::ARMSubArch_v8m_baseline; 568 case ARM::AK_ARMV8MMainline: 569 return Triple::ARMSubArch_v8m_mainline; 570 default: 571 return Triple::NoSubArch; 572 } 573 } 574 575 static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) { 576 switch (Kind) { 577 case Triple::UnknownObjectFormat: return ""; 578 case Triple::COFF: return "coff"; 579 case Triple::ELF: return "elf"; 580 case Triple::MachO: return "macho"; 581 } 582 llvm_unreachable("unknown object format type"); 583 } 584 585 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) { 586 switch (T.getArch()) { 587 case Triple::UnknownArch: 588 case Triple::aarch64: 589 case Triple::arm: 590 case Triple::thumb: 591 case Triple::x86: 592 case Triple::x86_64: 593 if (T.isOSDarwin()) 594 return Triple::MachO; 595 else if (T.isOSWindows()) 596 return Triple::COFF; 597 return Triple::ELF; 598 599 case Triple::aarch64_be: 600 case Triple::amdgcn: 601 case Triple::amdil: 602 case Triple::amdil64: 603 case Triple::armeb: 604 case Triple::avr: 605 case Triple::bpfeb: 606 case Triple::bpfel: 607 case Triple::hexagon: 608 case Triple::lanai: 609 case Triple::hsail: 610 case Triple::hsail64: 611 case Triple::kalimba: 612 case Triple::le32: 613 case Triple::le64: 614 case Triple::mips: 615 case Triple::mips64: 616 case Triple::mips64el: 617 case Triple::mipsel: 618 case Triple::msp430: 619 case Triple::nvptx: 620 case Triple::nvptx64: 621 case Triple::ppc64le: 622 case Triple::r600: 623 case Triple::renderscript32: 624 case Triple::renderscript64: 625 case Triple::riscv32: 626 case Triple::riscv64: 627 case Triple::shave: 628 case Triple::sparc: 629 case Triple::sparcel: 630 case Triple::sparcv9: 631 case Triple::spir: 632 case Triple::spir64: 633 case Triple::systemz: 634 case Triple::tce: 635 case Triple::thumbeb: 636 case Triple::wasm32: 637 case Triple::wasm64: 638 case Triple::xcore: 639 return Triple::ELF; 640 641 case Triple::ppc: 642 case Triple::ppc64: 643 if (T.isOSDarwin()) 644 return Triple::MachO; 645 return Triple::ELF; 646 } 647 llvm_unreachable("unknown architecture"); 648 } 649 650 /// \brief Construct a triple from the string representation provided. 651 /// 652 /// This stores the string representation and parses the various pieces into 653 /// enum members. 654 Triple::Triple(const Twine &Str) 655 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch), 656 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment), 657 ObjectFormat(UnknownObjectFormat) { 658 // Do minimal parsing by hand here. 659 SmallVector<StringRef, 4> Components; 660 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3); 661 if (Components.size() > 0) { 662 Arch = parseArch(Components[0]); 663 SubArch = parseSubArch(Components[0]); 664 if (Components.size() > 1) { 665 Vendor = parseVendor(Components[1]); 666 if (Components.size() > 2) { 667 OS = parseOS(Components[2]); 668 if (Components.size() > 3) { 669 Environment = parseEnvironment(Components[3]); 670 ObjectFormat = parseFormat(Components[3]); 671 } 672 } 673 } 674 } 675 if (ObjectFormat == UnknownObjectFormat) 676 ObjectFormat = getDefaultFormat(*this); 677 } 678 679 /// \brief Construct a triple from string representations of the architecture, 680 /// vendor, and OS. 681 /// 682 /// This joins each argument into a canonical string representation and parses 683 /// them into enum members. It leaves the environment unknown and omits it from 684 /// the string representation. 685 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr) 686 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()), 687 Arch(parseArch(ArchStr.str())), 688 SubArch(parseSubArch(ArchStr.str())), 689 Vendor(parseVendor(VendorStr.str())), 690 OS(parseOS(OSStr.str())), 691 Environment(), ObjectFormat(Triple::UnknownObjectFormat) { 692 ObjectFormat = getDefaultFormat(*this); 693 } 694 695 /// \brief Construct a triple from string representations of the architecture, 696 /// vendor, OS, and environment. 697 /// 698 /// This joins each argument into a canonical string representation and parses 699 /// them into enum members. 700 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, 701 const Twine &EnvironmentStr) 702 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') + 703 EnvironmentStr).str()), 704 Arch(parseArch(ArchStr.str())), 705 SubArch(parseSubArch(ArchStr.str())), 706 Vendor(parseVendor(VendorStr.str())), 707 OS(parseOS(OSStr.str())), 708 Environment(parseEnvironment(EnvironmentStr.str())), 709 ObjectFormat(parseFormat(EnvironmentStr.str())) { 710 if (ObjectFormat == Triple::UnknownObjectFormat) 711 ObjectFormat = getDefaultFormat(*this); 712 } 713 714 std::string Triple::normalize(StringRef Str) { 715 bool IsMinGW32 = false; 716 bool IsCygwin = false; 717 718 // Parse into components. 719 SmallVector<StringRef, 4> Components; 720 Str.split(Components, '-'); 721 722 // If the first component corresponds to a known architecture, preferentially 723 // use it for the architecture. If the second component corresponds to a 724 // known vendor, preferentially use it for the vendor, etc. This avoids silly 725 // component movement when a component parses as (eg) both a valid arch and a 726 // valid os. 727 ArchType Arch = UnknownArch; 728 if (Components.size() > 0) 729 Arch = parseArch(Components[0]); 730 VendorType Vendor = UnknownVendor; 731 if (Components.size() > 1) 732 Vendor = parseVendor(Components[1]); 733 OSType OS = UnknownOS; 734 if (Components.size() > 2) { 735 OS = parseOS(Components[2]); 736 IsCygwin = Components[2].startswith("cygwin"); 737 IsMinGW32 = Components[2].startswith("mingw"); 738 } 739 EnvironmentType Environment = UnknownEnvironment; 740 if (Components.size() > 3) 741 Environment = parseEnvironment(Components[3]); 742 ObjectFormatType ObjectFormat = UnknownObjectFormat; 743 if (Components.size() > 4) 744 ObjectFormat = parseFormat(Components[4]); 745 746 // Note which components are already in their final position. These will not 747 // be moved. 748 bool Found[4]; 749 Found[0] = Arch != UnknownArch; 750 Found[1] = Vendor != UnknownVendor; 751 Found[2] = OS != UnknownOS; 752 Found[3] = Environment != UnknownEnvironment; 753 754 // If they are not there already, permute the components into their canonical 755 // positions by seeing if they parse as a valid architecture, and if so moving 756 // the component to the architecture position etc. 757 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) { 758 if (Found[Pos]) 759 continue; // Already in the canonical position. 760 761 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) { 762 // Do not reparse any components that already matched. 763 if (Idx < array_lengthof(Found) && Found[Idx]) 764 continue; 765 766 // Does this component parse as valid for the target position? 767 bool Valid = false; 768 StringRef Comp = Components[Idx]; 769 switch (Pos) { 770 default: llvm_unreachable("unexpected component type!"); 771 case 0: 772 Arch = parseArch(Comp); 773 Valid = Arch != UnknownArch; 774 break; 775 case 1: 776 Vendor = parseVendor(Comp); 777 Valid = Vendor != UnknownVendor; 778 break; 779 case 2: 780 OS = parseOS(Comp); 781 IsCygwin = Comp.startswith("cygwin"); 782 IsMinGW32 = Comp.startswith("mingw"); 783 Valid = OS != UnknownOS || IsCygwin || IsMinGW32; 784 break; 785 case 3: 786 Environment = parseEnvironment(Comp); 787 Valid = Environment != UnknownEnvironment; 788 if (!Valid) { 789 ObjectFormat = parseFormat(Comp); 790 Valid = ObjectFormat != UnknownObjectFormat; 791 } 792 break; 793 } 794 if (!Valid) 795 continue; // Nope, try the next component. 796 797 // Move the component to the target position, pushing any non-fixed 798 // components that are in the way to the right. This tends to give 799 // good results in the common cases of a forgotten vendor component 800 // or a wrongly positioned environment. 801 if (Pos < Idx) { 802 // Insert left, pushing the existing components to the right. For 803 // example, a-b-i386 -> i386-a-b when moving i386 to the front. 804 StringRef CurrentComponent(""); // The empty component. 805 // Replace the component we are moving with an empty component. 806 std::swap(CurrentComponent, Components[Idx]); 807 // Insert the component being moved at Pos, displacing any existing 808 // components to the right. 809 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) { 810 // Skip over any fixed components. 811 while (i < array_lengthof(Found) && Found[i]) 812 ++i; 813 // Place the component at the new position, getting the component 814 // that was at this position - it will be moved right. 815 std::swap(CurrentComponent, Components[i]); 816 } 817 } else if (Pos > Idx) { 818 // Push right by inserting empty components until the component at Idx 819 // reaches the target position Pos. For example, pc-a -> -pc-a when 820 // moving pc to the second position. 821 do { 822 // Insert one empty component at Idx. 823 StringRef CurrentComponent(""); // The empty component. 824 for (unsigned i = Idx; i < Components.size();) { 825 // Place the component at the new position, getting the component 826 // that was at this position - it will be moved right. 827 std::swap(CurrentComponent, Components[i]); 828 // If it was placed on top of an empty component then we are done. 829 if (CurrentComponent.empty()) 830 break; 831 // Advance to the next component, skipping any fixed components. 832 while (++i < array_lengthof(Found) && Found[i]) 833 ; 834 } 835 // The last component was pushed off the end - append it. 836 if (!CurrentComponent.empty()) 837 Components.push_back(CurrentComponent); 838 839 // Advance Idx to the component's new position. 840 while (++Idx < array_lengthof(Found) && Found[Idx]) 841 ; 842 } while (Idx < Pos); // Add more until the final position is reached. 843 } 844 assert(Pos < Components.size() && Components[Pos] == Comp && 845 "Component moved wrong!"); 846 Found[Pos] = true; 847 break; 848 } 849 } 850 851 // Special case logic goes here. At this point Arch, Vendor and OS have the 852 // correct values for the computed components. 853 std::string NormalizedEnvironment; 854 if (Environment == Triple::Android && Components[3].startswith("androideabi")) { 855 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi")); 856 if (AndroidVersion.empty()) { 857 Components[3] = "android"; 858 } else { 859 NormalizedEnvironment = Twine("android", AndroidVersion).str(); 860 Components[3] = NormalizedEnvironment; 861 } 862 } 863 864 if (OS == Triple::Win32) { 865 Components.resize(4); 866 Components[2] = "windows"; 867 if (Environment == UnknownEnvironment) { 868 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF) 869 Components[3] = "msvc"; 870 else 871 Components[3] = getObjectFormatTypeName(ObjectFormat); 872 } 873 } else if (IsMinGW32) { 874 Components.resize(4); 875 Components[2] = "windows"; 876 Components[3] = "gnu"; 877 } else if (IsCygwin) { 878 Components.resize(4); 879 Components[2] = "windows"; 880 Components[3] = "cygnus"; 881 } 882 if (IsMinGW32 || IsCygwin || 883 (OS == Triple::Win32 && Environment != UnknownEnvironment)) { 884 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) { 885 Components.resize(5); 886 Components[4] = getObjectFormatTypeName(ObjectFormat); 887 } 888 } 889 890 // Stick the corrected components back together to form the normalized string. 891 std::string Normalized; 892 for (unsigned i = 0, e = Components.size(); i != e; ++i) { 893 if (i) Normalized += '-'; 894 Normalized += Components[i]; 895 } 896 return Normalized; 897 } 898 899 StringRef Triple::getArchName() const { 900 return StringRef(Data).split('-').first; // Isolate first component 901 } 902 903 StringRef Triple::getVendorName() const { 904 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 905 return Tmp.split('-').first; // Isolate second component 906 } 907 908 StringRef Triple::getOSName() const { 909 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 910 Tmp = Tmp.split('-').second; // Strip second component 911 return Tmp.split('-').first; // Isolate third component 912 } 913 914 StringRef Triple::getEnvironmentName() const { 915 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 916 Tmp = Tmp.split('-').second; // Strip second component 917 return Tmp.split('-').second; // Strip third component 918 } 919 920 StringRef Triple::getOSAndEnvironmentName() const { 921 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 922 return Tmp.split('-').second; // Strip second component 923 } 924 925 static unsigned EatNumber(StringRef &Str) { 926 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number"); 927 unsigned Result = 0; 928 929 do { 930 // Consume the leading digit. 931 Result = Result*10 + (Str[0] - '0'); 932 933 // Eat the digit. 934 Str = Str.substr(1); 935 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9'); 936 937 return Result; 938 } 939 940 static void parseVersionFromName(StringRef Name, unsigned &Major, 941 unsigned &Minor, unsigned &Micro) { 942 // Any unset version defaults to 0. 943 Major = Minor = Micro = 0; 944 945 // Parse up to three components. 946 unsigned *Components[3] = {&Major, &Minor, &Micro}; 947 for (unsigned i = 0; i != 3; ++i) { 948 if (Name.empty() || Name[0] < '0' || Name[0] > '9') 949 break; 950 951 // Consume the leading number. 952 *Components[i] = EatNumber(Name); 953 954 // Consume the separator, if present. 955 if (Name.startswith(".")) 956 Name = Name.substr(1); 957 } 958 } 959 960 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor, 961 unsigned &Micro) const { 962 StringRef EnvironmentName = getEnvironmentName(); 963 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment()); 964 if (EnvironmentName.startswith(EnvironmentTypeName)) 965 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size()); 966 967 parseVersionFromName(EnvironmentName, Major, Minor, Micro); 968 } 969 970 void Triple::getOSVersion(unsigned &Major, unsigned &Minor, 971 unsigned &Micro) const { 972 StringRef OSName = getOSName(); 973 // Assume that the OS portion of the triple starts with the canonical name. 974 StringRef OSTypeName = getOSTypeName(getOS()); 975 if (OSName.startswith(OSTypeName)) 976 OSName = OSName.substr(OSTypeName.size()); 977 978 parseVersionFromName(OSName, Major, Minor, Micro); 979 } 980 981 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor, 982 unsigned &Micro) const { 983 getOSVersion(Major, Minor, Micro); 984 985 switch (getOS()) { 986 default: llvm_unreachable("unexpected OS for Darwin triple"); 987 case Darwin: 988 // Default to darwin8, i.e., MacOSX 10.4. 989 if (Major == 0) 990 Major = 8; 991 // Darwin version numbers are skewed from OS X versions. 992 if (Major < 4) 993 return false; 994 Micro = 0; 995 Minor = Major - 4; 996 Major = 10; 997 break; 998 case MacOSX: 999 // Default to 10.4. 1000 if (Major == 0) { 1001 Major = 10; 1002 Minor = 4; 1003 } 1004 if (Major != 10) 1005 return false; 1006 break; 1007 case IOS: 1008 case TvOS: 1009 case WatchOS: 1010 // Ignore the version from the triple. This is only handled because the 1011 // the clang driver combines OS X and IOS support into a common Darwin 1012 // toolchain that wants to know the OS X version number even when targeting 1013 // IOS. 1014 Major = 10; 1015 Minor = 4; 1016 Micro = 0; 1017 break; 1018 } 1019 return true; 1020 } 1021 1022 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor, 1023 unsigned &Micro) const { 1024 switch (getOS()) { 1025 default: llvm_unreachable("unexpected OS for Darwin triple"); 1026 case Darwin: 1027 case MacOSX: 1028 // Ignore the version from the triple. This is only handled because the 1029 // the clang driver combines OS X and IOS support into a common Darwin 1030 // toolchain that wants to know the iOS version number even when targeting 1031 // OS X. 1032 Major = 5; 1033 Minor = 0; 1034 Micro = 0; 1035 break; 1036 case IOS: 1037 case TvOS: 1038 getOSVersion(Major, Minor, Micro); 1039 // Default to 5.0 (or 7.0 for arm64). 1040 if (Major == 0) 1041 Major = (getArch() == aarch64) ? 7 : 5; 1042 break; 1043 case WatchOS: 1044 llvm_unreachable("conflicting triple info"); 1045 } 1046 } 1047 1048 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor, 1049 unsigned &Micro) const { 1050 switch (getOS()) { 1051 default: llvm_unreachable("unexpected OS for Darwin triple"); 1052 case Darwin: 1053 case MacOSX: 1054 // Ignore the version from the triple. This is only handled because the 1055 // the clang driver combines OS X and IOS support into a common Darwin 1056 // toolchain that wants to know the iOS version number even when targeting 1057 // OS X. 1058 Major = 2; 1059 Minor = 0; 1060 Micro = 0; 1061 break; 1062 case WatchOS: 1063 getOSVersion(Major, Minor, Micro); 1064 if (Major == 0) 1065 Major = 2; 1066 break; 1067 case IOS: 1068 llvm_unreachable("conflicting triple info"); 1069 } 1070 } 1071 1072 void Triple::setTriple(const Twine &Str) { 1073 *this = Triple(Str); 1074 } 1075 1076 void Triple::setArch(ArchType Kind) { 1077 setArchName(getArchTypeName(Kind)); 1078 } 1079 1080 void Triple::setVendor(VendorType Kind) { 1081 setVendorName(getVendorTypeName(Kind)); 1082 } 1083 1084 void Triple::setOS(OSType Kind) { 1085 setOSName(getOSTypeName(Kind)); 1086 } 1087 1088 void Triple::setEnvironment(EnvironmentType Kind) { 1089 if (ObjectFormat == getDefaultFormat(*this)) 1090 return setEnvironmentName(getEnvironmentTypeName(Kind)); 1091 1092 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") + 1093 getObjectFormatTypeName(ObjectFormat)).str()); 1094 } 1095 1096 void Triple::setObjectFormat(ObjectFormatType Kind) { 1097 if (Environment == UnknownEnvironment) 1098 return setEnvironmentName(getObjectFormatTypeName(Kind)); 1099 1100 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") + 1101 getObjectFormatTypeName(Kind)).str()); 1102 } 1103 1104 void Triple::setArchName(StringRef Str) { 1105 // Work around a miscompilation bug for Twines in gcc 4.0.3. 1106 SmallString<64> Triple; 1107 Triple += Str; 1108 Triple += "-"; 1109 Triple += getVendorName(); 1110 Triple += "-"; 1111 Triple += getOSAndEnvironmentName(); 1112 setTriple(Triple); 1113 } 1114 1115 void Triple::setVendorName(StringRef Str) { 1116 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName()); 1117 } 1118 1119 void Triple::setOSName(StringRef Str) { 1120 if (hasEnvironment()) 1121 setTriple(getArchName() + "-" + getVendorName() + "-" + Str + 1122 "-" + getEnvironmentName()); 1123 else 1124 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1125 } 1126 1127 void Triple::setEnvironmentName(StringRef Str) { 1128 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + 1129 "-" + Str); 1130 } 1131 1132 void Triple::setOSAndEnvironmentName(StringRef Str) { 1133 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1134 } 1135 1136 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { 1137 switch (Arch) { 1138 case llvm::Triple::UnknownArch: 1139 return 0; 1140 1141 case llvm::Triple::avr: 1142 case llvm::Triple::msp430: 1143 return 16; 1144 1145 case llvm::Triple::arm: 1146 case llvm::Triple::armeb: 1147 case llvm::Triple::hexagon: 1148 case llvm::Triple::le32: 1149 case llvm::Triple::mips: 1150 case llvm::Triple::mipsel: 1151 case llvm::Triple::nvptx: 1152 case llvm::Triple::ppc: 1153 case llvm::Triple::r600: 1154 case llvm::Triple::riscv32: 1155 case llvm::Triple::sparc: 1156 case llvm::Triple::sparcel: 1157 case llvm::Triple::tce: 1158 case llvm::Triple::thumb: 1159 case llvm::Triple::thumbeb: 1160 case llvm::Triple::x86: 1161 case llvm::Triple::xcore: 1162 case llvm::Triple::amdil: 1163 case llvm::Triple::hsail: 1164 case llvm::Triple::spir: 1165 case llvm::Triple::kalimba: 1166 case llvm::Triple::lanai: 1167 case llvm::Triple::shave: 1168 case llvm::Triple::wasm32: 1169 case llvm::Triple::renderscript32: 1170 return 32; 1171 1172 case llvm::Triple::aarch64: 1173 case llvm::Triple::aarch64_be: 1174 case llvm::Triple::amdgcn: 1175 case llvm::Triple::bpfel: 1176 case llvm::Triple::bpfeb: 1177 case llvm::Triple::le64: 1178 case llvm::Triple::mips64: 1179 case llvm::Triple::mips64el: 1180 case llvm::Triple::nvptx64: 1181 case llvm::Triple::ppc64: 1182 case llvm::Triple::ppc64le: 1183 case llvm::Triple::riscv64: 1184 case llvm::Triple::sparcv9: 1185 case llvm::Triple::systemz: 1186 case llvm::Triple::x86_64: 1187 case llvm::Triple::amdil64: 1188 case llvm::Triple::hsail64: 1189 case llvm::Triple::spir64: 1190 case llvm::Triple::wasm64: 1191 case llvm::Triple::renderscript64: 1192 return 64; 1193 } 1194 llvm_unreachable("Invalid architecture value"); 1195 } 1196 1197 bool Triple::isArch64Bit() const { 1198 return getArchPointerBitWidth(getArch()) == 64; 1199 } 1200 1201 bool Triple::isArch32Bit() const { 1202 return getArchPointerBitWidth(getArch()) == 32; 1203 } 1204 1205 bool Triple::isArch16Bit() const { 1206 return getArchPointerBitWidth(getArch()) == 16; 1207 } 1208 1209 Triple Triple::get32BitArchVariant() const { 1210 Triple T(*this); 1211 switch (getArch()) { 1212 case Triple::UnknownArch: 1213 case Triple::amdgcn: 1214 case Triple::avr: 1215 case Triple::bpfel: 1216 case Triple::bpfeb: 1217 case Triple::msp430: 1218 case Triple::systemz: 1219 case Triple::ppc64le: 1220 T.setArch(UnknownArch); 1221 break; 1222 1223 case Triple::amdil: 1224 case Triple::hsail: 1225 case Triple::spir: 1226 case Triple::arm: 1227 case Triple::armeb: 1228 case Triple::hexagon: 1229 case Triple::kalimba: 1230 case Triple::le32: 1231 case Triple::mips: 1232 case Triple::mipsel: 1233 case Triple::nvptx: 1234 case Triple::ppc: 1235 case Triple::r600: 1236 case Triple::riscv32: 1237 case Triple::sparc: 1238 case Triple::sparcel: 1239 case Triple::tce: 1240 case Triple::thumb: 1241 case Triple::thumbeb: 1242 case Triple::x86: 1243 case Triple::xcore: 1244 case Triple::lanai: 1245 case Triple::shave: 1246 case Triple::wasm32: 1247 case Triple::renderscript32: 1248 // Already 32-bit. 1249 break; 1250 1251 case Triple::aarch64: T.setArch(Triple::arm); break; 1252 case Triple::aarch64_be: T.setArch(Triple::armeb); break; 1253 case Triple::le64: T.setArch(Triple::le32); break; 1254 case Triple::mips64: T.setArch(Triple::mips); break; 1255 case Triple::mips64el: T.setArch(Triple::mipsel); break; 1256 case Triple::nvptx64: T.setArch(Triple::nvptx); break; 1257 case Triple::ppc64: T.setArch(Triple::ppc); break; 1258 case Triple::sparcv9: T.setArch(Triple::sparc); break; 1259 case Triple::riscv64: T.setArch(Triple::riscv32); break; 1260 case Triple::x86_64: T.setArch(Triple::x86); break; 1261 case Triple::amdil64: T.setArch(Triple::amdil); break; 1262 case Triple::hsail64: T.setArch(Triple::hsail); break; 1263 case Triple::spir64: T.setArch(Triple::spir); break; 1264 case Triple::wasm64: T.setArch(Triple::wasm32); break; 1265 case Triple::renderscript64: T.setArch(Triple::renderscript32); break; 1266 } 1267 return T; 1268 } 1269 1270 Triple Triple::get64BitArchVariant() const { 1271 Triple T(*this); 1272 switch (getArch()) { 1273 case Triple::UnknownArch: 1274 case Triple::avr: 1275 case Triple::hexagon: 1276 case Triple::kalimba: 1277 case Triple::lanai: 1278 case Triple::msp430: 1279 case Triple::r600: 1280 case Triple::tce: 1281 case Triple::xcore: 1282 case Triple::sparcel: 1283 case Triple::shave: 1284 T.setArch(UnknownArch); 1285 break; 1286 1287 case Triple::aarch64: 1288 case Triple::aarch64_be: 1289 case Triple::bpfel: 1290 case Triple::bpfeb: 1291 case Triple::le64: 1292 case Triple::amdil64: 1293 case Triple::amdgcn: 1294 case Triple::hsail64: 1295 case Triple::spir64: 1296 case Triple::mips64: 1297 case Triple::mips64el: 1298 case Triple::nvptx64: 1299 case Triple::ppc64: 1300 case Triple::ppc64le: 1301 case Triple::riscv64: 1302 case Triple::sparcv9: 1303 case Triple::systemz: 1304 case Triple::x86_64: 1305 case Triple::wasm64: 1306 case Triple::renderscript64: 1307 // Already 64-bit. 1308 break; 1309 1310 case Triple::arm: T.setArch(Triple::aarch64); break; 1311 case Triple::armeb: T.setArch(Triple::aarch64_be); break; 1312 case Triple::le32: T.setArch(Triple::le64); break; 1313 case Triple::mips: T.setArch(Triple::mips64); break; 1314 case Triple::mipsel: T.setArch(Triple::mips64el); break; 1315 case Triple::nvptx: T.setArch(Triple::nvptx64); break; 1316 case Triple::ppc: T.setArch(Triple::ppc64); break; 1317 case Triple::sparc: T.setArch(Triple::sparcv9); break; 1318 case Triple::riscv32: T.setArch(Triple::riscv64); break; 1319 case Triple::x86: T.setArch(Triple::x86_64); break; 1320 case Triple::amdil: T.setArch(Triple::amdil64); break; 1321 case Triple::hsail: T.setArch(Triple::hsail64); break; 1322 case Triple::spir: T.setArch(Triple::spir64); break; 1323 case Triple::thumb: T.setArch(Triple::aarch64); break; 1324 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break; 1325 case Triple::wasm32: T.setArch(Triple::wasm64); break; 1326 case Triple::renderscript32: T.setArch(Triple::renderscript64); break; 1327 } 1328 return T; 1329 } 1330 1331 Triple Triple::getBigEndianArchVariant() const { 1332 Triple T(*this); 1333 // Already big endian. 1334 if (!isLittleEndian()) 1335 return T; 1336 switch (getArch()) { 1337 case Triple::UnknownArch: 1338 case Triple::amdgcn: 1339 case Triple::amdil64: 1340 case Triple::amdil: 1341 case Triple::avr: 1342 case Triple::hexagon: 1343 case Triple::hsail64: 1344 case Triple::hsail: 1345 case Triple::kalimba: 1346 case Triple::le32: 1347 case Triple::le64: 1348 case Triple::msp430: 1349 case Triple::nvptx64: 1350 case Triple::nvptx: 1351 case Triple::r600: 1352 case Triple::riscv32: 1353 case Triple::riscv64: 1354 case Triple::shave: 1355 case Triple::spir64: 1356 case Triple::spir: 1357 case Triple::wasm32: 1358 case Triple::wasm64: 1359 case Triple::x86: 1360 case Triple::x86_64: 1361 case Triple::xcore: 1362 case Triple::renderscript32: 1363 case Triple::renderscript64: 1364 1365 // ARM is intentionally unsupported here, changing the architecture would 1366 // drop any arch suffixes. 1367 case Triple::arm: 1368 case Triple::thumb: 1369 T.setArch(UnknownArch); 1370 break; 1371 1372 case Triple::aarch64: T.setArch(Triple::aarch64_be); break; 1373 case Triple::bpfel: T.setArch(Triple::bpfeb); break; 1374 case Triple::mips64el:T.setArch(Triple::mips64); break; 1375 case Triple::mipsel: T.setArch(Triple::mips); break; 1376 case Triple::ppc64le: T.setArch(Triple::ppc64); break; 1377 case Triple::sparcel: T.setArch(Triple::sparc); break; 1378 default: 1379 llvm_unreachable("getBigEndianArchVariant: unknown triple."); 1380 } 1381 return T; 1382 } 1383 1384 Triple Triple::getLittleEndianArchVariant() const { 1385 Triple T(*this); 1386 if (isLittleEndian()) 1387 return T; 1388 1389 switch (getArch()) { 1390 case Triple::UnknownArch: 1391 case Triple::lanai: 1392 case Triple::ppc: 1393 case Triple::sparcv9: 1394 case Triple::systemz: 1395 case Triple::tce: 1396 1397 // ARM is intentionally unsupported here, changing the architecture would 1398 // drop any arch suffixes. 1399 case Triple::armeb: 1400 case Triple::thumbeb: 1401 T.setArch(UnknownArch); 1402 break; 1403 1404 case Triple::aarch64_be: T.setArch(Triple::aarch64); break; 1405 case Triple::bpfeb: T.setArch(Triple::bpfel); break; 1406 case Triple::mips64: T.setArch(Triple::mips64el); break; 1407 case Triple::mips: T.setArch(Triple::mipsel); break; 1408 case Triple::ppc64: T.setArch(Triple::ppc64le); break; 1409 case Triple::sparc: T.setArch(Triple::sparcel); break; 1410 default: 1411 llvm_unreachable("getLittleEndianArchVariant: unknown triple."); 1412 } 1413 return T; 1414 } 1415 1416 bool Triple::isLittleEndian() const { 1417 switch (getArch()) { 1418 case Triple::aarch64: 1419 case Triple::amdgcn: 1420 case Triple::amdil64: 1421 case Triple::amdil: 1422 case Triple::arm: 1423 case Triple::avr: 1424 case Triple::bpfel: 1425 case Triple::hexagon: 1426 case Triple::hsail64: 1427 case Triple::hsail: 1428 case Triple::kalimba: 1429 case Triple::le32: 1430 case Triple::le64: 1431 case Triple::mips64el: 1432 case Triple::mipsel: 1433 case Triple::msp430: 1434 case Triple::nvptx64: 1435 case Triple::nvptx: 1436 case Triple::ppc64le: 1437 case Triple::r600: 1438 case Triple::riscv32: 1439 case Triple::riscv64: 1440 case Triple::shave: 1441 case Triple::sparcel: 1442 case Triple::spir64: 1443 case Triple::spir: 1444 case Triple::thumb: 1445 case Triple::wasm32: 1446 case Triple::wasm64: 1447 case Triple::x86: 1448 case Triple::x86_64: 1449 case Triple::xcore: 1450 case Triple::renderscript32: 1451 case Triple::renderscript64: 1452 return true; 1453 default: 1454 return false; 1455 } 1456 } 1457 1458 StringRef Triple::getARMCPUForArch(StringRef MArch) const { 1459 if (MArch.empty()) 1460 MArch = getArchName(); 1461 MArch = ARM::getCanonicalArchName(MArch); 1462 1463 // Some defaults are forced. 1464 switch (getOS()) { 1465 case llvm::Triple::FreeBSD: 1466 case llvm::Triple::NetBSD: 1467 if (!MArch.empty() && MArch == "v6") 1468 return "arm1176jzf-s"; 1469 break; 1470 case llvm::Triple::Win32: 1471 // FIXME: this is invalid for WindowsCE 1472 return "cortex-a9"; 1473 case llvm::Triple::MacOSX: 1474 case llvm::Triple::IOS: 1475 case llvm::Triple::WatchOS: 1476 case llvm::Triple::TvOS: 1477 if (MArch == "v7k") 1478 return "cortex-a7"; 1479 break; 1480 default: 1481 break; 1482 } 1483 1484 if (MArch.empty()) 1485 return StringRef(); 1486 1487 StringRef CPU = ARM::getDefaultCPU(MArch); 1488 if (!CPU.empty()) 1489 return CPU; 1490 1491 // If no specific architecture version is requested, return the minimum CPU 1492 // required by the OS and environment. 1493 switch (getOS()) { 1494 case llvm::Triple::NetBSD: 1495 switch (getEnvironment()) { 1496 case llvm::Triple::GNUEABIHF: 1497 case llvm::Triple::GNUEABI: 1498 case llvm::Triple::EABIHF: 1499 case llvm::Triple::EABI: 1500 return "arm926ej-s"; 1501 default: 1502 return "strongarm"; 1503 } 1504 case llvm::Triple::NaCl: 1505 return "cortex-a8"; 1506 default: 1507 switch (getEnvironment()) { 1508 case llvm::Triple::EABIHF: 1509 case llvm::Triple::GNUEABIHF: 1510 case llvm::Triple::MuslEABIHF: 1511 return "arm1176jzf-s"; 1512 default: 1513 return "arm7tdmi"; 1514 } 1515 } 1516 1517 llvm_unreachable("invalid arch name"); 1518 } 1519