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