PageRenderTime 25ms CodeModel.GetById 32ms RepoModel.GetById 0ms app.codeStats 1ms

/contrib/llvm-project/llvm/lib/Support/Triple.cpp

https://github.com/conclusiveeng/freebsd
C++ | 1666 lines | 1414 code | 141 blank | 111 comment | 229 complexity | c8c9e8afacbafd8bc745ecd5c202d582 MD5 | raw file
Possible License(s): CC0-1.0, Apache-2.0, AGPL-1.0, GPL-2.0, BSD-2-Clause, 0BSD, MPL-2.0-no-copyleft-exception, BSD-3-Clause, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

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

Large files files are truncated, but you can click here to view the full file