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 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::ARMV8R: 675 return Triple::ARMSubArch_v8r; 676 case ARM::ArchKind::ARMV8MBaseline: 677 return Triple::ARMSubArch_v8m_baseline; 678 case ARM::ArchKind::ARMV8MMainline: 679 return Triple::ARMSubArch_v8m_mainline; 680 case ARM::ArchKind::ARMV8_1MMainline: 681 return Triple::ARMSubArch_v8_1m_mainline; 682 default: 683 return Triple::NoSubArch; 684 } 685 } 686 687 static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) { 688 switch (Kind) { 689 case Triple::UnknownObjectFormat: return ""; 690 case Triple::COFF: return "coff"; 691 case Triple::ELF: return "elf"; 692 case Triple::GOFF: return "goff"; 693 case Triple::MachO: return "macho"; 694 case Triple::Wasm: return "wasm"; 695 case Triple::XCOFF: return "xcoff"; 696 } 697 llvm_unreachable("unknown object format type"); 698 } 699 700 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) { 701 switch (T.getArch()) { 702 case Triple::UnknownArch: 703 case Triple::aarch64: 704 case Triple::aarch64_32: 705 case Triple::arm: 706 case Triple::thumb: 707 case Triple::x86: 708 case Triple::x86_64: 709 if (T.isOSDarwin()) 710 return Triple::MachO; 711 else if (T.isOSWindows()) 712 return Triple::COFF; 713 return Triple::ELF; 714 715 case Triple::aarch64_be: 716 case Triple::amdgcn: 717 case Triple::amdil64: 718 case Triple::amdil: 719 case Triple::arc: 720 case Triple::armeb: 721 case Triple::avr: 722 case Triple::bpfeb: 723 case Triple::bpfel: 724 case Triple::csky: 725 case Triple::hexagon: 726 case Triple::hsail64: 727 case Triple::hsail: 728 case Triple::kalimba: 729 case Triple::lanai: 730 case Triple::le32: 731 case Triple::le64: 732 case Triple::m68k: 733 case Triple::mips64: 734 case Triple::mips64el: 735 case Triple::mips: 736 case Triple::mipsel: 737 case Triple::msp430: 738 case Triple::nvptx64: 739 case Triple::nvptx: 740 case Triple::ppc64le: 741 case Triple::ppcle: 742 case Triple::r600: 743 case Triple::renderscript32: 744 case Triple::renderscript64: 745 case Triple::riscv32: 746 case Triple::riscv64: 747 case Triple::shave: 748 case Triple::sparc: 749 case Triple::sparcel: 750 case Triple::sparcv9: 751 case Triple::spir64: 752 case Triple::spir: 753 case Triple::tce: 754 case Triple::tcele: 755 case Triple::thumbeb: 756 case Triple::ve: 757 case Triple::xcore: 758 return Triple::ELF; 759 760 case Triple::ppc64: 761 case Triple::ppc: 762 if (T.isOSAIX()) 763 return Triple::XCOFF; 764 return Triple::ELF; 765 766 case Triple::systemz: 767 if (T.isOSzOS()) 768 return Triple::GOFF; 769 return Triple::ELF; 770 771 case Triple::wasm32: 772 case Triple::wasm64: 773 return Triple::Wasm; 774 775 case Triple::spirv32: 776 case Triple::spirv64: 777 // TODO: In future this will be Triple::SPIRV. 778 return Triple::UnknownObjectFormat; 779 } 780 llvm_unreachable("unknown architecture"); 781 } 782 783 /// Construct a triple from the string representation provided. 784 /// 785 /// This stores the string representation and parses the various pieces into 786 /// enum members. 787 Triple::Triple(const Twine &Str) 788 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch), 789 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment), 790 ObjectFormat(UnknownObjectFormat) { 791 // Do minimal parsing by hand here. 792 SmallVector<StringRef, 4> Components; 793 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3); 794 if (Components.size() > 0) { 795 Arch = parseArch(Components[0]); 796 SubArch = parseSubArch(Components[0]); 797 if (Components.size() > 1) { 798 Vendor = parseVendor(Components[1]); 799 if (Components.size() > 2) { 800 OS = parseOS(Components[2]); 801 if (Components.size() > 3) { 802 Environment = parseEnvironment(Components[3]); 803 ObjectFormat = parseFormat(Components[3]); 804 } 805 } 806 } else { 807 Environment = 808 StringSwitch<Triple::EnvironmentType>(Components[0]) 809 .StartsWith("mipsn32", Triple::GNUABIN32) 810 .StartsWith("mips64", Triple::GNUABI64) 811 .StartsWith("mipsisa64", Triple::GNUABI64) 812 .StartsWith("mipsisa32", Triple::GNU) 813 .Cases("mips", "mipsel", "mipsr6", "mipsr6el", Triple::GNU) 814 .Default(UnknownEnvironment); 815 } 816 } 817 if (ObjectFormat == UnknownObjectFormat) 818 ObjectFormat = getDefaultFormat(*this); 819 } 820 821 /// Construct a triple from string representations of the architecture, 822 /// vendor, and OS. 823 /// 824 /// This joins each argument into a canonical string representation and parses 825 /// them into enum members. It leaves the environment unknown and omits it from 826 /// the string representation. 827 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr) 828 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()), 829 Arch(parseArch(ArchStr.str())), 830 SubArch(parseSubArch(ArchStr.str())), 831 Vendor(parseVendor(VendorStr.str())), 832 OS(parseOS(OSStr.str())), 833 Environment(), ObjectFormat(Triple::UnknownObjectFormat) { 834 ObjectFormat = getDefaultFormat(*this); 835 } 836 837 /// Construct a triple from string representations of the architecture, 838 /// vendor, OS, and environment. 839 /// 840 /// This joins each argument into a canonical string representation and parses 841 /// them into enum members. 842 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, 843 const Twine &EnvironmentStr) 844 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') + 845 EnvironmentStr).str()), 846 Arch(parseArch(ArchStr.str())), 847 SubArch(parseSubArch(ArchStr.str())), 848 Vendor(parseVendor(VendorStr.str())), 849 OS(parseOS(OSStr.str())), 850 Environment(parseEnvironment(EnvironmentStr.str())), 851 ObjectFormat(parseFormat(EnvironmentStr.str())) { 852 if (ObjectFormat == Triple::UnknownObjectFormat) 853 ObjectFormat = getDefaultFormat(*this); 854 } 855 856 std::string Triple::normalize(StringRef Str) { 857 bool IsMinGW32 = false; 858 bool IsCygwin = false; 859 860 // Parse into components. 861 SmallVector<StringRef, 4> Components; 862 Str.split(Components, '-'); 863 864 // If the first component corresponds to a known architecture, preferentially 865 // use it for the architecture. If the second component corresponds to a 866 // known vendor, preferentially use it for the vendor, etc. This avoids silly 867 // component movement when a component parses as (eg) both a valid arch and a 868 // valid os. 869 ArchType Arch = UnknownArch; 870 if (Components.size() > 0) 871 Arch = parseArch(Components[0]); 872 VendorType Vendor = UnknownVendor; 873 if (Components.size() > 1) 874 Vendor = parseVendor(Components[1]); 875 OSType OS = UnknownOS; 876 if (Components.size() > 2) { 877 OS = parseOS(Components[2]); 878 IsCygwin = Components[2].startswith("cygwin"); 879 IsMinGW32 = Components[2].startswith("mingw"); 880 } 881 EnvironmentType Environment = UnknownEnvironment; 882 if (Components.size() > 3) 883 Environment = parseEnvironment(Components[3]); 884 ObjectFormatType ObjectFormat = UnknownObjectFormat; 885 if (Components.size() > 4) 886 ObjectFormat = parseFormat(Components[4]); 887 888 // Note which components are already in their final position. These will not 889 // be moved. 890 bool Found[4]; 891 Found[0] = Arch != UnknownArch; 892 Found[1] = Vendor != UnknownVendor; 893 Found[2] = OS != UnknownOS; 894 Found[3] = Environment != UnknownEnvironment; 895 896 // If they are not there already, permute the components into their canonical 897 // positions by seeing if they parse as a valid architecture, and if so moving 898 // the component to the architecture position etc. 899 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) { 900 if (Found[Pos]) 901 continue; // Already in the canonical position. 902 903 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) { 904 // Do not reparse any components that already matched. 905 if (Idx < array_lengthof(Found) && Found[Idx]) 906 continue; 907 908 // Does this component parse as valid for the target position? 909 bool Valid = false; 910 StringRef Comp = Components[Idx]; 911 switch (Pos) { 912 default: llvm_unreachable("unexpected component type!"); 913 case 0: 914 Arch = parseArch(Comp); 915 Valid = Arch != UnknownArch; 916 break; 917 case 1: 918 Vendor = parseVendor(Comp); 919 Valid = Vendor != UnknownVendor; 920 break; 921 case 2: 922 OS = parseOS(Comp); 923 IsCygwin = Comp.startswith("cygwin"); 924 IsMinGW32 = Comp.startswith("mingw"); 925 Valid = OS != UnknownOS || IsCygwin || IsMinGW32; 926 break; 927 case 3: 928 Environment = parseEnvironment(Comp); 929 Valid = Environment != UnknownEnvironment; 930 if (!Valid) { 931 ObjectFormat = parseFormat(Comp); 932 Valid = ObjectFormat != UnknownObjectFormat; 933 } 934 break; 935 } 936 if (!Valid) 937 continue; // Nope, try the next component. 938 939 // Move the component to the target position, pushing any non-fixed 940 // components that are in the way to the right. This tends to give 941 // good results in the common cases of a forgotten vendor component 942 // or a wrongly positioned environment. 943 if (Pos < Idx) { 944 // Insert left, pushing the existing components to the right. For 945 // example, a-b-i386 -> i386-a-b when moving i386 to the front. 946 StringRef CurrentComponent(""); // The empty component. 947 // Replace the component we are moving with an empty component. 948 std::swap(CurrentComponent, Components[Idx]); 949 // Insert the component being moved at Pos, displacing any existing 950 // components to the right. 951 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) { 952 // Skip over any fixed components. 953 while (i < array_lengthof(Found) && Found[i]) 954 ++i; 955 // Place the component at the new position, getting the component 956 // that was at this position - it will be moved right. 957 std::swap(CurrentComponent, Components[i]); 958 } 959 } else if (Pos > Idx) { 960 // Push right by inserting empty components until the component at Idx 961 // reaches the target position Pos. For example, pc-a -> -pc-a when 962 // moving pc to the second position. 963 do { 964 // Insert one empty component at Idx. 965 StringRef CurrentComponent(""); // The empty component. 966 for (unsigned i = Idx; i < Components.size();) { 967 // Place the component at the new position, getting the component 968 // that was at this position - it will be moved right. 969 std::swap(CurrentComponent, Components[i]); 970 // If it was placed on top of an empty component then we are done. 971 if (CurrentComponent.empty()) 972 break; 973 // Advance to the next component, skipping any fixed components. 974 while (++i < array_lengthof(Found) && Found[i]) 975 ; 976 } 977 // The last component was pushed off the end - append it. 978 if (!CurrentComponent.empty()) 979 Components.push_back(CurrentComponent); 980 981 // Advance Idx to the component's new position. 982 while (++Idx < array_lengthof(Found) && Found[Idx]) 983 ; 984 } while (Idx < Pos); // Add more until the final position is reached. 985 } 986 assert(Pos < Components.size() && Components[Pos] == Comp && 987 "Component moved wrong!"); 988 Found[Pos] = true; 989 break; 990 } 991 } 992 993 // Replace empty components with "unknown" value. 994 for (StringRef &C : Components) 995 if (C.empty()) 996 C = "unknown"; 997 998 // Special case logic goes here. At this point Arch, Vendor and OS have the 999 // correct values for the computed components. 1000 std::string NormalizedEnvironment; 1001 if (Environment == Triple::Android && Components[3].startswith("androideabi")) { 1002 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi")); 1003 if (AndroidVersion.empty()) { 1004 Components[3] = "android"; 1005 } else { 1006 NormalizedEnvironment = Twine("android", AndroidVersion).str(); 1007 Components[3] = NormalizedEnvironment; 1008 } 1009 } 1010 1011 // SUSE uses "gnueabi" to mean "gnueabihf" 1012 if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI) 1013 Components[3] = "gnueabihf"; 1014 1015 if (OS == Triple::Win32) { 1016 Components.resize(4); 1017 Components[2] = "windows"; 1018 if (Environment == UnknownEnvironment) { 1019 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF) 1020 Components[3] = "msvc"; 1021 else 1022 Components[3] = getObjectFormatTypeName(ObjectFormat); 1023 } 1024 } else if (IsMinGW32) { 1025 Components.resize(4); 1026 Components[2] = "windows"; 1027 Components[3] = "gnu"; 1028 } else if (IsCygwin) { 1029 Components.resize(4); 1030 Components[2] = "windows"; 1031 Components[3] = "cygnus"; 1032 } 1033 if (IsMinGW32 || IsCygwin || 1034 (OS == Triple::Win32 && Environment != UnknownEnvironment)) { 1035 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) { 1036 Components.resize(5); 1037 Components[4] = getObjectFormatTypeName(ObjectFormat); 1038 } 1039 } 1040 1041 // Stick the corrected components back together to form the normalized string. 1042 return join(Components, "-"); 1043 } 1044 1045 StringRef Triple::getArchName() const { 1046 return StringRef(Data).split('-').first; // Isolate first component 1047 } 1048 1049 StringRef Triple::getArchName(ArchType Kind, SubArchType SubArch) const { 1050 switch (Kind) { 1051 case Triple::mips: 1052 if (SubArch == MipsSubArch_r6) 1053 return "mipsisa32r6"; 1054 break; 1055 case Triple::mipsel: 1056 if (SubArch == MipsSubArch_r6) 1057 return "mipsisa32r6el"; 1058 break; 1059 case Triple::mips64: 1060 if (SubArch == MipsSubArch_r6) 1061 return "mipsisa64r6"; 1062 break; 1063 case Triple::mips64el: 1064 if (SubArch == MipsSubArch_r6) 1065 return "mipsisa64r6el"; 1066 break; 1067 default: 1068 break; 1069 } 1070 return getArchTypeName(Kind); 1071 } 1072 1073 StringRef Triple::getVendorName() const { 1074 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1075 return Tmp.split('-').first; // Isolate second component 1076 } 1077 1078 StringRef Triple::getOSName() const { 1079 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1080 Tmp = Tmp.split('-').second; // Strip second component 1081 return Tmp.split('-').first; // Isolate third component 1082 } 1083 1084 StringRef Triple::getEnvironmentName() const { 1085 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1086 Tmp = Tmp.split('-').second; // Strip second component 1087 return Tmp.split('-').second; // Strip third component 1088 } 1089 1090 StringRef Triple::getOSAndEnvironmentName() const { 1091 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1092 return Tmp.split('-').second; // Strip second component 1093 } 1094 1095 static VersionTuple parseVersionFromName(StringRef Name) { 1096 VersionTuple Version; 1097 Version.tryParse(Name); 1098 return Version.withoutBuild(); 1099 } 1100 1101 VersionTuple Triple::getEnvironmentVersion() const { 1102 StringRef EnvironmentName = getEnvironmentName(); 1103 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment()); 1104 if (EnvironmentName.startswith(EnvironmentTypeName)) 1105 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size()); 1106 1107 return parseVersionFromName(EnvironmentName); 1108 } 1109 1110 VersionTuple Triple::getOSVersion() const { 1111 StringRef OSName = getOSName(); 1112 // Assume that the OS portion of the triple starts with the canonical name. 1113 StringRef OSTypeName = getOSTypeName(getOS()); 1114 if (OSName.startswith(OSTypeName)) 1115 OSName = OSName.substr(OSTypeName.size()); 1116 else if (getOS() == MacOSX) 1117 OSName.consume_front("macos"); 1118 1119 return parseVersionFromName(OSName); 1120 } 1121 1122 bool Triple::getMacOSXVersion(VersionTuple &Version) const { 1123 Version = getOSVersion(); 1124 1125 switch (getOS()) { 1126 default: llvm_unreachable("unexpected OS for Darwin triple"); 1127 case Darwin: 1128 // Default to darwin8, i.e., MacOSX 10.4. 1129 if (Version.getMajor() == 0) 1130 Version = VersionTuple(8); 1131 // Darwin version numbers are skewed from OS X versions. 1132 if (Version.getMajor() < 4) { 1133 return false; 1134 } 1135 if (Version.getMajor() <= 19) { 1136 Version = VersionTuple(10, Version.getMajor() - 4); 1137 } else { 1138 // darwin20+ corresponds to macOS 11+. 1139 Version = VersionTuple(11 + Version.getMajor() - 20); 1140 } 1141 break; 1142 case MacOSX: 1143 // Default to 10.4. 1144 if (Version.getMajor() == 0) { 1145 Version = VersionTuple(10, 4); 1146 } else if (Version.getMajor() < 10) { 1147 return false; 1148 } 1149 break; 1150 case IOS: 1151 case TvOS: 1152 case WatchOS: 1153 // Ignore the version from the triple. This is only handled because the 1154 // the clang driver combines OS X and IOS support into a common Darwin 1155 // toolchain that wants to know the OS X version number even when targeting 1156 // IOS. 1157 Version = VersionTuple(10, 4); 1158 break; 1159 } 1160 return true; 1161 } 1162 1163 VersionTuple Triple::getiOSVersion() const { 1164 switch (getOS()) { 1165 default: llvm_unreachable("unexpected OS for Darwin triple"); 1166 case Darwin: 1167 case MacOSX: 1168 // Ignore the version from the triple. This is only handled because the 1169 // the clang driver combines OS X and IOS support into a common Darwin 1170 // toolchain that wants to know the iOS version number even when targeting 1171 // OS X. 1172 return VersionTuple(5); 1173 case IOS: 1174 case TvOS: { 1175 VersionTuple Version = getOSVersion(); 1176 // Default to 5.0 (or 7.0 for arm64). 1177 if (Version.getMajor() == 0) 1178 return (getArch() == aarch64) ? VersionTuple(7) : VersionTuple(5); 1179 return Version; 1180 } 1181 case WatchOS: 1182 llvm_unreachable("conflicting triple info"); 1183 } 1184 } 1185 1186 VersionTuple Triple::getWatchOSVersion() const { 1187 switch (getOS()) { 1188 default: llvm_unreachable("unexpected OS for Darwin triple"); 1189 case Darwin: 1190 case MacOSX: 1191 // Ignore the version from the triple. This is only handled because the 1192 // the clang driver combines OS X and IOS support into a common Darwin 1193 // toolchain that wants to know the iOS version number even when targeting 1194 // OS X. 1195 return VersionTuple(2); 1196 case WatchOS: { 1197 VersionTuple Version = getOSVersion(); 1198 if (Version.getMajor() == 0) 1199 return VersionTuple(2); 1200 return Version; 1201 } 1202 case IOS: 1203 llvm_unreachable("conflicting triple info"); 1204 } 1205 } 1206 1207 void Triple::setTriple(const Twine &Str) { 1208 *this = Triple(Str); 1209 } 1210 1211 void Triple::setArch(ArchType Kind, SubArchType SubArch) { 1212 setArchName(getArchName(Kind, SubArch)); 1213 } 1214 1215 void Triple::setVendor(VendorType Kind) { 1216 setVendorName(getVendorTypeName(Kind)); 1217 } 1218 1219 void Triple::setOS(OSType Kind) { 1220 setOSName(getOSTypeName(Kind)); 1221 } 1222 1223 void Triple::setEnvironment(EnvironmentType Kind) { 1224 if (ObjectFormat == getDefaultFormat(*this)) 1225 return setEnvironmentName(getEnvironmentTypeName(Kind)); 1226 1227 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") + 1228 getObjectFormatTypeName(ObjectFormat)).str()); 1229 } 1230 1231 void Triple::setObjectFormat(ObjectFormatType Kind) { 1232 if (Environment == UnknownEnvironment) 1233 return setEnvironmentName(getObjectFormatTypeName(Kind)); 1234 1235 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") + 1236 getObjectFormatTypeName(Kind)).str()); 1237 } 1238 1239 void Triple::setArchName(StringRef Str) { 1240 // Work around a miscompilation bug for Twines in gcc 4.0.3. 1241 SmallString<64> Triple; 1242 Triple += Str; 1243 Triple += "-"; 1244 Triple += getVendorName(); 1245 Triple += "-"; 1246 Triple += getOSAndEnvironmentName(); 1247 setTriple(Triple); 1248 } 1249 1250 void Triple::setVendorName(StringRef Str) { 1251 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName()); 1252 } 1253 1254 void Triple::setOSName(StringRef Str) { 1255 if (hasEnvironment()) 1256 setTriple(getArchName() + "-" + getVendorName() + "-" + Str + 1257 "-" + getEnvironmentName()); 1258 else 1259 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1260 } 1261 1262 void Triple::setEnvironmentName(StringRef Str) { 1263 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + 1264 "-" + Str); 1265 } 1266 1267 void Triple::setOSAndEnvironmentName(StringRef Str) { 1268 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1269 } 1270 1271 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { 1272 switch (Arch) { 1273 case llvm::Triple::UnknownArch: 1274 return 0; 1275 1276 case llvm::Triple::avr: 1277 case llvm::Triple::msp430: 1278 return 16; 1279 1280 case llvm::Triple::aarch64_32: 1281 case llvm::Triple::amdil: 1282 case llvm::Triple::arc: 1283 case llvm::Triple::arm: 1284 case llvm::Triple::armeb: 1285 case llvm::Triple::csky: 1286 case llvm::Triple::hexagon: 1287 case llvm::Triple::hsail: 1288 case llvm::Triple::kalimba: 1289 case llvm::Triple::lanai: 1290 case llvm::Triple::le32: 1291 case llvm::Triple::m68k: 1292 case llvm::Triple::mips: 1293 case llvm::Triple::mipsel: 1294 case llvm::Triple::nvptx: 1295 case llvm::Triple::ppc: 1296 case llvm::Triple::ppcle: 1297 case llvm::Triple::r600: 1298 case llvm::Triple::renderscript32: 1299 case llvm::Triple::riscv32: 1300 case llvm::Triple::shave: 1301 case llvm::Triple::sparc: 1302 case llvm::Triple::sparcel: 1303 case llvm::Triple::spir: 1304 case llvm::Triple::spirv32: 1305 case llvm::Triple::tce: 1306 case llvm::Triple::tcele: 1307 case llvm::Triple::thumb: 1308 case llvm::Triple::thumbeb: 1309 case llvm::Triple::wasm32: 1310 case llvm::Triple::x86: 1311 case llvm::Triple::xcore: 1312 return 32; 1313 1314 case llvm::Triple::aarch64: 1315 case llvm::Triple::aarch64_be: 1316 case llvm::Triple::amdgcn: 1317 case llvm::Triple::amdil64: 1318 case llvm::Triple::bpfeb: 1319 case llvm::Triple::bpfel: 1320 case llvm::Triple::hsail64: 1321 case llvm::Triple::le64: 1322 case llvm::Triple::mips64: 1323 case llvm::Triple::mips64el: 1324 case llvm::Triple::nvptx64: 1325 case llvm::Triple::ppc64: 1326 case llvm::Triple::ppc64le: 1327 case llvm::Triple::renderscript64: 1328 case llvm::Triple::riscv64: 1329 case llvm::Triple::sparcv9: 1330 case llvm::Triple::spir64: 1331 case llvm::Triple::spirv64: 1332 case llvm::Triple::systemz: 1333 case llvm::Triple::ve: 1334 case llvm::Triple::wasm64: 1335 case llvm::Triple::x86_64: 1336 return 64; 1337 } 1338 llvm_unreachable("Invalid architecture value"); 1339 } 1340 1341 bool Triple::isArch64Bit() const { 1342 return getArchPointerBitWidth(getArch()) == 64; 1343 } 1344 1345 bool Triple::isArch32Bit() const { 1346 return getArchPointerBitWidth(getArch()) == 32; 1347 } 1348 1349 bool Triple::isArch16Bit() const { 1350 return getArchPointerBitWidth(getArch()) == 16; 1351 } 1352 1353 Triple Triple::get32BitArchVariant() const { 1354 Triple T(*this); 1355 switch (getArch()) { 1356 case Triple::UnknownArch: 1357 case Triple::amdgcn: 1358 case Triple::avr: 1359 case Triple::bpfeb: 1360 case Triple::bpfel: 1361 case Triple::msp430: 1362 case Triple::systemz: 1363 case Triple::ve: 1364 T.setArch(UnknownArch); 1365 break; 1366 1367 case Triple::aarch64_32: 1368 case Triple::amdil: 1369 case Triple::arc: 1370 case Triple::arm: 1371 case Triple::armeb: 1372 case Triple::csky: 1373 case Triple::hexagon: 1374 case Triple::hsail: 1375 case Triple::kalimba: 1376 case Triple::lanai: 1377 case Triple::le32: 1378 case Triple::m68k: 1379 case Triple::mips: 1380 case Triple::mipsel: 1381 case Triple::nvptx: 1382 case Triple::ppc: 1383 case Triple::ppcle: 1384 case Triple::r600: 1385 case Triple::renderscript32: 1386 case Triple::riscv32: 1387 case Triple::shave: 1388 case Triple::sparc: 1389 case Triple::sparcel: 1390 case Triple::spir: 1391 case Triple::spirv32: 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: 1408 T.setArch(Triple::mips, getSubArch()); 1409 break; 1410 case Triple::mips64el: 1411 T.setArch(Triple::mipsel, getSubArch()); 1412 break; 1413 case Triple::nvptx64: T.setArch(Triple::nvptx); break; 1414 case Triple::ppc64: T.setArch(Triple::ppc); break; 1415 case Triple::ppc64le: T.setArch(Triple::ppcle); break; 1416 case Triple::renderscript64: T.setArch(Triple::renderscript32); break; 1417 case Triple::riscv64: T.setArch(Triple::riscv32); break; 1418 case Triple::sparcv9: T.setArch(Triple::sparc); break; 1419 case Triple::spir64: T.setArch(Triple::spir); break; 1420 case Triple::spirv64: T.setArch(Triple::spirv32); break; 1421 case Triple::wasm64: T.setArch(Triple::wasm32); break; 1422 case Triple::x86_64: T.setArch(Triple::x86); break; 1423 } 1424 return T; 1425 } 1426 1427 Triple Triple::get64BitArchVariant() const { 1428 Triple T(*this); 1429 switch (getArch()) { 1430 case Triple::UnknownArch: 1431 case Triple::arc: 1432 case Triple::avr: 1433 case Triple::csky: 1434 case Triple::hexagon: 1435 case Triple::kalimba: 1436 case Triple::lanai: 1437 case Triple::m68k: 1438 case Triple::msp430: 1439 case Triple::r600: 1440 case Triple::shave: 1441 case Triple::sparcel: 1442 case Triple::tce: 1443 case Triple::tcele: 1444 case Triple::xcore: 1445 T.setArch(UnknownArch); 1446 break; 1447 1448 case Triple::aarch64: 1449 case Triple::aarch64_be: 1450 case Triple::amdgcn: 1451 case Triple::amdil64: 1452 case Triple::bpfeb: 1453 case Triple::bpfel: 1454 case Triple::hsail64: 1455 case Triple::le64: 1456 case Triple::mips64: 1457 case Triple::mips64el: 1458 case Triple::nvptx64: 1459 case Triple::ppc64: 1460 case Triple::ppc64le: 1461 case Triple::renderscript64: 1462 case Triple::riscv64: 1463 case Triple::sparcv9: 1464 case Triple::spir64: 1465 case Triple::spirv64: 1466 case Triple::systemz: 1467 case Triple::ve: 1468 case Triple::wasm64: 1469 case Triple::x86_64: 1470 // Already 64-bit. 1471 break; 1472 1473 case Triple::aarch64_32: T.setArch(Triple::aarch64); break; 1474 case Triple::amdil: T.setArch(Triple::amdil64); break; 1475 case Triple::arm: T.setArch(Triple::aarch64); break; 1476 case Triple::armeb: T.setArch(Triple::aarch64_be); break; 1477 case Triple::hsail: T.setArch(Triple::hsail64); break; 1478 case Triple::le32: T.setArch(Triple::le64); break; 1479 case Triple::mips: 1480 T.setArch(Triple::mips64, getSubArch()); 1481 break; 1482 case Triple::mipsel: 1483 T.setArch(Triple::mips64el, getSubArch()); 1484 break; 1485 case Triple::nvptx: T.setArch(Triple::nvptx64); break; 1486 case Triple::ppc: T.setArch(Triple::ppc64); break; 1487 case Triple::ppcle: T.setArch(Triple::ppc64le); break; 1488 case Triple::renderscript32: T.setArch(Triple::renderscript64); break; 1489 case Triple::riscv32: T.setArch(Triple::riscv64); break; 1490 case Triple::sparc: T.setArch(Triple::sparcv9); break; 1491 case Triple::spir: T.setArch(Triple::spir64); break; 1492 case Triple::spirv32: T.setArch(Triple::spirv64); break; 1493 case Triple::thumb: T.setArch(Triple::aarch64); break; 1494 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break; 1495 case Triple::wasm32: T.setArch(Triple::wasm64); break; 1496 case Triple::x86: T.setArch(Triple::x86_64); break; 1497 } 1498 return T; 1499 } 1500 1501 Triple Triple::getBigEndianArchVariant() const { 1502 Triple T(*this); 1503 // Already big endian. 1504 if (!isLittleEndian()) 1505 return T; 1506 switch (getArch()) { 1507 case Triple::UnknownArch: 1508 case Triple::amdgcn: 1509 case Triple::amdil64: 1510 case Triple::amdil: 1511 case Triple::avr: 1512 case Triple::hexagon: 1513 case Triple::hsail64: 1514 case Triple::hsail: 1515 case Triple::kalimba: 1516 case Triple::le32: 1517 case Triple::le64: 1518 case Triple::msp430: 1519 case Triple::nvptx64: 1520 case Triple::nvptx: 1521 case Triple::r600: 1522 case Triple::renderscript32: 1523 case Triple::renderscript64: 1524 case Triple::riscv32: 1525 case Triple::riscv64: 1526 case Triple::shave: 1527 case Triple::spir64: 1528 case Triple::spir: 1529 case Triple::spirv32: 1530 case Triple::spirv64: 1531 case Triple::wasm32: 1532 case Triple::wasm64: 1533 case Triple::x86: 1534 case Triple::x86_64: 1535 case Triple::xcore: 1536 case Triple::ve: 1537 case Triple::csky: 1538 1539 // ARM is intentionally unsupported here, changing the architecture would 1540 // drop any arch suffixes. 1541 case Triple::arm: 1542 case Triple::thumb: 1543 T.setArch(UnknownArch); 1544 break; 1545 1546 case Triple::aarch64: T.setArch(Triple::aarch64_be); break; 1547 case Triple::bpfel: T.setArch(Triple::bpfeb); break; 1548 case Triple::mips64el: 1549 T.setArch(Triple::mips64, getSubArch()); 1550 break; 1551 case Triple::mipsel: 1552 T.setArch(Triple::mips, getSubArch()); 1553 break; 1554 case Triple::ppcle: T.setArch(Triple::ppc); break; 1555 case Triple::ppc64le: T.setArch(Triple::ppc64); break; 1556 case Triple::sparcel: T.setArch(Triple::sparc); break; 1557 case Triple::tcele: T.setArch(Triple::tce); break; 1558 default: 1559 llvm_unreachable("getBigEndianArchVariant: unknown triple."); 1560 } 1561 return T; 1562 } 1563 1564 Triple Triple::getLittleEndianArchVariant() const { 1565 Triple T(*this); 1566 if (isLittleEndian()) 1567 return T; 1568 1569 switch (getArch()) { 1570 case Triple::UnknownArch: 1571 case Triple::lanai: 1572 case Triple::sparcv9: 1573 case Triple::systemz: 1574 case Triple::m68k: 1575 1576 // ARM is intentionally unsupported here, changing the architecture would 1577 // drop any arch suffixes. 1578 case Triple::armeb: 1579 case Triple::thumbeb: 1580 T.setArch(UnknownArch); 1581 break; 1582 1583 case Triple::aarch64_be: T.setArch(Triple::aarch64); break; 1584 case Triple::bpfeb: T.setArch(Triple::bpfel); break; 1585 case Triple::mips64: 1586 T.setArch(Triple::mips64el, getSubArch()); 1587 break; 1588 case Triple::mips: 1589 T.setArch(Triple::mipsel, getSubArch()); 1590 break; 1591 case Triple::ppc: T.setArch(Triple::ppcle); break; 1592 case Triple::ppc64: T.setArch(Triple::ppc64le); break; 1593 case Triple::sparc: T.setArch(Triple::sparcel); break; 1594 case Triple::tce: T.setArch(Triple::tcele); break; 1595 default: 1596 llvm_unreachable("getLittleEndianArchVariant: unknown triple."); 1597 } 1598 return T; 1599 } 1600 1601 bool Triple::isLittleEndian() const { 1602 switch (getArch()) { 1603 case Triple::aarch64: 1604 case Triple::aarch64_32: 1605 case Triple::amdgcn: 1606 case Triple::amdil64: 1607 case Triple::amdil: 1608 case Triple::arm: 1609 case Triple::avr: 1610 case Triple::bpfel: 1611 case Triple::csky: 1612 case Triple::hexagon: 1613 case Triple::hsail64: 1614 case Triple::hsail: 1615 case Triple::kalimba: 1616 case Triple::le32: 1617 case Triple::le64: 1618 case Triple::mips64el: 1619 case Triple::mipsel: 1620 case Triple::msp430: 1621 case Triple::nvptx64: 1622 case Triple::nvptx: 1623 case Triple::ppcle: 1624 case Triple::ppc64le: 1625 case Triple::r600: 1626 case Triple::renderscript32: 1627 case Triple::renderscript64: 1628 case Triple::riscv32: 1629 case Triple::riscv64: 1630 case Triple::shave: 1631 case Triple::sparcel: 1632 case Triple::spir64: 1633 case Triple::spir: 1634 case Triple::spirv32: 1635 case Triple::spirv64: 1636 case Triple::tcele: 1637 case Triple::thumb: 1638 case Triple::ve: 1639 case Triple::wasm32: 1640 case Triple::wasm64: 1641 case Triple::x86: 1642 case Triple::x86_64: 1643 case Triple::xcore: 1644 return true; 1645 default: 1646 return false; 1647 } 1648 } 1649 1650 bool Triple::isCompatibleWith(const Triple &Other) const { 1651 // ARM and Thumb triples are compatible, if subarch, vendor and OS match. 1652 if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) || 1653 (getArch() == Triple::arm && Other.getArch() == Triple::thumb) || 1654 (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) || 1655 (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) { 1656 if (getVendor() == Triple::Apple) 1657 return getSubArch() == Other.getSubArch() && 1658 getVendor() == Other.getVendor() && getOS() == Other.getOS(); 1659 else 1660 return getSubArch() == Other.getSubArch() && 1661 getVendor() == Other.getVendor() && getOS() == Other.getOS() && 1662 getEnvironment() == Other.getEnvironment() && 1663 getObjectFormat() == Other.getObjectFormat(); 1664 } 1665 1666 // If vendor is apple, ignore the version number. 1667 if (getVendor() == Triple::Apple) 1668 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() && 1669 getVendor() == Other.getVendor() && getOS() == Other.getOS(); 1670 1671 return *this == Other; 1672 } 1673 1674 std::string Triple::merge(const Triple &Other) const { 1675 // If vendor is apple, pick the triple with the larger version number. 1676 if (getVendor() == Triple::Apple) 1677 if (Other.isOSVersionLT(*this)) 1678 return str(); 1679 1680 return Other.str(); 1681 } 1682 1683 bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor, 1684 unsigned Micro) const { 1685 assert(isMacOSX() && "Not an OS X triple!"); 1686 1687 // If this is OS X, expect a sane version number. 1688 if (getOS() == Triple::MacOSX) 1689 return isOSVersionLT(Major, Minor, Micro); 1690 1691 // Otherwise, compare to the "Darwin" number. 1692 if (Major == 10) { 1693 return isOSVersionLT(Minor + 4, Micro, 0); 1694 } else { 1695 assert(Major >= 11 && "Unexpected major version"); 1696 return isOSVersionLT(Major - 11 + 20, Minor, Micro); 1697 } 1698 } 1699 1700 VersionTuple Triple::getMinimumSupportedOSVersion() const { 1701 if (getVendor() != Triple::Apple || getArch() != Triple::aarch64) 1702 return VersionTuple(); 1703 switch (getOS()) { 1704 case Triple::MacOSX: 1705 // ARM64 slice is supported starting from macOS 11.0+. 1706 return VersionTuple(11, 0, 0); 1707 case Triple::IOS: 1708 // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11). 1709 // ARM64 simulators are supported for iOS 14+. 1710 if (isMacCatalystEnvironment() || isSimulatorEnvironment()) 1711 return VersionTuple(14, 0, 0); 1712 // ARM64e slice is supported starting from iOS 14. 1713 if (isArm64e()) 1714 return VersionTuple(14, 0, 0); 1715 break; 1716 case Triple::TvOS: 1717 // ARM64 simulators are supported for tvOS 14+. 1718 if (isSimulatorEnvironment()) 1719 return VersionTuple(14, 0, 0); 1720 break; 1721 case Triple::WatchOS: 1722 // ARM64 simulators are supported for watchOS 7+. 1723 if (isSimulatorEnvironment()) 1724 return VersionTuple(7, 0, 0); 1725 break; 1726 default: 1727 break; 1728 } 1729 return VersionTuple(); 1730 } 1731 1732 StringRef Triple::getARMCPUForArch(StringRef MArch) const { 1733 if (MArch.empty()) 1734 MArch = getArchName(); 1735 MArch = ARM::getCanonicalArchName(MArch); 1736 1737 // Some defaults are forced. 1738 switch (getOS()) { 1739 case llvm::Triple::FreeBSD: 1740 case llvm::Triple::NetBSD: 1741 case llvm::Triple::OpenBSD: 1742 if (!MArch.empty() && MArch == "v6") 1743 return "arm1176jzf-s"; 1744 if (!MArch.empty() && MArch == "v7") 1745 return "cortex-a8"; 1746 break; 1747 case llvm::Triple::Win32: 1748 // FIXME: this is invalid for WindowsCE 1749 if (ARM::parseArchVersion(MArch) <= 7) 1750 return "cortex-a9"; 1751 break; 1752 case llvm::Triple::IOS: 1753 case llvm::Triple::MacOSX: 1754 case llvm::Triple::TvOS: 1755 case llvm::Triple::WatchOS: 1756 if (MArch == "v7k") 1757 return "cortex-a7"; 1758 break; 1759 default: 1760 break; 1761 } 1762 1763 if (MArch.empty()) 1764 return StringRef(); 1765 1766 StringRef CPU = ARM::getDefaultCPU(MArch); 1767 if (!CPU.empty() && !CPU.equals("invalid")) 1768 return CPU; 1769 1770 // If no specific architecture version is requested, return the minimum CPU 1771 // required by the OS and environment. 1772 switch (getOS()) { 1773 case llvm::Triple::NetBSD: 1774 switch (getEnvironment()) { 1775 case llvm::Triple::EABI: 1776 case llvm::Triple::EABIHF: 1777 case llvm::Triple::GNUEABI: 1778 case llvm::Triple::GNUEABIHF: 1779 return "arm926ej-s"; 1780 default: 1781 return "strongarm"; 1782 } 1783 case llvm::Triple::NaCl: 1784 case llvm::Triple::OpenBSD: 1785 return "cortex-a8"; 1786 default: 1787 switch (getEnvironment()) { 1788 case llvm::Triple::EABIHF: 1789 case llvm::Triple::GNUEABIHF: 1790 case llvm::Triple::MuslEABIHF: 1791 return "arm1176jzf-s"; 1792 default: 1793 return "arm7tdmi"; 1794 } 1795 } 1796 1797 llvm_unreachable("invalid arch name"); 1798 } 1799 1800 VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind, 1801 const VersionTuple &Version) { 1802 switch (OSKind) { 1803 case MacOSX: 1804 // macOS 10.16 is canonicalized to macOS 11. 1805 if (Version == VersionTuple(10, 16)) 1806 return VersionTuple(11, 0); 1807 LLVM_FALLTHROUGH; 1808 default: 1809 return Version; 1810 } 1811 } 1812