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