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