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 (unsigned i = 0, e = Components.size(); i < e; ++i) { 993 if (Components[i].empty()) 994 Components[i] = "unknown"; 995 } 996 997 // Special case logic goes here. At this point Arch, Vendor and OS have the 998 // correct values for the computed components. 999 std::string NormalizedEnvironment; 1000 if (Environment == Triple::Android && Components[3].startswith("androideabi")) { 1001 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi")); 1002 if (AndroidVersion.empty()) { 1003 Components[3] = "android"; 1004 } else { 1005 NormalizedEnvironment = Twine("android", AndroidVersion).str(); 1006 Components[3] = NormalizedEnvironment; 1007 } 1008 } 1009 1010 // SUSE uses "gnueabi" to mean "gnueabihf" 1011 if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI) 1012 Components[3] = "gnueabihf"; 1013 1014 if (OS == Triple::Win32) { 1015 Components.resize(4); 1016 Components[2] = "windows"; 1017 if (Environment == UnknownEnvironment) { 1018 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF) 1019 Components[3] = "msvc"; 1020 else 1021 Components[3] = getObjectFormatTypeName(ObjectFormat); 1022 } 1023 } else if (IsMinGW32) { 1024 Components.resize(4); 1025 Components[2] = "windows"; 1026 Components[3] = "gnu"; 1027 } else if (IsCygwin) { 1028 Components.resize(4); 1029 Components[2] = "windows"; 1030 Components[3] = "cygnus"; 1031 } 1032 if (IsMinGW32 || IsCygwin || 1033 (OS == Triple::Win32 && Environment != UnknownEnvironment)) { 1034 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) { 1035 Components.resize(5); 1036 Components[4] = getObjectFormatTypeName(ObjectFormat); 1037 } 1038 } 1039 1040 // Stick the corrected components back together to form the normalized string. 1041 return join(Components, "-"); 1042 } 1043 1044 StringRef Triple::getArchName() const { 1045 return StringRef(Data).split('-').first; // Isolate first component 1046 } 1047 1048 StringRef Triple::getArchName(ArchType Kind, SubArchType SubArch) const { 1049 switch (Kind) { 1050 case Triple::mips: 1051 if (SubArch == MipsSubArch_r6) 1052 return "mipsisa32r6"; 1053 break; 1054 case Triple::mipsel: 1055 if (SubArch == MipsSubArch_r6) 1056 return "mipsisa32r6el"; 1057 break; 1058 case Triple::mips64: 1059 if (SubArch == MipsSubArch_r6) 1060 return "mipsisa64r6"; 1061 break; 1062 case Triple::mips64el: 1063 if (SubArch == MipsSubArch_r6) 1064 return "mipsisa64r6el"; 1065 break; 1066 default: 1067 break; 1068 } 1069 return getArchTypeName(Kind); 1070 } 1071 1072 StringRef Triple::getVendorName() const { 1073 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1074 return Tmp.split('-').first; // Isolate second component 1075 } 1076 1077 StringRef Triple::getOSName() const { 1078 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1079 Tmp = Tmp.split('-').second; // Strip second component 1080 return Tmp.split('-').first; // Isolate third component 1081 } 1082 1083 StringRef Triple::getEnvironmentName() const { 1084 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1085 Tmp = Tmp.split('-').second; // Strip second component 1086 return Tmp.split('-').second; // Strip third component 1087 } 1088 1089 StringRef Triple::getOSAndEnvironmentName() const { 1090 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1091 return Tmp.split('-').second; // Strip second component 1092 } 1093 1094 static VersionTuple parseVersionFromName(StringRef Name) { 1095 VersionTuple Version; 1096 Version.tryParse(Name); 1097 return Version.withoutBuild(); 1098 } 1099 1100 VersionTuple Triple::getEnvironmentVersion() const { 1101 StringRef EnvironmentName = getEnvironmentName(); 1102 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment()); 1103 if (EnvironmentName.startswith(EnvironmentTypeName)) 1104 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size()); 1105 1106 return parseVersionFromName(EnvironmentName); 1107 } 1108 1109 VersionTuple Triple::getOSVersion() const { 1110 StringRef OSName = getOSName(); 1111 // Assume that the OS portion of the triple starts with the canonical name. 1112 StringRef OSTypeName = getOSTypeName(getOS()); 1113 if (OSName.startswith(OSTypeName)) 1114 OSName = OSName.substr(OSTypeName.size()); 1115 else if (getOS() == MacOSX) 1116 OSName.consume_front("macos"); 1117 1118 return parseVersionFromName(OSName); 1119 } 1120 1121 bool Triple::getMacOSXVersion(VersionTuple &Version) const { 1122 Version = getOSVersion(); 1123 1124 switch (getOS()) { 1125 default: llvm_unreachable("unexpected OS for Darwin triple"); 1126 case Darwin: 1127 // Default to darwin8, i.e., MacOSX 10.4. 1128 if (Version.getMajor() == 0) 1129 Version = VersionTuple(8); 1130 // Darwin version numbers are skewed from OS X versions. 1131 if (Version.getMajor() < 4) { 1132 return false; 1133 } 1134 if (Version.getMajor() <= 19) { 1135 Version = VersionTuple(10, Version.getMajor() - 4); 1136 } else { 1137 // darwin20+ corresponds to macOS 11+. 1138 Version = VersionTuple(11 + Version.getMajor() - 20); 1139 } 1140 break; 1141 case MacOSX: 1142 // Default to 10.4. 1143 if (Version.getMajor() == 0) { 1144 Version = VersionTuple(10, 4); 1145 } else if (Version.getMajor() < 10) { 1146 return false; 1147 } 1148 break; 1149 case IOS: 1150 case TvOS: 1151 case WatchOS: 1152 // Ignore the version from the triple. This is only handled because the 1153 // the clang driver combines OS X and IOS support into a common Darwin 1154 // toolchain that wants to know the OS X version number even when targeting 1155 // IOS. 1156 Version = VersionTuple(10, 4); 1157 break; 1158 } 1159 return true; 1160 } 1161 1162 VersionTuple Triple::getiOSVersion() const { 1163 switch (getOS()) { 1164 default: llvm_unreachable("unexpected OS for Darwin triple"); 1165 case Darwin: 1166 case MacOSX: 1167 // Ignore the version from the triple. This is only handled because the 1168 // the clang driver combines OS X and IOS support into a common Darwin 1169 // toolchain that wants to know the iOS version number even when targeting 1170 // OS X. 1171 return VersionTuple(5); 1172 case IOS: 1173 case TvOS: { 1174 VersionTuple Version = getOSVersion(); 1175 // Default to 5.0 (or 7.0 for arm64). 1176 if (Version.getMajor() == 0) 1177 return (getArch() == aarch64) ? VersionTuple(7) : VersionTuple(5); 1178 return Version; 1179 } 1180 case WatchOS: 1181 llvm_unreachable("conflicting triple info"); 1182 } 1183 } 1184 1185 VersionTuple Triple::getWatchOSVersion() const { 1186 switch (getOS()) { 1187 default: llvm_unreachable("unexpected OS for Darwin triple"); 1188 case Darwin: 1189 case MacOSX: 1190 // Ignore the version from the triple. This is only handled because the 1191 // the clang driver combines OS X and IOS support into a common Darwin 1192 // toolchain that wants to know the iOS version number even when targeting 1193 // OS X. 1194 return VersionTuple(2); 1195 case WatchOS: { 1196 VersionTuple Version = getOSVersion(); 1197 if (Version.getMajor() == 0) 1198 return VersionTuple(2); 1199 return Version; 1200 } 1201 case IOS: 1202 llvm_unreachable("conflicting triple info"); 1203 } 1204 } 1205 1206 void Triple::setTriple(const Twine &Str) { 1207 *this = Triple(Str); 1208 } 1209 1210 void Triple::setArch(ArchType Kind, SubArchType SubArch) { 1211 setArchName(getArchName(Kind, SubArch)); 1212 } 1213 1214 void Triple::setVendor(VendorType Kind) { 1215 setVendorName(getVendorTypeName(Kind)); 1216 } 1217 1218 void Triple::setOS(OSType Kind) { 1219 setOSName(getOSTypeName(Kind)); 1220 } 1221 1222 void Triple::setEnvironment(EnvironmentType Kind) { 1223 if (ObjectFormat == getDefaultFormat(*this)) 1224 return setEnvironmentName(getEnvironmentTypeName(Kind)); 1225 1226 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") + 1227 getObjectFormatTypeName(ObjectFormat)).str()); 1228 } 1229 1230 void Triple::setObjectFormat(ObjectFormatType Kind) { 1231 if (Environment == UnknownEnvironment) 1232 return setEnvironmentName(getObjectFormatTypeName(Kind)); 1233 1234 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") + 1235 getObjectFormatTypeName(Kind)).str()); 1236 } 1237 1238 void Triple::setArchName(StringRef Str) { 1239 // Work around a miscompilation bug for Twines in gcc 4.0.3. 1240 SmallString<64> Triple; 1241 Triple += Str; 1242 Triple += "-"; 1243 Triple += getVendorName(); 1244 Triple += "-"; 1245 Triple += getOSAndEnvironmentName(); 1246 setTriple(Triple); 1247 } 1248 1249 void Triple::setVendorName(StringRef Str) { 1250 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName()); 1251 } 1252 1253 void Triple::setOSName(StringRef Str) { 1254 if (hasEnvironment()) 1255 setTriple(getArchName() + "-" + getVendorName() + "-" + Str + 1256 "-" + getEnvironmentName()); 1257 else 1258 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1259 } 1260 1261 void Triple::setEnvironmentName(StringRef Str) { 1262 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + 1263 "-" + Str); 1264 } 1265 1266 void Triple::setOSAndEnvironmentName(StringRef Str) { 1267 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1268 } 1269 1270 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { 1271 switch (Arch) { 1272 case llvm::Triple::UnknownArch: 1273 return 0; 1274 1275 case llvm::Triple::avr: 1276 case llvm::Triple::msp430: 1277 return 16; 1278 1279 case llvm::Triple::aarch64_32: 1280 case llvm::Triple::amdil: 1281 case llvm::Triple::arc: 1282 case llvm::Triple::arm: 1283 case llvm::Triple::armeb: 1284 case llvm::Triple::csky: 1285 case llvm::Triple::hexagon: 1286 case llvm::Triple::hsail: 1287 case llvm::Triple::kalimba: 1288 case llvm::Triple::lanai: 1289 case llvm::Triple::le32: 1290 case llvm::Triple::m68k: 1291 case llvm::Triple::mips: 1292 case llvm::Triple::mipsel: 1293 case llvm::Triple::nvptx: 1294 case llvm::Triple::ppc: 1295 case llvm::Triple::ppcle: 1296 case llvm::Triple::r600: 1297 case llvm::Triple::renderscript32: 1298 case llvm::Triple::riscv32: 1299 case llvm::Triple::shave: 1300 case llvm::Triple::sparc: 1301 case llvm::Triple::sparcel: 1302 case llvm::Triple::spir: 1303 case llvm::Triple::spirv32: 1304 case llvm::Triple::tce: 1305 case llvm::Triple::tcele: 1306 case llvm::Triple::thumb: 1307 case llvm::Triple::thumbeb: 1308 case llvm::Triple::wasm32: 1309 case llvm::Triple::x86: 1310 case llvm::Triple::xcore: 1311 return 32; 1312 1313 case llvm::Triple::aarch64: 1314 case llvm::Triple::aarch64_be: 1315 case llvm::Triple::amdgcn: 1316 case llvm::Triple::amdil64: 1317 case llvm::Triple::bpfeb: 1318 case llvm::Triple::bpfel: 1319 case llvm::Triple::hsail64: 1320 case llvm::Triple::le64: 1321 case llvm::Triple::mips64: 1322 case llvm::Triple::mips64el: 1323 case llvm::Triple::nvptx64: 1324 case llvm::Triple::ppc64: 1325 case llvm::Triple::ppc64le: 1326 case llvm::Triple::renderscript64: 1327 case llvm::Triple::riscv64: 1328 case llvm::Triple::sparcv9: 1329 case llvm::Triple::spir64: 1330 case llvm::Triple::spirv64: 1331 case llvm::Triple::systemz: 1332 case llvm::Triple::ve: 1333 case llvm::Triple::wasm64: 1334 case llvm::Triple::x86_64: 1335 return 64; 1336 } 1337 llvm_unreachable("Invalid architecture value"); 1338 } 1339 1340 bool Triple::isArch64Bit() const { 1341 return getArchPointerBitWidth(getArch()) == 64; 1342 } 1343 1344 bool Triple::isArch32Bit() const { 1345 return getArchPointerBitWidth(getArch()) == 32; 1346 } 1347 1348 bool Triple::isArch16Bit() const { 1349 return getArchPointerBitWidth(getArch()) == 16; 1350 } 1351 1352 Triple Triple::get32BitArchVariant() const { 1353 Triple T(*this); 1354 switch (getArch()) { 1355 case Triple::UnknownArch: 1356 case Triple::amdgcn: 1357 case Triple::avr: 1358 case Triple::bpfeb: 1359 case Triple::bpfel: 1360 case Triple::msp430: 1361 case Triple::systemz: 1362 case Triple::ve: 1363 T.setArch(UnknownArch); 1364 break; 1365 1366 case Triple::aarch64_32: 1367 case Triple::amdil: 1368 case Triple::arc: 1369 case Triple::arm: 1370 case Triple::armeb: 1371 case Triple::csky: 1372 case Triple::hexagon: 1373 case Triple::hsail: 1374 case Triple::kalimba: 1375 case Triple::lanai: 1376 case Triple::le32: 1377 case Triple::m68k: 1378 case Triple::mips: 1379 case Triple::mipsel: 1380 case Triple::nvptx: 1381 case Triple::ppc: 1382 case Triple::ppcle: 1383 case Triple::r600: 1384 case Triple::renderscript32: 1385 case Triple::riscv32: 1386 case Triple::shave: 1387 case Triple::sparc: 1388 case Triple::sparcel: 1389 case Triple::spir: 1390 case Triple::spirv32: 1391 case Triple::tce: 1392 case Triple::tcele: 1393 case Triple::thumb: 1394 case Triple::thumbeb: 1395 case Triple::wasm32: 1396 case Triple::x86: 1397 case Triple::xcore: 1398 // Already 32-bit. 1399 break; 1400 1401 case Triple::aarch64: T.setArch(Triple::arm); break; 1402 case Triple::aarch64_be: T.setArch(Triple::armeb); break; 1403 case Triple::amdil64: T.setArch(Triple::amdil); break; 1404 case Triple::hsail64: T.setArch(Triple::hsail); break; 1405 case Triple::le64: T.setArch(Triple::le32); break; 1406 case Triple::mips64: 1407 T.setArch(Triple::mips, getSubArch()); 1408 break; 1409 case Triple::mips64el: 1410 T.setArch(Triple::mipsel, getSubArch()); 1411 break; 1412 case Triple::nvptx64: T.setArch(Triple::nvptx); break; 1413 case Triple::ppc64: T.setArch(Triple::ppc); break; 1414 case Triple::ppc64le: T.setArch(Triple::ppcle); break; 1415 case Triple::renderscript64: T.setArch(Triple::renderscript32); break; 1416 case Triple::riscv64: T.setArch(Triple::riscv32); break; 1417 case Triple::sparcv9: T.setArch(Triple::sparc); break; 1418 case Triple::spir64: T.setArch(Triple::spir); break; 1419 case Triple::spirv64: T.setArch(Triple::spirv32); break; 1420 case Triple::wasm64: T.setArch(Triple::wasm32); break; 1421 case Triple::x86_64: T.setArch(Triple::x86); break; 1422 } 1423 return T; 1424 } 1425 1426 Triple Triple::get64BitArchVariant() const { 1427 Triple T(*this); 1428 switch (getArch()) { 1429 case Triple::UnknownArch: 1430 case Triple::arc: 1431 case Triple::avr: 1432 case Triple::csky: 1433 case Triple::hexagon: 1434 case Triple::kalimba: 1435 case Triple::lanai: 1436 case Triple::m68k: 1437 case Triple::msp430: 1438 case Triple::r600: 1439 case Triple::shave: 1440 case Triple::sparcel: 1441 case Triple::tce: 1442 case Triple::tcele: 1443 case Triple::xcore: 1444 T.setArch(UnknownArch); 1445 break; 1446 1447 case Triple::aarch64: 1448 case Triple::aarch64_be: 1449 case Triple::amdgcn: 1450 case Triple::amdil64: 1451 case Triple::bpfeb: 1452 case Triple::bpfel: 1453 case Triple::hsail64: 1454 case Triple::le64: 1455 case Triple::mips64: 1456 case Triple::mips64el: 1457 case Triple::nvptx64: 1458 case Triple::ppc64: 1459 case Triple::ppc64le: 1460 case Triple::renderscript64: 1461 case Triple::riscv64: 1462 case Triple::sparcv9: 1463 case Triple::spir64: 1464 case Triple::spirv64: 1465 case Triple::systemz: 1466 case Triple::ve: 1467 case Triple::wasm64: 1468 case Triple::x86_64: 1469 // Already 64-bit. 1470 break; 1471 1472 case Triple::aarch64_32: T.setArch(Triple::aarch64); break; 1473 case Triple::amdil: T.setArch(Triple::amdil64); break; 1474 case Triple::arm: T.setArch(Triple::aarch64); break; 1475 case Triple::armeb: T.setArch(Triple::aarch64_be); break; 1476 case Triple::hsail: T.setArch(Triple::hsail64); break; 1477 case Triple::le32: T.setArch(Triple::le64); break; 1478 case Triple::mips: 1479 T.setArch(Triple::mips64, getSubArch()); 1480 break; 1481 case Triple::mipsel: 1482 T.setArch(Triple::mips64el, getSubArch()); 1483 break; 1484 case Triple::nvptx: T.setArch(Triple::nvptx64); break; 1485 case Triple::ppc: T.setArch(Triple::ppc64); break; 1486 case Triple::ppcle: T.setArch(Triple::ppc64le); break; 1487 case Triple::renderscript32: T.setArch(Triple::renderscript64); break; 1488 case Triple::riscv32: T.setArch(Triple::riscv64); break; 1489 case Triple::sparc: T.setArch(Triple::sparcv9); break; 1490 case Triple::spir: T.setArch(Triple::spir64); break; 1491 case Triple::spirv32: T.setArch(Triple::spirv64); break; 1492 case Triple::thumb: T.setArch(Triple::aarch64); break; 1493 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break; 1494 case Triple::wasm32: T.setArch(Triple::wasm64); break; 1495 case Triple::x86: T.setArch(Triple::x86_64); break; 1496 } 1497 return T; 1498 } 1499 1500 Triple Triple::getBigEndianArchVariant() const { 1501 Triple T(*this); 1502 // Already big endian. 1503 if (!isLittleEndian()) 1504 return T; 1505 switch (getArch()) { 1506 case Triple::UnknownArch: 1507 case Triple::amdgcn: 1508 case Triple::amdil64: 1509 case Triple::amdil: 1510 case Triple::avr: 1511 case Triple::hexagon: 1512 case Triple::hsail64: 1513 case Triple::hsail: 1514 case Triple::kalimba: 1515 case Triple::le32: 1516 case Triple::le64: 1517 case Triple::msp430: 1518 case Triple::nvptx64: 1519 case Triple::nvptx: 1520 case Triple::r600: 1521 case Triple::renderscript32: 1522 case Triple::renderscript64: 1523 case Triple::riscv32: 1524 case Triple::riscv64: 1525 case Triple::shave: 1526 case Triple::spir64: 1527 case Triple::spir: 1528 case Triple::spirv32: 1529 case Triple::spirv64: 1530 case Triple::wasm32: 1531 case Triple::wasm64: 1532 case Triple::x86: 1533 case Triple::x86_64: 1534 case Triple::xcore: 1535 case Triple::ve: 1536 case Triple::csky: 1537 1538 // ARM is intentionally unsupported here, changing the architecture would 1539 // drop any arch suffixes. 1540 case Triple::arm: 1541 case Triple::thumb: 1542 T.setArch(UnknownArch); 1543 break; 1544 1545 case Triple::aarch64: T.setArch(Triple::aarch64_be); break; 1546 case Triple::bpfel: T.setArch(Triple::bpfeb); break; 1547 case Triple::mips64el: 1548 T.setArch(Triple::mips64, getSubArch()); 1549 break; 1550 case Triple::mipsel: 1551 T.setArch(Triple::mips, getSubArch()); 1552 break; 1553 case Triple::ppcle: T.setArch(Triple::ppc); break; 1554 case Triple::ppc64le: T.setArch(Triple::ppc64); break; 1555 case Triple::sparcel: T.setArch(Triple::sparc); break; 1556 case Triple::tcele: T.setArch(Triple::tce); break; 1557 default: 1558 llvm_unreachable("getBigEndianArchVariant: unknown triple."); 1559 } 1560 return T; 1561 } 1562 1563 Triple Triple::getLittleEndianArchVariant() const { 1564 Triple T(*this); 1565 if (isLittleEndian()) 1566 return T; 1567 1568 switch (getArch()) { 1569 case Triple::UnknownArch: 1570 case Triple::lanai: 1571 case Triple::sparcv9: 1572 case Triple::systemz: 1573 case Triple::m68k: 1574 1575 // ARM is intentionally unsupported here, changing the architecture would 1576 // drop any arch suffixes. 1577 case Triple::armeb: 1578 case Triple::thumbeb: 1579 T.setArch(UnknownArch); 1580 break; 1581 1582 case Triple::aarch64_be: T.setArch(Triple::aarch64); break; 1583 case Triple::bpfeb: T.setArch(Triple::bpfel); break; 1584 case Triple::mips64: 1585 T.setArch(Triple::mips64el, getSubArch()); 1586 break; 1587 case Triple::mips: 1588 T.setArch(Triple::mipsel, getSubArch()); 1589 break; 1590 case Triple::ppc: T.setArch(Triple::ppcle); break; 1591 case Triple::ppc64: T.setArch(Triple::ppc64le); break; 1592 case Triple::sparc: T.setArch(Triple::sparcel); break; 1593 case Triple::tce: T.setArch(Triple::tcele); break; 1594 default: 1595 llvm_unreachable("getLittleEndianArchVariant: unknown triple."); 1596 } 1597 return T; 1598 } 1599 1600 bool Triple::isLittleEndian() const { 1601 switch (getArch()) { 1602 case Triple::aarch64: 1603 case Triple::aarch64_32: 1604 case Triple::amdgcn: 1605 case Triple::amdil64: 1606 case Triple::amdil: 1607 case Triple::arm: 1608 case Triple::avr: 1609 case Triple::bpfel: 1610 case Triple::csky: 1611 case Triple::hexagon: 1612 case Triple::hsail64: 1613 case Triple::hsail: 1614 case Triple::kalimba: 1615 case Triple::le32: 1616 case Triple::le64: 1617 case Triple::mips64el: 1618 case Triple::mipsel: 1619 case Triple::msp430: 1620 case Triple::nvptx64: 1621 case Triple::nvptx: 1622 case Triple::ppcle: 1623 case Triple::ppc64le: 1624 case Triple::r600: 1625 case Triple::renderscript32: 1626 case Triple::renderscript64: 1627 case Triple::riscv32: 1628 case Triple::riscv64: 1629 case Triple::shave: 1630 case Triple::sparcel: 1631 case Triple::spir64: 1632 case Triple::spir: 1633 case Triple::spirv32: 1634 case Triple::spirv64: 1635 case Triple::tcele: 1636 case Triple::thumb: 1637 case Triple::ve: 1638 case Triple::wasm32: 1639 case Triple::wasm64: 1640 case Triple::x86: 1641 case Triple::x86_64: 1642 case Triple::xcore: 1643 return true; 1644 default: 1645 return false; 1646 } 1647 } 1648 1649 bool Triple::isCompatibleWith(const Triple &Other) const { 1650 // ARM and Thumb triples are compatible, if subarch, vendor and OS match. 1651 if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) || 1652 (getArch() == Triple::arm && Other.getArch() == Triple::thumb) || 1653 (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) || 1654 (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) { 1655 if (getVendor() == Triple::Apple) 1656 return getSubArch() == Other.getSubArch() && 1657 getVendor() == Other.getVendor() && getOS() == Other.getOS(); 1658 else 1659 return getSubArch() == Other.getSubArch() && 1660 getVendor() == Other.getVendor() && getOS() == Other.getOS() && 1661 getEnvironment() == Other.getEnvironment() && 1662 getObjectFormat() == Other.getObjectFormat(); 1663 } 1664 1665 // If vendor is apple, ignore the version number. 1666 if (getVendor() == Triple::Apple) 1667 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() && 1668 getVendor() == Other.getVendor() && getOS() == Other.getOS(); 1669 1670 return *this == Other; 1671 } 1672 1673 std::string Triple::merge(const Triple &Other) const { 1674 // If vendor is apple, pick the triple with the larger version number. 1675 if (getVendor() == Triple::Apple) 1676 if (Other.isOSVersionLT(*this)) 1677 return str(); 1678 1679 return Other.str(); 1680 } 1681 1682 bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor, 1683 unsigned Micro) const { 1684 assert(isMacOSX() && "Not an OS X triple!"); 1685 1686 // If this is OS X, expect a sane version number. 1687 if (getOS() == Triple::MacOSX) 1688 return isOSVersionLT(Major, Minor, Micro); 1689 1690 // Otherwise, compare to the "Darwin" number. 1691 if (Major == 10) { 1692 return isOSVersionLT(Minor + 4, Micro, 0); 1693 } else { 1694 assert(Major >= 11 && "Unexpected major version"); 1695 return isOSVersionLT(Major - 11 + 20, Minor, Micro); 1696 } 1697 } 1698 1699 VersionTuple Triple::getMinimumSupportedOSVersion() const { 1700 if (getVendor() != Triple::Apple || getArch() != Triple::aarch64) 1701 return VersionTuple(); 1702 switch (getOS()) { 1703 case Triple::MacOSX: 1704 // ARM64 slice is supported starting from macOS 11.0+. 1705 return VersionTuple(11, 0, 0); 1706 case Triple::IOS: 1707 // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11). 1708 // ARM64 simulators are supported for iOS 14+. 1709 if (isMacCatalystEnvironment() || isSimulatorEnvironment()) 1710 return VersionTuple(14, 0, 0); 1711 // ARM64e slice is supported starting from iOS 14. 1712 if (isArm64e()) 1713 return VersionTuple(14, 0, 0); 1714 break; 1715 case Triple::TvOS: 1716 // ARM64 simulators are supported for tvOS 14+. 1717 if (isSimulatorEnvironment()) 1718 return VersionTuple(14, 0, 0); 1719 break; 1720 case Triple::WatchOS: 1721 // ARM64 simulators are supported for watchOS 7+. 1722 if (isSimulatorEnvironment()) 1723 return VersionTuple(7, 0, 0); 1724 break; 1725 default: 1726 break; 1727 } 1728 return VersionTuple(); 1729 } 1730 1731 StringRef Triple::getARMCPUForArch(StringRef MArch) const { 1732 if (MArch.empty()) 1733 MArch = getArchName(); 1734 MArch = ARM::getCanonicalArchName(MArch); 1735 1736 // Some defaults are forced. 1737 switch (getOS()) { 1738 case llvm::Triple::FreeBSD: 1739 case llvm::Triple::NetBSD: 1740 case llvm::Triple::OpenBSD: 1741 if (!MArch.empty() && MArch == "v6") 1742 return "arm1176jzf-s"; 1743 if (!MArch.empty() && MArch == "v7") 1744 return "cortex-a8"; 1745 break; 1746 case llvm::Triple::Win32: 1747 // FIXME: this is invalid for WindowsCE 1748 if (ARM::parseArchVersion(MArch) <= 7) 1749 return "cortex-a9"; 1750 break; 1751 case llvm::Triple::IOS: 1752 case llvm::Triple::MacOSX: 1753 case llvm::Triple::TvOS: 1754 case llvm::Triple::WatchOS: 1755 if (MArch == "v7k") 1756 return "cortex-a7"; 1757 break; 1758 default: 1759 break; 1760 } 1761 1762 if (MArch.empty()) 1763 return StringRef(); 1764 1765 StringRef CPU = ARM::getDefaultCPU(MArch); 1766 if (!CPU.empty() && !CPU.equals("invalid")) 1767 return CPU; 1768 1769 // If no specific architecture version is requested, return the minimum CPU 1770 // required by the OS and environment. 1771 switch (getOS()) { 1772 case llvm::Triple::NetBSD: 1773 switch (getEnvironment()) { 1774 case llvm::Triple::EABI: 1775 case llvm::Triple::EABIHF: 1776 case llvm::Triple::GNUEABI: 1777 case llvm::Triple::GNUEABIHF: 1778 return "arm926ej-s"; 1779 default: 1780 return "strongarm"; 1781 } 1782 case llvm::Triple::NaCl: 1783 case llvm::Triple::OpenBSD: 1784 return "cortex-a8"; 1785 default: 1786 switch (getEnvironment()) { 1787 case llvm::Triple::EABIHF: 1788 case llvm::Triple::GNUEABIHF: 1789 case llvm::Triple::MuslEABIHF: 1790 return "arm1176jzf-s"; 1791 default: 1792 return "arm7tdmi"; 1793 } 1794 } 1795 1796 llvm_unreachable("invalid arch name"); 1797 } 1798 1799 VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind, 1800 const VersionTuple &Version) { 1801 switch (OSKind) { 1802 case MacOSX: 1803 // macOS 10.16 is canonicalized to macOS 11. 1804 if (Version == VersionTuple(10, 16)) 1805 return VersionTuple(11, 0); 1806 LLVM_FALLTHROUGH; 1807 default: 1808 return Version; 1809 } 1810 } 1811