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