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