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