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