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