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