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