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