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