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