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