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