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 case Triple::DXContainer: return "dxcontainer"; 747 } 748 llvm_unreachable("unknown object format type"); 749 } 750 751 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) { 752 switch (T.getArch()) { 753 case Triple::UnknownArch: 754 case Triple::aarch64: 755 case Triple::aarch64_32: 756 case Triple::arm: 757 case Triple::thumb: 758 case Triple::x86: 759 case Triple::x86_64: 760 if (T.isOSDarwin()) 761 return Triple::MachO; 762 else if (T.isOSWindows()) 763 return Triple::COFF; 764 return Triple::ELF; 765 766 case Triple::aarch64_be: 767 case Triple::amdgcn: 768 case Triple::amdil64: 769 case Triple::amdil: 770 case Triple::arc: 771 case Triple::armeb: 772 case Triple::avr: 773 case Triple::bpfeb: 774 case Triple::bpfel: 775 case Triple::csky: 776 case Triple::hexagon: 777 case Triple::hsail64: 778 case Triple::hsail: 779 case Triple::kalimba: 780 case Triple::lanai: 781 case Triple::le32: 782 case Triple::le64: 783 case Triple::loongarch32: 784 case Triple::loongarch64: 785 case Triple::m68k: 786 case Triple::mips64: 787 case Triple::mips64el: 788 case Triple::mips: 789 case Triple::mipsel: 790 case Triple::msp430: 791 case Triple::nvptx64: 792 case Triple::nvptx: 793 case Triple::ppc64le: 794 case Triple::ppcle: 795 case Triple::r600: 796 case Triple::renderscript32: 797 case Triple::renderscript64: 798 case Triple::riscv32: 799 case Triple::riscv64: 800 case Triple::shave: 801 case Triple::sparc: 802 case Triple::sparcel: 803 case Triple::sparcv9: 804 case Triple::spir64: 805 case Triple::spir: 806 case Triple::tce: 807 case Triple::tcele: 808 case Triple::thumbeb: 809 case Triple::ve: 810 case Triple::xcore: 811 return Triple::ELF; 812 813 case Triple::ppc64: 814 case Triple::ppc: 815 if (T.isOSAIX()) 816 return Triple::XCOFF; 817 return Triple::ELF; 818 819 case Triple::systemz: 820 if (T.isOSzOS()) 821 return Triple::GOFF; 822 return Triple::ELF; 823 824 case Triple::wasm32: 825 case Triple::wasm64: 826 return Triple::Wasm; 827 828 case Triple::spirv32: 829 case Triple::spirv64: 830 // TODO: In future this will be Triple::SPIRV. 831 return Triple::UnknownObjectFormat; 832 833 case Triple::dxil: 834 return Triple::DXContainer; 835 } 836 llvm_unreachable("unknown architecture"); 837 } 838 839 /// Construct a triple from the string representation provided. 840 /// 841 /// This stores the string representation and parses the various pieces into 842 /// enum members. 843 Triple::Triple(const Twine &Str) 844 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch), 845 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment), 846 ObjectFormat(UnknownObjectFormat) { 847 // Do minimal parsing by hand here. 848 SmallVector<StringRef, 4> Components; 849 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3); 850 if (Components.size() > 0) { 851 Arch = parseArch(Components[0]); 852 SubArch = parseSubArch(Components[0]); 853 if (Components.size() > 1) { 854 Vendor = parseVendor(Components[1]); 855 if (Components.size() > 2) { 856 OS = parseOS(Components[2]); 857 if (Components.size() > 3) { 858 Environment = parseEnvironment(Components[3]); 859 ObjectFormat = parseFormat(Components[3]); 860 } 861 } 862 } else { 863 Environment = 864 StringSwitch<Triple::EnvironmentType>(Components[0]) 865 .StartsWith("mipsn32", Triple::GNUABIN32) 866 .StartsWith("mips64", Triple::GNUABI64) 867 .StartsWith("mipsisa64", Triple::GNUABI64) 868 .StartsWith("mipsisa32", Triple::GNU) 869 .Cases("mips", "mipsel", "mipsr6", "mipsr6el", Triple::GNU) 870 .Default(UnknownEnvironment); 871 } 872 } 873 if (ObjectFormat == UnknownObjectFormat) 874 ObjectFormat = getDefaultFormat(*this); 875 } 876 877 /// Construct a triple from string representations of the architecture, 878 /// vendor, and OS. 879 /// 880 /// This joins each argument into a canonical string representation and parses 881 /// them into enum members. It leaves the environment unknown and omits it from 882 /// the string representation. 883 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr) 884 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()), 885 Arch(parseArch(ArchStr.str())), 886 SubArch(parseSubArch(ArchStr.str())), 887 Vendor(parseVendor(VendorStr.str())), 888 OS(parseOS(OSStr.str())), 889 Environment(), ObjectFormat(Triple::UnknownObjectFormat) { 890 ObjectFormat = getDefaultFormat(*this); 891 } 892 893 /// Construct a triple from string representations of the architecture, 894 /// vendor, OS, and environment. 895 /// 896 /// This joins each argument into a canonical string representation and parses 897 /// them into enum members. 898 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, 899 const Twine &EnvironmentStr) 900 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') + 901 EnvironmentStr).str()), 902 Arch(parseArch(ArchStr.str())), 903 SubArch(parseSubArch(ArchStr.str())), 904 Vendor(parseVendor(VendorStr.str())), 905 OS(parseOS(OSStr.str())), 906 Environment(parseEnvironment(EnvironmentStr.str())), 907 ObjectFormat(parseFormat(EnvironmentStr.str())) { 908 if (ObjectFormat == Triple::UnknownObjectFormat) 909 ObjectFormat = getDefaultFormat(*this); 910 } 911 912 std::string Triple::normalize(StringRef Str) { 913 bool IsMinGW32 = false; 914 bool IsCygwin = false; 915 916 // Parse into components. 917 SmallVector<StringRef, 4> Components; 918 Str.split(Components, '-'); 919 920 // If the first component corresponds to a known architecture, preferentially 921 // use it for the architecture. If the second component corresponds to a 922 // known vendor, preferentially use it for the vendor, etc. This avoids silly 923 // component movement when a component parses as (eg) both a valid arch and a 924 // valid os. 925 ArchType Arch = UnknownArch; 926 if (Components.size() > 0) 927 Arch = parseArch(Components[0]); 928 VendorType Vendor = UnknownVendor; 929 if (Components.size() > 1) 930 Vendor = parseVendor(Components[1]); 931 OSType OS = UnknownOS; 932 if (Components.size() > 2) { 933 OS = parseOS(Components[2]); 934 IsCygwin = Components[2].startswith("cygwin"); 935 IsMinGW32 = Components[2].startswith("mingw"); 936 } 937 EnvironmentType Environment = UnknownEnvironment; 938 if (Components.size() > 3) 939 Environment = parseEnvironment(Components[3]); 940 ObjectFormatType ObjectFormat = UnknownObjectFormat; 941 if (Components.size() > 4) 942 ObjectFormat = parseFormat(Components[4]); 943 944 // Note which components are already in their final position. These will not 945 // be moved. 946 bool Found[4]; 947 Found[0] = Arch != UnknownArch; 948 Found[1] = Vendor != UnknownVendor; 949 Found[2] = OS != UnknownOS; 950 Found[3] = Environment != UnknownEnvironment; 951 952 // If they are not there already, permute the components into their canonical 953 // positions by seeing if they parse as a valid architecture, and if so moving 954 // the component to the architecture position etc. 955 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) { 956 if (Found[Pos]) 957 continue; // Already in the canonical position. 958 959 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) { 960 // Do not reparse any components that already matched. 961 if (Idx < array_lengthof(Found) && Found[Idx]) 962 continue; 963 964 // Does this component parse as valid for the target position? 965 bool Valid = false; 966 StringRef Comp = Components[Idx]; 967 switch (Pos) { 968 default: llvm_unreachable("unexpected component type!"); 969 case 0: 970 Arch = parseArch(Comp); 971 Valid = Arch != UnknownArch; 972 break; 973 case 1: 974 Vendor = parseVendor(Comp); 975 Valid = Vendor != UnknownVendor; 976 break; 977 case 2: 978 OS = parseOS(Comp); 979 IsCygwin = Comp.startswith("cygwin"); 980 IsMinGW32 = Comp.startswith("mingw"); 981 Valid = OS != UnknownOS || IsCygwin || IsMinGW32; 982 break; 983 case 3: 984 Environment = parseEnvironment(Comp); 985 Valid = Environment != UnknownEnvironment; 986 if (!Valid) { 987 ObjectFormat = parseFormat(Comp); 988 Valid = ObjectFormat != UnknownObjectFormat; 989 } 990 break; 991 } 992 if (!Valid) 993 continue; // Nope, try the next component. 994 995 // Move the component to the target position, pushing any non-fixed 996 // components that are in the way to the right. This tends to give 997 // good results in the common cases of a forgotten vendor component 998 // or a wrongly positioned environment. 999 if (Pos < Idx) { 1000 // Insert left, pushing the existing components to the right. For 1001 // example, a-b-i386 -> i386-a-b when moving i386 to the front. 1002 StringRef CurrentComponent(""); // The empty component. 1003 // Replace the component we are moving with an empty component. 1004 std::swap(CurrentComponent, Components[Idx]); 1005 // Insert the component being moved at Pos, displacing any existing 1006 // components to the right. 1007 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) { 1008 // Skip over any fixed components. 1009 while (i < array_lengthof(Found) && Found[i]) 1010 ++i; 1011 // Place the component at the new position, getting the component 1012 // that was at this position - it will be moved right. 1013 std::swap(CurrentComponent, Components[i]); 1014 } 1015 } else if (Pos > Idx) { 1016 // Push right by inserting empty components until the component at Idx 1017 // reaches the target position Pos. For example, pc-a -> -pc-a when 1018 // moving pc to the second position. 1019 do { 1020 // Insert one empty component at Idx. 1021 StringRef CurrentComponent(""); // The empty component. 1022 for (unsigned i = Idx; i < Components.size();) { 1023 // Place the component at the new position, getting the component 1024 // that was at this position - it will be moved right. 1025 std::swap(CurrentComponent, Components[i]); 1026 // If it was placed on top of an empty component then we are done. 1027 if (CurrentComponent.empty()) 1028 break; 1029 // Advance to the next component, skipping any fixed components. 1030 while (++i < array_lengthof(Found) && Found[i]) 1031 ; 1032 } 1033 // The last component was pushed off the end - append it. 1034 if (!CurrentComponent.empty()) 1035 Components.push_back(CurrentComponent); 1036 1037 // Advance Idx to the component's new position. 1038 while (++Idx < array_lengthof(Found) && Found[Idx]) 1039 ; 1040 } while (Idx < Pos); // Add more until the final position is reached. 1041 } 1042 assert(Pos < Components.size() && Components[Pos] == Comp && 1043 "Component moved wrong!"); 1044 Found[Pos] = true; 1045 break; 1046 } 1047 } 1048 1049 // Replace empty components with "unknown" value. 1050 for (StringRef &C : Components) 1051 if (C.empty()) 1052 C = "unknown"; 1053 1054 // Special case logic goes here. At this point Arch, Vendor and OS have the 1055 // correct values for the computed components. 1056 std::string NormalizedEnvironment; 1057 if (Environment == Triple::Android && Components[3].startswith("androideabi")) { 1058 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi")); 1059 if (AndroidVersion.empty()) { 1060 Components[3] = "android"; 1061 } else { 1062 NormalizedEnvironment = Twine("android", AndroidVersion).str(); 1063 Components[3] = NormalizedEnvironment; 1064 } 1065 } 1066 1067 // SUSE uses "gnueabi" to mean "gnueabihf" 1068 if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI) 1069 Components[3] = "gnueabihf"; 1070 1071 if (OS == Triple::Win32) { 1072 Components.resize(4); 1073 Components[2] = "windows"; 1074 if (Environment == UnknownEnvironment) { 1075 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF) 1076 Components[3] = "msvc"; 1077 else 1078 Components[3] = getObjectFormatTypeName(ObjectFormat); 1079 } 1080 } else if (IsMinGW32) { 1081 Components.resize(4); 1082 Components[2] = "windows"; 1083 Components[3] = "gnu"; 1084 } else if (IsCygwin) { 1085 Components.resize(4); 1086 Components[2] = "windows"; 1087 Components[3] = "cygnus"; 1088 } 1089 if (IsMinGW32 || IsCygwin || 1090 (OS == Triple::Win32 && Environment != UnknownEnvironment)) { 1091 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) { 1092 Components.resize(5); 1093 Components[4] = getObjectFormatTypeName(ObjectFormat); 1094 } 1095 } 1096 1097 // Stick the corrected components back together to form the normalized string. 1098 return join(Components, "-"); 1099 } 1100 1101 StringRef Triple::getArchName() const { 1102 return StringRef(Data).split('-').first; // Isolate first component 1103 } 1104 1105 StringRef Triple::getArchName(ArchType Kind, SubArchType SubArch) const { 1106 switch (Kind) { 1107 case Triple::mips: 1108 if (SubArch == MipsSubArch_r6) 1109 return "mipsisa32r6"; 1110 break; 1111 case Triple::mipsel: 1112 if (SubArch == MipsSubArch_r6) 1113 return "mipsisa32r6el"; 1114 break; 1115 case Triple::mips64: 1116 if (SubArch == MipsSubArch_r6) 1117 return "mipsisa64r6"; 1118 break; 1119 case Triple::mips64el: 1120 if (SubArch == MipsSubArch_r6) 1121 return "mipsisa64r6el"; 1122 break; 1123 default: 1124 break; 1125 } 1126 return getArchTypeName(Kind); 1127 } 1128 1129 StringRef Triple::getVendorName() const { 1130 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1131 return Tmp.split('-').first; // Isolate second component 1132 } 1133 1134 StringRef Triple::getOSName() const { 1135 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1136 Tmp = Tmp.split('-').second; // Strip second component 1137 return Tmp.split('-').first; // Isolate third component 1138 } 1139 1140 StringRef Triple::getEnvironmentName() const { 1141 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1142 Tmp = Tmp.split('-').second; // Strip second component 1143 return Tmp.split('-').second; // Strip third component 1144 } 1145 1146 StringRef Triple::getOSAndEnvironmentName() const { 1147 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component 1148 return Tmp.split('-').second; // Strip second component 1149 } 1150 1151 static VersionTuple parseVersionFromName(StringRef Name) { 1152 VersionTuple Version; 1153 Version.tryParse(Name); 1154 return Version.withoutBuild(); 1155 } 1156 1157 VersionTuple Triple::getEnvironmentVersion() const { 1158 StringRef EnvironmentName = getEnvironmentName(); 1159 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment()); 1160 if (EnvironmentName.startswith(EnvironmentTypeName)) 1161 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size()); 1162 1163 return parseVersionFromName(EnvironmentName); 1164 } 1165 1166 VersionTuple Triple::getOSVersion() const { 1167 StringRef OSName = getOSName(); 1168 // Assume that the OS portion of the triple starts with the canonical name. 1169 StringRef OSTypeName = getOSTypeName(getOS()); 1170 if (OSName.startswith(OSTypeName)) 1171 OSName = OSName.substr(OSTypeName.size()); 1172 else if (getOS() == MacOSX) 1173 OSName.consume_front("macos"); 1174 1175 return parseVersionFromName(OSName); 1176 } 1177 1178 bool Triple::getMacOSXVersion(VersionTuple &Version) const { 1179 Version = getOSVersion(); 1180 1181 switch (getOS()) { 1182 default: llvm_unreachable("unexpected OS for Darwin triple"); 1183 case Darwin: 1184 // Default to darwin8, i.e., MacOSX 10.4. 1185 if (Version.getMajor() == 0) 1186 Version = VersionTuple(8); 1187 // Darwin version numbers are skewed from OS X versions. 1188 if (Version.getMajor() < 4) { 1189 return false; 1190 } 1191 if (Version.getMajor() <= 19) { 1192 Version = VersionTuple(10, Version.getMajor() - 4); 1193 } else { 1194 // darwin20+ corresponds to macOS 11+. 1195 Version = VersionTuple(11 + Version.getMajor() - 20); 1196 } 1197 break; 1198 case MacOSX: 1199 // Default to 10.4. 1200 if (Version.getMajor() == 0) { 1201 Version = VersionTuple(10, 4); 1202 } else if (Version.getMajor() < 10) { 1203 return false; 1204 } 1205 break; 1206 case IOS: 1207 case TvOS: 1208 case WatchOS: 1209 // Ignore the version from the triple. This is only handled because the 1210 // the clang driver combines OS X and IOS support into a common Darwin 1211 // toolchain that wants to know the OS X version number even when targeting 1212 // IOS. 1213 Version = VersionTuple(10, 4); 1214 break; 1215 case DriverKit: 1216 llvm_unreachable("OSX version isn't relevant for DriverKit"); 1217 } 1218 return true; 1219 } 1220 1221 VersionTuple Triple::getiOSVersion() const { 1222 switch (getOS()) { 1223 default: llvm_unreachable("unexpected OS for Darwin triple"); 1224 case Darwin: 1225 case MacOSX: 1226 // Ignore the version from the triple. This is only handled because the 1227 // the clang driver combines OS X and IOS support into a common Darwin 1228 // toolchain that wants to know the iOS version number even when targeting 1229 // OS X. 1230 return VersionTuple(5); 1231 case IOS: 1232 case TvOS: { 1233 VersionTuple Version = getOSVersion(); 1234 // Default to 5.0 (or 7.0 for arm64). 1235 if (Version.getMajor() == 0) 1236 return (getArch() == aarch64) ? VersionTuple(7) : VersionTuple(5); 1237 return Version; 1238 } 1239 case WatchOS: 1240 llvm_unreachable("conflicting triple info"); 1241 case DriverKit: 1242 llvm_unreachable("DriverKit doesn't have an iOS version"); 1243 } 1244 } 1245 1246 VersionTuple Triple::getWatchOSVersion() const { 1247 switch (getOS()) { 1248 default: llvm_unreachable("unexpected OS for Darwin triple"); 1249 case Darwin: 1250 case MacOSX: 1251 // Ignore the version from the triple. This is only handled because the 1252 // the clang driver combines OS X and IOS support into a common Darwin 1253 // toolchain that wants to know the iOS version number even when targeting 1254 // OS X. 1255 return VersionTuple(2); 1256 case WatchOS: { 1257 VersionTuple Version = getOSVersion(); 1258 if (Version.getMajor() == 0) 1259 return VersionTuple(2); 1260 return Version; 1261 } 1262 case IOS: 1263 llvm_unreachable("conflicting triple info"); 1264 case DriverKit: 1265 llvm_unreachable("DriverKit doesn't have a WatchOS version"); 1266 } 1267 } 1268 1269 VersionTuple Triple::getDriverKitVersion() const { 1270 switch (getOS()) { 1271 default: 1272 llvm_unreachable("unexpected OS for Darwin triple"); 1273 case DriverKit: 1274 VersionTuple Version = getOSVersion(); 1275 if (Version.getMajor() == 0) 1276 return Version.withMajorReplaced(19); 1277 return Version; 1278 } 1279 } 1280 1281 void Triple::setTriple(const Twine &Str) { 1282 *this = Triple(Str); 1283 } 1284 1285 void Triple::setArch(ArchType Kind, SubArchType SubArch) { 1286 setArchName(getArchName(Kind, SubArch)); 1287 } 1288 1289 void Triple::setVendor(VendorType Kind) { 1290 setVendorName(getVendorTypeName(Kind)); 1291 } 1292 1293 void Triple::setOS(OSType Kind) { 1294 setOSName(getOSTypeName(Kind)); 1295 } 1296 1297 void Triple::setEnvironment(EnvironmentType Kind) { 1298 if (ObjectFormat == getDefaultFormat(*this)) 1299 return setEnvironmentName(getEnvironmentTypeName(Kind)); 1300 1301 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") + 1302 getObjectFormatTypeName(ObjectFormat)).str()); 1303 } 1304 1305 void Triple::setObjectFormat(ObjectFormatType Kind) { 1306 if (Environment == UnknownEnvironment) 1307 return setEnvironmentName(getObjectFormatTypeName(Kind)); 1308 1309 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") + 1310 getObjectFormatTypeName(Kind)).str()); 1311 } 1312 1313 void Triple::setArchName(StringRef Str) { 1314 // Work around a miscompilation bug for Twines in gcc 4.0.3. 1315 SmallString<64> Triple; 1316 Triple += Str; 1317 Triple += "-"; 1318 Triple += getVendorName(); 1319 Triple += "-"; 1320 Triple += getOSAndEnvironmentName(); 1321 setTriple(Triple); 1322 } 1323 1324 void Triple::setVendorName(StringRef Str) { 1325 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName()); 1326 } 1327 1328 void Triple::setOSName(StringRef Str) { 1329 if (hasEnvironment()) 1330 setTriple(getArchName() + "-" + getVendorName() + "-" + Str + 1331 "-" + getEnvironmentName()); 1332 else 1333 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1334 } 1335 1336 void Triple::setEnvironmentName(StringRef Str) { 1337 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + 1338 "-" + Str); 1339 } 1340 1341 void Triple::setOSAndEnvironmentName(StringRef Str) { 1342 setTriple(getArchName() + "-" + getVendorName() + "-" + Str); 1343 } 1344 1345 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { 1346 switch (Arch) { 1347 case llvm::Triple::UnknownArch: 1348 return 0; 1349 1350 case llvm::Triple::avr: 1351 case llvm::Triple::msp430: 1352 return 16; 1353 1354 case llvm::Triple::aarch64_32: 1355 case llvm::Triple::amdil: 1356 case llvm::Triple::arc: 1357 case llvm::Triple::arm: 1358 case llvm::Triple::armeb: 1359 case llvm::Triple::csky: 1360 case llvm::Triple::dxil: 1361 case llvm::Triple::hexagon: 1362 case llvm::Triple::hsail: 1363 case llvm::Triple::kalimba: 1364 case llvm::Triple::lanai: 1365 case llvm::Triple::le32: 1366 case llvm::Triple::loongarch32: 1367 case llvm::Triple::m68k: 1368 case llvm::Triple::mips: 1369 case llvm::Triple::mipsel: 1370 case llvm::Triple::nvptx: 1371 case llvm::Triple::ppc: 1372 case llvm::Triple::ppcle: 1373 case llvm::Triple::r600: 1374 case llvm::Triple::renderscript32: 1375 case llvm::Triple::riscv32: 1376 case llvm::Triple::shave: 1377 case llvm::Triple::sparc: 1378 case llvm::Triple::sparcel: 1379 case llvm::Triple::spir: 1380 case llvm::Triple::spirv32: 1381 case llvm::Triple::tce: 1382 case llvm::Triple::tcele: 1383 case llvm::Triple::thumb: 1384 case llvm::Triple::thumbeb: 1385 case llvm::Triple::wasm32: 1386 case llvm::Triple::x86: 1387 case llvm::Triple::xcore: 1388 return 32; 1389 1390 case llvm::Triple::aarch64: 1391 case llvm::Triple::aarch64_be: 1392 case llvm::Triple::amdgcn: 1393 case llvm::Triple::amdil64: 1394 case llvm::Triple::bpfeb: 1395 case llvm::Triple::bpfel: 1396 case llvm::Triple::hsail64: 1397 case llvm::Triple::le64: 1398 case llvm::Triple::loongarch64: 1399 case llvm::Triple::mips64: 1400 case llvm::Triple::mips64el: 1401 case llvm::Triple::nvptx64: 1402 case llvm::Triple::ppc64: 1403 case llvm::Triple::ppc64le: 1404 case llvm::Triple::renderscript64: 1405 case llvm::Triple::riscv64: 1406 case llvm::Triple::sparcv9: 1407 case llvm::Triple::spir64: 1408 case llvm::Triple::spirv64: 1409 case llvm::Triple::systemz: 1410 case llvm::Triple::ve: 1411 case llvm::Triple::wasm64: 1412 case llvm::Triple::x86_64: 1413 return 64; 1414 } 1415 llvm_unreachable("Invalid architecture value"); 1416 } 1417 1418 bool Triple::isArch64Bit() const { 1419 return getArchPointerBitWidth(getArch()) == 64; 1420 } 1421 1422 bool Triple::isArch32Bit() const { 1423 return getArchPointerBitWidth(getArch()) == 32; 1424 } 1425 1426 bool Triple::isArch16Bit() const { 1427 return getArchPointerBitWidth(getArch()) == 16; 1428 } 1429 1430 Triple Triple::get32BitArchVariant() const { 1431 Triple T(*this); 1432 switch (getArch()) { 1433 case Triple::UnknownArch: 1434 case Triple::amdgcn: 1435 case Triple::avr: 1436 case Triple::bpfeb: 1437 case Triple::bpfel: 1438 case Triple::msp430: 1439 case Triple::systemz: 1440 case Triple::ve: 1441 T.setArch(UnknownArch); 1442 break; 1443 1444 case Triple::aarch64_32: 1445 case Triple::amdil: 1446 case Triple::arc: 1447 case Triple::arm: 1448 case Triple::armeb: 1449 case Triple::csky: 1450 case Triple::dxil: 1451 case Triple::hexagon: 1452 case Triple::hsail: 1453 case Triple::kalimba: 1454 case Triple::lanai: 1455 case Triple::le32: 1456 case Triple::loongarch32: 1457 case Triple::m68k: 1458 case Triple::mips: 1459 case Triple::mipsel: 1460 case Triple::nvptx: 1461 case Triple::ppc: 1462 case Triple::ppcle: 1463 case Triple::r600: 1464 case Triple::renderscript32: 1465 case Triple::riscv32: 1466 case Triple::shave: 1467 case Triple::sparc: 1468 case Triple::sparcel: 1469 case Triple::spir: 1470 case Triple::spirv32: 1471 case Triple::tce: 1472 case Triple::tcele: 1473 case Triple::thumb: 1474 case Triple::thumbeb: 1475 case Triple::wasm32: 1476 case Triple::x86: 1477 case Triple::xcore: 1478 // Already 32-bit. 1479 break; 1480 1481 case Triple::aarch64: T.setArch(Triple::arm); break; 1482 case Triple::aarch64_be: T.setArch(Triple::armeb); break; 1483 case Triple::amdil64: T.setArch(Triple::amdil); break; 1484 case Triple::hsail64: T.setArch(Triple::hsail); break; 1485 case Triple::le64: T.setArch(Triple::le32); break; 1486 case Triple::loongarch64: T.setArch(Triple::loongarch32); break; 1487 case Triple::mips64: 1488 T.setArch(Triple::mips, getSubArch()); 1489 break; 1490 case Triple::mips64el: 1491 T.setArch(Triple::mipsel, getSubArch()); 1492 break; 1493 case Triple::nvptx64: T.setArch(Triple::nvptx); break; 1494 case Triple::ppc64: T.setArch(Triple::ppc); break; 1495 case Triple::ppc64le: T.setArch(Triple::ppcle); break; 1496 case Triple::renderscript64: T.setArch(Triple::renderscript32); break; 1497 case Triple::riscv64: T.setArch(Triple::riscv32); break; 1498 case Triple::sparcv9: T.setArch(Triple::sparc); break; 1499 case Triple::spir64: T.setArch(Triple::spir); break; 1500 case Triple::spirv64: T.setArch(Triple::spirv32); break; 1501 case Triple::wasm64: T.setArch(Triple::wasm32); break; 1502 case Triple::x86_64: T.setArch(Triple::x86); break; 1503 } 1504 return T; 1505 } 1506 1507 Triple Triple::get64BitArchVariant() const { 1508 Triple T(*this); 1509 switch (getArch()) { 1510 case Triple::UnknownArch: 1511 case Triple::arc: 1512 case Triple::avr: 1513 case Triple::csky: 1514 case Triple::dxil: 1515 case Triple::hexagon: 1516 case Triple::kalimba: 1517 case Triple::lanai: 1518 case Triple::m68k: 1519 case Triple::msp430: 1520 case Triple::r600: 1521 case Triple::shave: 1522 case Triple::sparcel: 1523 case Triple::tce: 1524 case Triple::tcele: 1525 case Triple::xcore: 1526 T.setArch(UnknownArch); 1527 break; 1528 1529 case Triple::aarch64: 1530 case Triple::aarch64_be: 1531 case Triple::amdgcn: 1532 case Triple::amdil64: 1533 case Triple::bpfeb: 1534 case Triple::bpfel: 1535 case Triple::hsail64: 1536 case Triple::le64: 1537 case Triple::loongarch64: 1538 case Triple::mips64: 1539 case Triple::mips64el: 1540 case Triple::nvptx64: 1541 case Triple::ppc64: 1542 case Triple::ppc64le: 1543 case Triple::renderscript64: 1544 case Triple::riscv64: 1545 case Triple::sparcv9: 1546 case Triple::spir64: 1547 case Triple::spirv64: 1548 case Triple::systemz: 1549 case Triple::ve: 1550 case Triple::wasm64: 1551 case Triple::x86_64: 1552 // Already 64-bit. 1553 break; 1554 1555 case Triple::aarch64_32: T.setArch(Triple::aarch64); break; 1556 case Triple::amdil: T.setArch(Triple::amdil64); break; 1557 case Triple::arm: T.setArch(Triple::aarch64); break; 1558 case Triple::armeb: T.setArch(Triple::aarch64_be); break; 1559 case Triple::hsail: T.setArch(Triple::hsail64); break; 1560 case Triple::le32: T.setArch(Triple::le64); break; 1561 case Triple::loongarch32: T.setArch(Triple::loongarch64); break; 1562 case Triple::mips: 1563 T.setArch(Triple::mips64, getSubArch()); 1564 break; 1565 case Triple::mipsel: 1566 T.setArch(Triple::mips64el, getSubArch()); 1567 break; 1568 case Triple::nvptx: T.setArch(Triple::nvptx64); break; 1569 case Triple::ppc: T.setArch(Triple::ppc64); break; 1570 case Triple::ppcle: T.setArch(Triple::ppc64le); break; 1571 case Triple::renderscript32: T.setArch(Triple::renderscript64); break; 1572 case Triple::riscv32: T.setArch(Triple::riscv64); break; 1573 case Triple::sparc: T.setArch(Triple::sparcv9); break; 1574 case Triple::spir: T.setArch(Triple::spir64); break; 1575 case Triple::spirv32: T.setArch(Triple::spirv64); break; 1576 case Triple::thumb: T.setArch(Triple::aarch64); break; 1577 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break; 1578 case Triple::wasm32: T.setArch(Triple::wasm64); break; 1579 case Triple::x86: T.setArch(Triple::x86_64); break; 1580 } 1581 return T; 1582 } 1583 1584 Triple Triple::getBigEndianArchVariant() const { 1585 Triple T(*this); 1586 // Already big endian. 1587 if (!isLittleEndian()) 1588 return T; 1589 switch (getArch()) { 1590 case Triple::UnknownArch: 1591 case Triple::amdgcn: 1592 case Triple::amdil64: 1593 case Triple::amdil: 1594 case Triple::avr: 1595 case Triple::dxil: 1596 case Triple::hexagon: 1597 case Triple::hsail64: 1598 case Triple::hsail: 1599 case Triple::kalimba: 1600 case Triple::le32: 1601 case Triple::le64: 1602 case Triple::loongarch32: 1603 case Triple::loongarch64: 1604 case Triple::msp430: 1605 case Triple::nvptx64: 1606 case Triple::nvptx: 1607 case Triple::r600: 1608 case Triple::renderscript32: 1609 case Triple::renderscript64: 1610 case Triple::riscv32: 1611 case Triple::riscv64: 1612 case Triple::shave: 1613 case Triple::spir64: 1614 case Triple::spir: 1615 case Triple::spirv32: 1616 case Triple::spirv64: 1617 case Triple::wasm32: 1618 case Triple::wasm64: 1619 case Triple::x86: 1620 case Triple::x86_64: 1621 case Triple::xcore: 1622 case Triple::ve: 1623 case Triple::csky: 1624 1625 // ARM is intentionally unsupported here, changing the architecture would 1626 // drop any arch suffixes. 1627 case Triple::arm: 1628 case Triple::thumb: 1629 T.setArch(UnknownArch); 1630 break; 1631 1632 case Triple::aarch64: T.setArch(Triple::aarch64_be); break; 1633 case Triple::bpfel: T.setArch(Triple::bpfeb); break; 1634 case Triple::mips64el: 1635 T.setArch(Triple::mips64, getSubArch()); 1636 break; 1637 case Triple::mipsel: 1638 T.setArch(Triple::mips, getSubArch()); 1639 break; 1640 case Triple::ppcle: T.setArch(Triple::ppc); break; 1641 case Triple::ppc64le: T.setArch(Triple::ppc64); break; 1642 case Triple::sparcel: T.setArch(Triple::sparc); break; 1643 case Triple::tcele: T.setArch(Triple::tce); break; 1644 default: 1645 llvm_unreachable("getBigEndianArchVariant: unknown triple."); 1646 } 1647 return T; 1648 } 1649 1650 Triple Triple::getLittleEndianArchVariant() const { 1651 Triple T(*this); 1652 if (isLittleEndian()) 1653 return T; 1654 1655 switch (getArch()) { 1656 case Triple::UnknownArch: 1657 case Triple::lanai: 1658 case Triple::sparcv9: 1659 case Triple::systemz: 1660 case Triple::m68k: 1661 1662 // ARM is intentionally unsupported here, changing the architecture would 1663 // drop any arch suffixes. 1664 case Triple::armeb: 1665 case Triple::thumbeb: 1666 T.setArch(UnknownArch); 1667 break; 1668 1669 case Triple::aarch64_be: T.setArch(Triple::aarch64); break; 1670 case Triple::bpfeb: T.setArch(Triple::bpfel); break; 1671 case Triple::mips64: 1672 T.setArch(Triple::mips64el, getSubArch()); 1673 break; 1674 case Triple::mips: 1675 T.setArch(Triple::mipsel, getSubArch()); 1676 break; 1677 case Triple::ppc: T.setArch(Triple::ppcle); break; 1678 case Triple::ppc64: T.setArch(Triple::ppc64le); break; 1679 case Triple::sparc: T.setArch(Triple::sparcel); break; 1680 case Triple::tce: T.setArch(Triple::tcele); break; 1681 default: 1682 llvm_unreachable("getLittleEndianArchVariant: unknown triple."); 1683 } 1684 return T; 1685 } 1686 1687 bool Triple::isLittleEndian() const { 1688 switch (getArch()) { 1689 case Triple::aarch64: 1690 case Triple::aarch64_32: 1691 case Triple::amdgcn: 1692 case Triple::amdil64: 1693 case Triple::amdil: 1694 case Triple::arm: 1695 case Triple::avr: 1696 case Triple::bpfel: 1697 case Triple::csky: 1698 case Triple::dxil: 1699 case Triple::hexagon: 1700 case Triple::hsail64: 1701 case Triple::hsail: 1702 case Triple::kalimba: 1703 case Triple::le32: 1704 case Triple::le64: 1705 case Triple::loongarch32: 1706 case Triple::loongarch64: 1707 case Triple::mips64el: 1708 case Triple::mipsel: 1709 case Triple::msp430: 1710 case Triple::nvptx64: 1711 case Triple::nvptx: 1712 case Triple::ppcle: 1713 case Triple::ppc64le: 1714 case Triple::r600: 1715 case Triple::renderscript32: 1716 case Triple::renderscript64: 1717 case Triple::riscv32: 1718 case Triple::riscv64: 1719 case Triple::shave: 1720 case Triple::sparcel: 1721 case Triple::spir64: 1722 case Triple::spir: 1723 case Triple::spirv32: 1724 case Triple::spirv64: 1725 case Triple::tcele: 1726 case Triple::thumb: 1727 case Triple::ve: 1728 case Triple::wasm32: 1729 case Triple::wasm64: 1730 case Triple::x86: 1731 case Triple::x86_64: 1732 case Triple::xcore: 1733 return true; 1734 default: 1735 return false; 1736 } 1737 } 1738 1739 bool Triple::isCompatibleWith(const Triple &Other) const { 1740 // ARM and Thumb triples are compatible, if subarch, vendor and OS match. 1741 if ((getArch() == Triple::thumb && Other.getArch() == Triple::arm) || 1742 (getArch() == Triple::arm && Other.getArch() == Triple::thumb) || 1743 (getArch() == Triple::thumbeb && Other.getArch() == Triple::armeb) || 1744 (getArch() == Triple::armeb && Other.getArch() == Triple::thumbeb)) { 1745 if (getVendor() == Triple::Apple) 1746 return getSubArch() == Other.getSubArch() && 1747 getVendor() == Other.getVendor() && getOS() == Other.getOS(); 1748 else 1749 return getSubArch() == Other.getSubArch() && 1750 getVendor() == Other.getVendor() && getOS() == Other.getOS() && 1751 getEnvironment() == Other.getEnvironment() && 1752 getObjectFormat() == Other.getObjectFormat(); 1753 } 1754 1755 // If vendor is apple, ignore the version number. 1756 if (getVendor() == Triple::Apple) 1757 return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() && 1758 getVendor() == Other.getVendor() && getOS() == Other.getOS(); 1759 1760 return *this == Other; 1761 } 1762 1763 std::string Triple::merge(const Triple &Other) const { 1764 // If vendor is apple, pick the triple with the larger version number. 1765 if (getVendor() == Triple::Apple) 1766 if (Other.isOSVersionLT(*this)) 1767 return str(); 1768 1769 return Other.str(); 1770 } 1771 1772 bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor, 1773 unsigned Micro) const { 1774 assert(isMacOSX() && "Not an OS X triple!"); 1775 1776 // If this is OS X, expect a sane version number. 1777 if (getOS() == Triple::MacOSX) 1778 return isOSVersionLT(Major, Minor, Micro); 1779 1780 // Otherwise, compare to the "Darwin" number. 1781 if (Major == 10) { 1782 return isOSVersionLT(Minor + 4, Micro, 0); 1783 } else { 1784 assert(Major >= 11 && "Unexpected major version"); 1785 return isOSVersionLT(Major - 11 + 20, Minor, Micro); 1786 } 1787 } 1788 1789 VersionTuple Triple::getMinimumSupportedOSVersion() const { 1790 if (getVendor() != Triple::Apple || getArch() != Triple::aarch64) 1791 return VersionTuple(); 1792 switch (getOS()) { 1793 case Triple::MacOSX: 1794 // ARM64 slice is supported starting from macOS 11.0+. 1795 return VersionTuple(11, 0, 0); 1796 case Triple::IOS: 1797 // ARM64 slice is supported starting from Mac Catalyst 14 (macOS 11). 1798 // ARM64 simulators are supported for iOS 14+. 1799 if (isMacCatalystEnvironment() || isSimulatorEnvironment()) 1800 return VersionTuple(14, 0, 0); 1801 // ARM64e slice is supported starting from iOS 14. 1802 if (isArm64e()) 1803 return VersionTuple(14, 0, 0); 1804 break; 1805 case Triple::TvOS: 1806 // ARM64 simulators are supported for tvOS 14+. 1807 if (isSimulatorEnvironment()) 1808 return VersionTuple(14, 0, 0); 1809 break; 1810 case Triple::WatchOS: 1811 // ARM64 simulators are supported for watchOS 7+. 1812 if (isSimulatorEnvironment()) 1813 return VersionTuple(7, 0, 0); 1814 break; 1815 case Triple::DriverKit: 1816 return VersionTuple(20, 0, 0); 1817 default: 1818 break; 1819 } 1820 return VersionTuple(); 1821 } 1822 1823 StringRef Triple::getARMCPUForArch(StringRef MArch) const { 1824 if (MArch.empty()) 1825 MArch = getArchName(); 1826 MArch = ARM::getCanonicalArchName(MArch); 1827 1828 // Some defaults are forced. 1829 switch (getOS()) { 1830 case llvm::Triple::FreeBSD: 1831 case llvm::Triple::NetBSD: 1832 case llvm::Triple::OpenBSD: 1833 if (!MArch.empty() && MArch == "v6") 1834 return "arm1176jzf-s"; 1835 if (!MArch.empty() && MArch == "v7") 1836 return "cortex-a8"; 1837 break; 1838 case llvm::Triple::Win32: 1839 // FIXME: this is invalid for WindowsCE 1840 if (ARM::parseArchVersion(MArch) <= 7) 1841 return "cortex-a9"; 1842 break; 1843 case llvm::Triple::IOS: 1844 case llvm::Triple::MacOSX: 1845 case llvm::Triple::TvOS: 1846 case llvm::Triple::WatchOS: 1847 case llvm::Triple::DriverKit: 1848 if (MArch == "v7k") 1849 return "cortex-a7"; 1850 break; 1851 default: 1852 break; 1853 } 1854 1855 if (MArch.empty()) 1856 return StringRef(); 1857 1858 StringRef CPU = ARM::getDefaultCPU(MArch); 1859 if (!CPU.empty() && !CPU.equals("invalid")) 1860 return CPU; 1861 1862 // If no specific architecture version is requested, return the minimum CPU 1863 // required by the OS and environment. 1864 switch (getOS()) { 1865 case llvm::Triple::NetBSD: 1866 switch (getEnvironment()) { 1867 case llvm::Triple::EABI: 1868 case llvm::Triple::EABIHF: 1869 case llvm::Triple::GNUEABI: 1870 case llvm::Triple::GNUEABIHF: 1871 return "arm926ej-s"; 1872 default: 1873 return "strongarm"; 1874 } 1875 case llvm::Triple::NaCl: 1876 case llvm::Triple::OpenBSD: 1877 return "cortex-a8"; 1878 default: 1879 switch (getEnvironment()) { 1880 case llvm::Triple::EABIHF: 1881 case llvm::Triple::GNUEABIHF: 1882 case llvm::Triple::MuslEABIHF: 1883 return "arm1176jzf-s"; 1884 default: 1885 return "arm7tdmi"; 1886 } 1887 } 1888 1889 llvm_unreachable("invalid arch name"); 1890 } 1891 1892 VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind, 1893 const VersionTuple &Version) { 1894 switch (OSKind) { 1895 case MacOSX: 1896 // macOS 10.16 is canonicalized to macOS 11. 1897 if (Version == VersionTuple(10, 16)) 1898 return VersionTuple(11, 0); 1899 LLVM_FALLTHROUGH; 1900 default: 1901 return Version; 1902 } 1903 } 1904 1905 // HLSL triple environment orders are relied on in the front end 1906 static_assert(Triple::Vertex - Triple::Pixel == 1, 1907 "incorrect HLSL stage order"); 1908 static_assert(Triple::Geometry - Triple::Pixel == 2, 1909 "incorrect HLSL stage order"); 1910 static_assert(Triple::Hull - Triple::Pixel == 3, 1911 "incorrect HLSL stage order"); 1912 static_assert(Triple::Domain - Triple::Pixel == 4, 1913 "incorrect HLSL stage order"); 1914 static_assert(Triple::Compute - Triple::Pixel == 5, 1915 "incorrect HLSL stage order"); 1916 static_assert(Triple::Library - Triple::Pixel == 6, 1917 "incorrect HLSL stage order"); 1918 static_assert(Triple::RayGeneration - Triple::Pixel == 7, 1919 "incorrect HLSL stage order"); 1920 static_assert(Triple::Intersection - Triple::Pixel == 8, 1921 "incorrect HLSL stage order"); 1922 static_assert(Triple::AnyHit - Triple::Pixel == 9, 1923 "incorrect HLSL stage order"); 1924 static_assert(Triple::ClosestHit - Triple::Pixel == 10, 1925 "incorrect HLSL stage order"); 1926 static_assert(Triple::Miss - Triple::Pixel == 11, 1927 "incorrect HLSL stage order"); 1928 static_assert(Triple::Callable - Triple::Pixel == 12, 1929 "incorrect HLSL stage order"); 1930 static_assert(Triple::Mesh - Triple::Pixel == 13, 1931 "incorrect HLSL stage order"); 1932 static_assert(Triple::Amplification - Triple::Pixel == 14, 1933 "incorrect HLSL stage order"); 1934