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