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