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