blob: cb4ae95b881ea04fbac1550937047dfa21283ab8 [file] [log] [blame]
Daniel Dunbar4abd5662009-04-01 21:53:23 +00001//===--- 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"
Chandler Carruthed0881b2012-12-03 16:50:05 +000011#include "llvm/ADT/STLExtras.h"
Jeffrey Yasskine2595b52009-10-06 21:45:26 +000012#include "llvm/ADT/SmallString.h"
Chandler Carruthff6f3562012-02-12 09:27:38 +000013#include "llvm/ADT/StringSwitch.h"
David Blaikie46a9f012012-01-20 21:51:11 +000014#include "llvm/Support/ErrorHandling.h"
Renato Goline8048f02015-05-20 15:05:07 +000015#include "llvm/Support/TargetParser.h"
Alexei Starovoitov310dead2015-06-04 19:15:05 +000016#include "llvm/Support/Host.h"
Mikhail Glushenkov12062ba2009-04-02 01:11:37 +000017#include <cstring>
Daniel Dunbar4abd5662009-04-01 21:53:23 +000018using namespace llvm;
19
Mehdi Aminib7fb1242016-10-01 01:16:22 +000020StringRef Triple::getArchTypeName(ArchType Kind) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +000021 switch (Kind) {
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +000022 case UnknownArch: return "unknown";
Jim Grosbachf638b262010-12-17 02:10:59 +000023
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +000024 case aarch64: return "aarch64";
25 case aarch64_be: return "aarch64_be";
26 case arm: return "arm";
27 case armeb: return "armeb";
28 case avr: return "avr";
29 case bpfel: return "bpfel";
30 case bpfeb: return "bpfeb";
31 case hexagon: return "hexagon";
32 case mips: return "mips";
33 case mipsel: return "mipsel";
34 case mips64: return "mips64";
35 case mips64el: return "mips64el";
36 case msp430: return "msp430";
37 case ppc64: return "powerpc64";
38 case ppc64le: return "powerpc64le";
39 case ppc: return "powerpc";
40 case r600: return "r600";
41 case amdgcn: return "amdgcn";
Alex Bradburyb6e784a2016-11-01 16:47:54 +000042 case riscv32: return "riscv32";
43 case riscv64: return "riscv64";
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +000044 case sparc: return "sparc";
45 case sparcv9: return "sparcv9";
46 case sparcel: return "sparcel";
47 case systemz: return "s390x";
48 case tce: return "tce";
49 case thumb: return "thumb";
50 case thumbeb: return "thumbeb";
51 case x86: return "i386";
52 case x86_64: return "x86_64";
53 case xcore: return "xcore";
54 case nvptx: return "nvptx";
55 case nvptx64: return "nvptx64";
56 case le32: return "le32";
57 case le64: return "le64";
58 case amdil: return "amdil";
59 case amdil64: return "amdil64";
60 case hsail: return "hsail";
61 case hsail64: return "hsail64";
62 case spir: return "spir";
63 case spir64: return "spir64";
64 case kalimba: return "kalimba";
65 case lanai: return "lanai";
66 case shave: return "shave";
67 case wasm32: return "wasm32";
68 case wasm64: return "wasm64";
69 case renderscript32: return "renderscript32";
70 case renderscript64: return "renderscript64";
Daniel Dunbar4abd5662009-04-01 21:53:23 +000071 }
72
David Blaikie46a9f012012-01-20 21:51:11 +000073 llvm_unreachable("Invalid ArchType!");
Daniel Dunbar4abd5662009-04-01 21:53:23 +000074}
75
Mehdi Aminib7fb1242016-10-01 01:16:22 +000076StringRef Triple::getArchTypePrefix(ArchType Kind) {
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +000077 switch (Kind) {
78 default:
Mehdi Aminib7fb1242016-10-01 01:16:22 +000079 return StringRef();
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +000080
Christian Pirker6c2f4d42014-02-24 11:34:50 +000081 case aarch64:
82 case aarch64_be: return "aarch64";
Tim Northovere0e3aef2013-01-31 12:12:40 +000083
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +000084 case arm:
Christian Pirker2a111602014-03-28 14:35:30 +000085 case armeb:
86 case thumb:
87 case thumbeb: return "arm";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +000088
Dylan McKayb1d469c2015-10-16 03:10:30 +000089 case avr: return "avr";
90
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +000091 case ppc64:
Bill Schmidt0a9170d2013-07-26 01:35:43 +000092 case ppc64le:
Christian Pirker6c2f4d42014-02-24 11:34:50 +000093 case ppc: return "ppc";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +000094
Benjamin Kramerae3c3002012-06-28 19:09:53 +000095 case mips:
96 case mipsel:
97 case mips64:
Christian Pirker6c2f4d42014-02-24 11:34:50 +000098 case mips64el: return "mips";
Benjamin Kramerae3c3002012-06-28 19:09:53 +000099
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000100 case hexagon: return "hexagon";
Tony Linthicum1213a7a2011-12-12 21:14:40 +0000101
Matt Arsenault429f2802016-01-22 19:09:12 +0000102 case amdgcn: return "amdgcn";
103 case r600: return "r600";
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000104
Alexei Starovoitov8cf9a4c2015-06-05 16:11:14 +0000105 case bpfel:
106 case bpfeb: return "bpf";
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000107
Chris Lattner8228b112010-02-04 06:34:01 +0000108 case sparcv9:
Douglas Katzmane0ff2822015-04-29 19:15:08 +0000109 case sparcel:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000110 case sparc: return "sparc";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000111
Ulrich Weigand57c85f52015-04-01 12:51:43 +0000112 case systemz: return "s390";
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000113
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000114 case x86:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000115 case x86_64: return "x86";
Nick Lewycky4c82c6c2010-09-07 18:14:24 +0000116
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000117 case xcore: return "xcore";
Nick Lewycky4c82c6c2010-09-07 18:14:24 +0000118
Justin Bogner068a8052016-07-08 17:25:18 +0000119 // NVPTX intrinsics are namespaced under nvvm.
120 case nvptx: return "nvvm";
121 case nvptx64: return "nvvm";
Tim Northover00ed9962014-03-29 10:18:08 +0000122
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000123 case le32: return "le32";
JF Bastien32972ef2014-09-12 17:54:17 +0000124 case le64: return "le64";
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000125
126 case amdil:
127 case amdil64: return "amdil";
128
129 case hsail:
130 case hsail64: return "hsail";
131
132 case spir:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000133 case spir64: return "spir";
Eric Christopher54fe1b22014-07-10 17:26:54 +0000134 case kalimba: return "kalimba";
Jacques Pienaardbfe8702016-02-11 17:16:20 +0000135 case lanai: return "lanai";
Douglas Katzman1b5767f2015-06-12 18:31:38 +0000136 case shave: return "shave";
Dan Gohman4e2d7992015-08-17 22:35:40 +0000137 case wasm32:
138 case wasm64: return "wasm";
Alex Bradburyb6e784a2016-11-01 16:47:54 +0000139
140 case riscv32:
141 case riscv64: return "riscv";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000142 }
143}
144
Mehdi Aminib7fb1242016-10-01 01:16:22 +0000145StringRef Triple::getVendorTypeName(VendorType Kind) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000146 switch (Kind) {
147 case UnknownVendor: return "unknown";
148
149 case Apple: return "apple";
Chris Lattner07921952009-08-14 18:48:13 +0000150 case PC: return "pc";
John Thompsond0332e42011-03-15 21:51:56 +0000151 case SCEI: return "scei";
Hal Finkelf208af02012-04-02 18:31:33 +0000152 case BGP: return "bgp";
153 case BGQ: return "bgq";
Hal Finkelb5d177e2012-08-28 02:10:30 +0000154 case Freescale: return "fsl";
Duncan Sandsd5772de2012-10-12 11:08:57 +0000155 case IBM: return "ibm";
Daniel Sandersc5626f42014-07-09 16:03:10 +0000156 case ImaginationTechnologies: return "img";
Daniel Sandersdc6a9412014-07-18 14:28:19 +0000157 case MipsTechnologies: return "mti";
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000158 case NVIDIA: return "nvidia";
Eric Christopher54fe1b22014-07-10 17:26:54 +0000159 case CSR: return "csr";
Douglas Katzman78425202015-09-02 23:11:25 +0000160 case Myriad: return "myriad";
Matt Arsenault5e845e52016-02-13 01:56:21 +0000161 case AMD: return "amd";
162 case Mesa: return "mesa";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000163 }
164
David Blaikie46a9f012012-01-20 21:51:11 +0000165 llvm_unreachable("Invalid VendorType!");
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000166}
167
Mehdi Aminib7fb1242016-10-01 01:16:22 +0000168StringRef Triple::getOSTypeName(OSType Kind) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000169 switch (Kind) {
170 case UnknownOS: return "unknown";
171
Ed Schoutendae71892015-03-09 18:40:45 +0000172 case CloudABI: return "cloudabi";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000173 case Darwin: return "darwin";
Daniel Dunbare3384c42009-05-22 02:24:11 +0000174 case DragonFly: return "dragonfly";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000175 case FreeBSD: return "freebsd";
Petr Hoseke023d622016-10-06 05:17:26 +0000176 case Fuchsia: return "fuchsia";
Daniel Dunbard74bac72011-04-19 20:19:27 +0000177 case IOS: return "ios";
Duncan Sandsfe44f672011-07-26 15:30:04 +0000178 case KFreeBSD: return "kfreebsd";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000179 case Linux: return "linux";
Edward O'Callaghanba993b82009-11-19 11:59:00 +0000180 case Lv2: return "lv2";
Daniel Dunbar0854f342011-04-19 23:34:12 +0000181 case MacOSX: return "macosx";
Chris Lattner01218d52009-07-13 20:22:23 +0000182 case NetBSD: return "netbsd";
Duncan Sands14814d42009-06-29 13:36:13 +0000183 case OpenBSD: return "openbsd";
Daniel Dunbar781f94d2009-08-18 04:43:27 +0000184 case Solaris: return "solaris";
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000185 case Win32: return "windows";
Chris Lattner27f20492009-10-16 02:06:30 +0000186 case Haiku: return "haiku";
Chris Lattnerca97c922010-07-07 15:52:27 +0000187 case Minix: return "minix";
Douglas Gregorde3c9262011-07-01 22:41:06 +0000188 case RTEMS: return "rtems";
Eli Benderskyabe54632012-12-04 18:37:26 +0000189 case NaCl: return "nacl";
Hal Finkelf208af02012-04-02 18:31:33 +0000190 case CNK: return "cnk";
Eric Christopher22738d02012-08-06 20:52:18 +0000191 case Bitrig: return "bitrig";
Duncan Sandsd5772de2012-10-12 11:08:57 +0000192 case AIX: return "aix";
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000193 case CUDA: return "cuda";
194 case NVCL: return "nvcl";
Tom Stellard4082a6c2014-12-02 16:45:47 +0000195 case AMDHSA: return "amdhsa";
Alex Rosenberg38babd12015-01-25 22:46:59 +0000196 case PS4: return "ps4";
Michael Kupersteine1194bd2015-10-27 07:23:59 +0000197 case ELFIAMCU: return "elfiamcu";
Tim Northover2d4d1612015-10-28 22:36:05 +0000198 case TvOS: return "tvos";
199 case WatchOS: return "watchos";
Matt Arsenault5e845e52016-02-13 01:56:21 +0000200 case Mesa3D: return "mesa3d";
David L Kreitzer3155abf2016-10-14 14:41:46 +0000201 case Contiki: return "contiki";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000202 }
203
David Blaikie46a9f012012-01-20 21:51:11 +0000204 llvm_unreachable("Invalid OSType");
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000205}
206
Mehdi Aminib7fb1242016-10-01 01:16:22 +0000207StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000208 switch (Kind) {
209 case UnknownEnvironment: return "unknown";
Renato Golin83758d5c2011-01-21 18:25:47 +0000210 case GNU: return "gnu";
Daniel Sanders2cb55d72016-07-19 10:22:19 +0000211 case GNUABI64: return "gnuabi64";
Rafael Espindolaf5e78fa2012-01-18 23:35:29 +0000212 case GNUEABIHF: return "gnueabihf";
Renato Golin83758d5c2011-01-21 18:25:47 +0000213 case GNUEABI: return "gnueabi";
Eli Bendersky0893e102013-01-22 18:02:49 +0000214 case GNUX32: return "gnux32";
David Woodhouse71d15ed2014-01-20 12:02:25 +0000215 case CODE16: return "code16";
Renato Golin83758d5c2011-01-21 18:25:47 +0000216 case EABI: return "eabi";
Joerg Sonnenberger8fe41b72013-12-16 18:51:28 +0000217 case EABIHF: return "eabihf";
Logan Chien9ab55b82012-09-02 09:29:46 +0000218 case Android: return "android";
Rafael Espindola9768b0a2016-06-14 12:45:33 +0000219 case Musl: return "musl";
Rafael Espindolaa895a0c2016-06-24 21:14:33 +0000220 case MuslEABI: return "musleabi";
221 case MuslEABIHF: return "musleabihf";
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000222 case MSVC: return "msvc";
223 case Itanium: return "itanium";
224 case Cygnus: return "cygnus";
Matt Arsenaultf1ffbe72015-07-30 08:16:51 +0000225 case AMDOpenCL: return "amdopencl";
Pat Gavlinb3990952015-08-14 22:41:43 +0000226 case CoreCLR: return "coreclr";
Tom Stellarde190cd22016-09-23 00:42:56 +0000227 case OpenCL: return "opencl";
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000228 }
229
David Blaikie46a9f012012-01-20 21:51:11 +0000230 llvm_unreachable("Invalid EnvironmentType!");
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000231}
232
Alexei Starovoitov310dead2015-06-04 19:15:05 +0000233static Triple::ArchType parseBPFArch(StringRef ArchName) {
234 if (ArchName.equals("bpf")) {
235 if (sys::IsLittleEndianHost)
Alexei Starovoitov8cf9a4c2015-06-05 16:11:14 +0000236 return Triple::bpfel;
Alexei Starovoitov310dead2015-06-04 19:15:05 +0000237 else
Alexei Starovoitov8cf9a4c2015-06-05 16:11:14 +0000238 return Triple::bpfeb;
239 } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
240 return Triple::bpfeb;
241 } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
242 return Triple::bpfel;
Alexei Starovoitov310dead2015-06-04 19:15:05 +0000243 } else {
244 return Triple::UnknownArch;
245 }
246}
247
Daniel Dunbarad36e8a2009-11-06 10:58:06 +0000248Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
Alexei Starovoitov310dead2015-06-04 19:15:05 +0000249 Triple::ArchType BPFArch(parseBPFArch(Name));
Chandler Carruthff6f3562012-02-12 09:27:38 +0000250 return StringSwitch<Triple::ArchType>(Name)
Tim Northovere0e3aef2013-01-31 12:12:40 +0000251 .Case("aarch64", aarch64)
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000252 .Case("aarch64_be", aarch64_be)
Tim Northovere19bed72014-07-23 12:32:47 +0000253 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
Chandler Carruthff6f3562012-02-12 09:27:38 +0000254 .Case("arm", arm)
Christian Pirker2a111602014-03-28 14:35:30 +0000255 .Case("armeb", armeb)
Dylan McKayb1d469c2015-10-16 03:10:30 +0000256 .Case("avr", avr)
Alexei Starovoitov310dead2015-06-04 19:15:05 +0000257 .StartsWith("bpf", BPFArch)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000258 .Case("mips", mips)
259 .Case("mipsel", mipsel)
260 .Case("mips64", mips64)
261 .Case("mips64el", mips64el)
262 .Case("msp430", msp430)
263 .Case("ppc64", ppc64)
264 .Case("ppc32", ppc)
265 .Case("ppc", ppc)
Bill Schmidt0a9170d2013-07-26 01:35:43 +0000266 .Case("ppc64le", ppc64le)
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000267 .Case("r600", r600)
Tom Stellard07f11602015-01-06 18:00:00 +0000268 .Case("amdgcn", amdgcn)
Alex Bradburyb6e784a2016-11-01 16:47:54 +0000269 .Case("riscv32", riscv32)
270 .Case("riscv64", riscv64)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000271 .Case("hexagon", hexagon)
272 .Case("sparc", sparc)
Douglas Katzman49e96132015-05-01 16:49:58 +0000273 .Case("sparcel", sparcel)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000274 .Case("sparcv9", sparcv9)
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000275 .Case("systemz", systemz)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000276 .Case("tce", tce)
277 .Case("thumb", thumb)
Christian Pirker2a111602014-03-28 14:35:30 +0000278 .Case("thumbeb", thumbeb)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000279 .Case("x86", x86)
280 .Case("x86-64", x86_64)
281 .Case("xcore", xcore)
Justin Holewinskiae556d32012-05-04 20:18:50 +0000282 .Case("nvptx", nvptx)
283 .Case("nvptx64", nvptx64)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000284 .Case("le32", le32)
JF Bastien32972ef2014-09-12 17:54:17 +0000285 .Case("le64", le64)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000286 .Case("amdil", amdil)
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000287 .Case("amdil64", amdil64)
288 .Case("hsail", hsail)
289 .Case("hsail64", hsail64)
Micah Villmow48c8ddc2012-10-01 17:01:31 +0000290 .Case("spir", spir)
Guy Benyeia4d31a32012-11-15 10:35:47 +0000291 .Case("spir64", spir64)
Eric Christopher54fe1b22014-07-10 17:26:54 +0000292 .Case("kalimba", kalimba)
Jacques Pienaardbfe8702016-02-11 17:16:20 +0000293 .Case("lanai", lanai)
Douglas Katzman1b5767f2015-06-12 18:31:38 +0000294 .Case("shave", shave)
Dan Gohman10e730a2015-06-29 23:51:55 +0000295 .Case("wasm32", wasm32)
296 .Case("wasm64", wasm64)
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +0000297 .Case("renderscript32", renderscript32)
298 .Case("renderscript64", renderscript64)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000299 .Default(UnknownArch);
Daniel Dunbar0f16ea52009-08-03 04:03:51 +0000300}
301
Renato Golin609bf922014-11-17 14:08:57 +0000302static Triple::ArchType parseARMArch(StringRef ArchName) {
Chandler Carruthbb47b9a2015-08-30 02:09:48 +0000303 unsigned ISA = ARM::parseArchISA(ArchName);
304 unsigned ENDIAN = ARM::parseArchEndian(ArchName);
Renato Golinb6b9e052015-05-21 13:52:20 +0000305
Renato Golin609bf922014-11-17 14:08:57 +0000306 Triple::ArchType arch = Triple::UnknownArch;
Renato Golinb6b9e052015-05-21 13:52:20 +0000307 switch (ENDIAN) {
308 case ARM::EK_LITTLE: {
309 switch (ISA) {
310 case ARM::IK_ARM:
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000311 arch = Triple::arm;
Renato Golinb6b9e052015-05-21 13:52:20 +0000312 break;
313 case ARM::IK_THUMB:
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000314 arch = Triple::thumb;
Renato Golinb6b9e052015-05-21 13:52:20 +0000315 break;
316 case ARM::IK_AARCH64:
317 arch = Triple::aarch64;
318 break;
319 }
320 break;
Renato Golin609bf922014-11-17 14:08:57 +0000321 }
Renato Golinb6b9e052015-05-21 13:52:20 +0000322 case ARM::EK_BIG: {
323 switch (ISA) {
324 case ARM::IK_ARM:
325 arch = Triple::armeb;
326 break;
327 case ARM::IK_THUMB:
328 arch = Triple::thumbeb;
329 break;
330 case ARM::IK_AARCH64:
331 arch = Triple::aarch64_be;
332 break;
333 }
334 break;
335 }
336 }
337
Chandler Carruthbb47b9a2015-08-30 02:09:48 +0000338 ArchName = ARM::getCanonicalArchName(ArchName);
Renato Golinb6b9e052015-05-21 13:52:20 +0000339 if (ArchName.empty())
340 return Triple::UnknownArch;
341
342 // Thumb only exists in v4+
343 if (ISA == ARM::IK_THUMB &&
344 (ArchName.startswith("v2") || ArchName.startswith("v3")))
345 return Triple::UnknownArch;
346
Renato Golinfadc2102015-05-22 18:17:55 +0000347 // Thumb only for v6m
Chandler Carruthbb47b9a2015-08-30 02:09:48 +0000348 unsigned Profile = ARM::parseArchProfile(ArchName);
349 unsigned Version = ARM::parseArchVersion(ArchName);
Renato Golinfadc2102015-05-22 18:17:55 +0000350 if (Profile == ARM::PK_M && Version == 6) {
351 if (ENDIAN == ARM::EK_BIG)
352 return Triple::thumbeb;
353 else
354 return Triple::thumb;
355 }
356
Renato Golinb6b9e052015-05-21 13:52:20 +0000357 return arch;
Renato Golin609bf922014-11-17 14:08:57 +0000358}
359
Chandler Carruthaec97082012-02-21 08:53:32 +0000360static Triple::ArchType parseArch(StringRef ArchName) {
Chandler Carruth5543fbc2015-08-30 09:54:34 +0000361 auto AT = StringSwitch<Triple::ArchType>(ArchName)
Chandler Carruthaec97082012-02-21 08:53:32 +0000362 .Cases("i386", "i486", "i586", "i686", Triple::x86)
363 // FIXME: Do we need to support these?
364 .Cases("i786", "i886", "i986", Triple::x86)
Jim Grosbach664d1482013-11-16 00:52:57 +0000365 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
Kelvin Li510498c2016-01-19 00:04:41 +0000366 .Cases("powerpc", "ppc32", Triple::ppc)
367 .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
368 .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
Renato Golin609bf922014-11-17 14:08:57 +0000369 .Case("xscale", Triple::arm)
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000370 .Case("xscaleeb", Triple::armeb)
Chandler Carruth5543fbc2015-08-30 09:54:34 +0000371 .Case("aarch64", Triple::aarch64)
372 .Case("aarch64_be", Triple::aarch64_be)
373 .Case("arm64", Triple::aarch64)
374 .Case("arm", Triple::arm)
375 .Case("armeb", Triple::armeb)
376 .Case("thumb", Triple::thumb)
377 .Case("thumbeb", Triple::thumbeb)
Dylan McKayb1d469c2015-10-16 03:10:30 +0000378 .Case("avr", Triple::avr)
Chandler Carruthaec97082012-02-21 08:53:32 +0000379 .Case("msp430", Triple::msp430)
380 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
Chandler Carruth0c7a7cc2012-02-22 11:32:54 +0000381 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
Chandler Carruthaec97082012-02-21 08:53:32 +0000382 .Cases("mips64", "mips64eb", Triple::mips64)
383 .Case("mips64el", Triple::mips64el)
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000384 .Case("r600", Triple::r600)
Tom Stellard07f11602015-01-06 18:00:00 +0000385 .Case("amdgcn", Triple::amdgcn)
Alex Bradburyb6e784a2016-11-01 16:47:54 +0000386 .Case("riscv32", Triple::riscv32)
387 .Case("riscv64", Triple::riscv64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000388 .Case("hexagon", Triple::hexagon)
Kelvin Li510498c2016-01-19 00:04:41 +0000389 .Cases("s390x", "systemz", Triple::systemz)
Chandler Carruthaec97082012-02-21 08:53:32 +0000390 .Case("sparc", Triple::sparc)
Douglas Katzmane0ff2822015-04-29 19:15:08 +0000391 .Case("sparcel", Triple::sparcel)
Jakob Stoklund Olesenabc3d232013-05-14 17:47:27 +0000392 .Cases("sparcv9", "sparc64", Triple::sparcv9)
Chandler Carruthaec97082012-02-21 08:53:32 +0000393 .Case("tce", Triple::tce)
394 .Case("xcore", Triple::xcore)
Justin Holewinskiae556d32012-05-04 20:18:50 +0000395 .Case("nvptx", Triple::nvptx)
396 .Case("nvptx64", Triple::nvptx64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000397 .Case("le32", Triple::le32)
JF Bastien32972ef2014-09-12 17:54:17 +0000398 .Case("le64", Triple::le64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000399 .Case("amdil", Triple::amdil)
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000400 .Case("amdil64", Triple::amdil64)
401 .Case("hsail", Triple::hsail)
402 .Case("hsail64", Triple::hsail64)
Micah Villmow48c8ddc2012-10-01 17:01:31 +0000403 .Case("spir", Triple::spir)
Guy Benyeia4d31a32012-11-15 10:35:47 +0000404 .Case("spir64", Triple::spir64)
Matthew Gardiner3b15a892014-09-05 06:46:43 +0000405 .StartsWith("kalimba", Triple::kalimba)
Jacques Pienaardbfe8702016-02-11 17:16:20 +0000406 .Case("lanai", Triple::lanai)
Douglas Katzman1b5767f2015-06-12 18:31:38 +0000407 .Case("shave", Triple::shave)
Dan Gohman10e730a2015-06-29 23:51:55 +0000408 .Case("wasm32", Triple::wasm32)
409 .Case("wasm64", Triple::wasm64)
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +0000410 .Case("renderscript32", Triple::renderscript32)
411 .Case("renderscript64", Triple::renderscript64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000412 .Default(Triple::UnknownArch);
Chandler Carruth5543fbc2015-08-30 09:54:34 +0000413
414 // Some architectures require special parsing logic just to compute the
415 // ArchType result.
416 if (AT == Triple::UnknownArch) {
417 if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
418 ArchName.startswith("aarch64"))
419 return parseARMArch(ArchName);
420 if (ArchName.startswith("bpf"))
421 return parseBPFArch(ArchName);
422 }
423
424 return AT;
Duncan Sands501dff72010-08-12 11:31:39 +0000425}
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000426
Chandler Carruthaec97082012-02-21 08:53:32 +0000427static Triple::VendorType parseVendor(StringRef VendorName) {
428 return StringSwitch<Triple::VendorType>(VendorName)
429 .Case("apple", Triple::Apple)
430 .Case("pc", Triple::PC)
431 .Case("scei", Triple::SCEI)
Hal Finkelf208af02012-04-02 18:31:33 +0000432 .Case("bgp", Triple::BGP)
433 .Case("bgq", Triple::BGQ)
Hal Finkelb5d177e2012-08-28 02:10:30 +0000434 .Case("fsl", Triple::Freescale)
Duncan Sandsd5772de2012-10-12 11:08:57 +0000435 .Case("ibm", Triple::IBM)
Daniel Sandersc5626f42014-07-09 16:03:10 +0000436 .Case("img", Triple::ImaginationTechnologies)
Daniel Sandersdc6a9412014-07-18 14:28:19 +0000437 .Case("mti", Triple::MipsTechnologies)
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000438 .Case("nvidia", Triple::NVIDIA)
Eric Christopher54fe1b22014-07-10 17:26:54 +0000439 .Case("csr", Triple::CSR)
Douglas Katzman78425202015-09-02 23:11:25 +0000440 .Case("myriad", Triple::Myriad)
Matt Arsenault5e845e52016-02-13 01:56:21 +0000441 .Case("amd", Triple::AMD)
442 .Case("mesa", Triple::Mesa)
Chandler Carruthaec97082012-02-21 08:53:32 +0000443 .Default(Triple::UnknownVendor);
Duncan Sands501dff72010-08-12 11:31:39 +0000444}
445
Chandler Carruthaec97082012-02-21 08:53:32 +0000446static Triple::OSType parseOS(StringRef OSName) {
447 return StringSwitch<Triple::OSType>(OSName)
Ed Schoutendae71892015-03-09 18:40:45 +0000448 .StartsWith("cloudabi", Triple::CloudABI)
Chandler Carruthaec97082012-02-21 08:53:32 +0000449 .StartsWith("darwin", Triple::Darwin)
450 .StartsWith("dragonfly", Triple::DragonFly)
451 .StartsWith("freebsd", Triple::FreeBSD)
Petr Hoseke023d622016-10-06 05:17:26 +0000452 .StartsWith("fuchsia", Triple::Fuchsia)
Chandler Carruthaec97082012-02-21 08:53:32 +0000453 .StartsWith("ios", Triple::IOS)
454 .StartsWith("kfreebsd", Triple::KFreeBSD)
455 .StartsWith("linux", Triple::Linux)
456 .StartsWith("lv2", Triple::Lv2)
457 .StartsWith("macosx", Triple::MacOSX)
Chandler Carruthaec97082012-02-21 08:53:32 +0000458 .StartsWith("netbsd", Triple::NetBSD)
459 .StartsWith("openbsd", Triple::OpenBSD)
Chandler Carruthaec97082012-02-21 08:53:32 +0000460 .StartsWith("solaris", Triple::Solaris)
461 .StartsWith("win32", Triple::Win32)
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000462 .StartsWith("windows", Triple::Win32)
Chandler Carruthaec97082012-02-21 08:53:32 +0000463 .StartsWith("haiku", Triple::Haiku)
464 .StartsWith("minix", Triple::Minix)
465 .StartsWith("rtems", Triple::RTEMS)
Eli Benderskyabe54632012-12-04 18:37:26 +0000466 .StartsWith("nacl", Triple::NaCl)
Hal Finkelf208af02012-04-02 18:31:33 +0000467 .StartsWith("cnk", Triple::CNK)
Eric Christopher22738d02012-08-06 20:52:18 +0000468 .StartsWith("bitrig", Triple::Bitrig)
Duncan Sandsd5772de2012-10-12 11:08:57 +0000469 .StartsWith("aix", Triple::AIX)
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000470 .StartsWith("cuda", Triple::CUDA)
471 .StartsWith("nvcl", Triple::NVCL)
Tom Stellard4082a6c2014-12-02 16:45:47 +0000472 .StartsWith("amdhsa", Triple::AMDHSA)
Alex Rosenberg38babd12015-01-25 22:46:59 +0000473 .StartsWith("ps4", Triple::PS4)
Michael Kupersteine1194bd2015-10-27 07:23:59 +0000474 .StartsWith("elfiamcu", Triple::ELFIAMCU)
Tim Northover2d4d1612015-10-28 22:36:05 +0000475 .StartsWith("tvos", Triple::TvOS)
476 .StartsWith("watchos", Triple::WatchOS)
Matt Arsenault5e845e52016-02-13 01:56:21 +0000477 .StartsWith("mesa3d", Triple::Mesa3D)
David L Kreitzer3155abf2016-10-14 14:41:46 +0000478 .StartsWith("contiki", Triple::Contiki)
Chandler Carruthaec97082012-02-21 08:53:32 +0000479 .Default(Triple::UnknownOS);
Duncan Sands501dff72010-08-12 11:31:39 +0000480}
481
Chandler Carruthaec97082012-02-21 08:53:32 +0000482static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
483 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
Joerg Sonnenberger8fe41b72013-12-16 18:51:28 +0000484 .StartsWith("eabihf", Triple::EABIHF)
Chandler Carruthaec97082012-02-21 08:53:32 +0000485 .StartsWith("eabi", Triple::EABI)
Daniel Sanders2cb55d72016-07-19 10:22:19 +0000486 .StartsWith("gnuabi64", Triple::GNUABI64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000487 .StartsWith("gnueabihf", Triple::GNUEABIHF)
488 .StartsWith("gnueabi", Triple::GNUEABI)
Eli Bendersky0893e102013-01-22 18:02:49 +0000489 .StartsWith("gnux32", Triple::GNUX32)
David Woodhouse71d15ed2014-01-20 12:02:25 +0000490 .StartsWith("code16", Triple::CODE16)
Chandler Carruthaec97082012-02-21 08:53:32 +0000491 .StartsWith("gnu", Triple::GNU)
Logan Chien9ab55b82012-09-02 09:29:46 +0000492 .StartsWith("android", Triple::Android)
Rafael Espindolaa895a0c2016-06-24 21:14:33 +0000493 .StartsWith("musleabihf", Triple::MuslEABIHF)
494 .StartsWith("musleabi", Triple::MuslEABI)
Rafael Espindola9768b0a2016-06-14 12:45:33 +0000495 .StartsWith("musl", Triple::Musl)
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000496 .StartsWith("msvc", Triple::MSVC)
497 .StartsWith("itanium", Triple::Itanium)
498 .StartsWith("cygnus", Triple::Cygnus)
Matt Arsenaultf1ffbe72015-07-30 08:16:51 +0000499 .StartsWith("amdopencl", Triple::AMDOpenCL)
Pat Gavlinb3990952015-08-14 22:41:43 +0000500 .StartsWith("coreclr", Triple::CoreCLR)
Tom Stellarde190cd22016-09-23 00:42:56 +0000501 .StartsWith("opencl", Triple::OpenCL)
Chandler Carruthaec97082012-02-21 08:53:32 +0000502 .Default(Triple::UnknownEnvironment);
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000503}
504
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000505static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
506 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
507 .EndsWith("coff", Triple::COFF)
508 .EndsWith("elf", Triple::ELF)
509 .EndsWith("macho", Triple::MachO)
510 .Default(Triple::UnknownObjectFormat);
511}
512
Renato Golinc17a07b2014-07-18 12:00:48 +0000513static Triple::SubArchType parseSubArch(StringRef SubArchName) {
Chandler Carruthbb47b9a2015-08-30 02:09:48 +0000514 StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000515
Renato Golinfe54d342015-05-24 11:18:44 +0000516 // For now, this is the small part. Early return.
517 if (ARMSubArch.empty())
518 return StringSwitch<Triple::SubArchType>(SubArchName)
519 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
520 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
521 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
522 .Default(Triple::NoSubArch);
523
524 // ARM sub arch.
Chandler Carruthbb47b9a2015-08-30 02:09:48 +0000525 switch(ARM::parseArch(ARMSubArch)) {
Renato Golinfe54d342015-05-24 11:18:44 +0000526 case ARM::AK_ARMV4:
527 return Triple::NoSubArch;
528 case ARM::AK_ARMV4T:
529 return Triple::ARMSubArch_v4t;
Renato Golinfe54d342015-05-24 11:18:44 +0000530 case ARM::AK_ARMV5T:
Renato Golinfe54d342015-05-24 11:18:44 +0000531 return Triple::ARMSubArch_v5;
532 case ARM::AK_ARMV5TE:
533 case ARM::AK_IWMMXT:
534 case ARM::AK_IWMMXT2:
535 case ARM::AK_XSCALE:
536 case ARM::AK_ARMV5TEJ:
537 return Triple::ARMSubArch_v5te;
538 case ARM::AK_ARMV6:
Renato Golinfe54d342015-05-24 11:18:44 +0000539 return Triple::ARMSubArch_v6;
540 case ARM::AK_ARMV6K:
Artyom Skrobovf187a652015-11-16 14:05:32 +0000541 case ARM::AK_ARMV6KZ:
Renato Golinfe54d342015-05-24 11:18:44 +0000542 return Triple::ARMSubArch_v6k;
543 case ARM::AK_ARMV6T2:
544 return Triple::ARMSubArch_v6t2;
545 case ARM::AK_ARMV6M:
Renato Golinfe54d342015-05-24 11:18:44 +0000546 return Triple::ARMSubArch_v6m;
Renato Golinfe54d342015-05-24 11:18:44 +0000547 case ARM::AK_ARMV7A:
548 case ARM::AK_ARMV7R:
Renato Golinfe54d342015-05-24 11:18:44 +0000549 return Triple::ARMSubArch_v7;
Tim Northover2d4d1612015-10-28 22:36:05 +0000550 case ARM::AK_ARMV7K:
551 return Triple::ARMSubArch_v7k;
Renato Golinfe54d342015-05-24 11:18:44 +0000552 case ARM::AK_ARMV7M:
553 return Triple::ARMSubArch_v7m;
554 case ARM::AK_ARMV7S:
555 return Triple::ARMSubArch_v7s;
556 case ARM::AK_ARMV7EM:
557 return Triple::ARMSubArch_v7em;
558 case ARM::AK_ARMV8A:
559 return Triple::ARMSubArch_v8;
560 case ARM::AK_ARMV8_1A:
561 return Triple::ARMSubArch_v8_1a;
Oliver Stannard46670712015-12-01 10:33:56 +0000562 case ARM::AK_ARMV8_2A:
563 return Triple::ARMSubArch_v8_2a;
Javed Absarfb4b6e82016-10-07 12:06:40 +0000564 case ARM::AK_ARMV8R:
565 return Triple::ARMSubArch_v8r;
Bradley Smithe26f7992016-01-15 10:24:39 +0000566 case ARM::AK_ARMV8MBaseline:
567 return Triple::ARMSubArch_v8m_baseline;
568 case ARM::AK_ARMV8MMainline:
569 return Triple::ARMSubArch_v8m_mainline;
Renato Golinfe54d342015-05-24 11:18:44 +0000570 default:
571 return Triple::NoSubArch;
572 }
Renato Golinc17a07b2014-07-18 12:00:48 +0000573}
574
Mehdi Aminib7fb1242016-10-01 01:16:22 +0000575static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000576 switch (Kind) {
577 case Triple::UnknownObjectFormat: return "";
578 case Triple::COFF: return "coff";
579 case Triple::ELF: return "elf";
580 case Triple::MachO: return "macho";
581 }
582 llvm_unreachable("unknown object format type");
583}
584
585static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
Rafael Espindola24254892015-03-18 22:19:16 +0000586 switch (T.getArch()) {
David Majnemerff1d0842015-12-22 01:39:04 +0000587 case Triple::UnknownArch:
588 case Triple::aarch64:
589 case Triple::arm:
590 case Triple::thumb:
591 case Triple::x86:
592 case Triple::x86_64:
593 if (T.isOSDarwin())
594 return Triple::MachO;
595 else if (T.isOSWindows())
596 return Triple::COFF;
597 return Triple::ELF;
598
599 case Triple::aarch64_be:
600 case Triple::amdgcn:
601 case Triple::amdil:
602 case Triple::amdil64:
603 case Triple::armeb:
604 case Triple::avr:
605 case Triple::bpfeb:
606 case Triple::bpfel:
Rafael Espindola24254892015-03-18 22:19:16 +0000607 case Triple::hexagon:
Jacques Pienaardbfe8702016-02-11 17:16:20 +0000608 case Triple::lanai:
David Majnemerff1d0842015-12-22 01:39:04 +0000609 case Triple::hsail:
610 case Triple::hsail64:
611 case Triple::kalimba:
612 case Triple::le32:
613 case Triple::le64:
Rafael Espindola24254892015-03-18 22:19:16 +0000614 case Triple::mips:
Rafael Espindola24254892015-03-18 22:19:16 +0000615 case Triple::mips64:
616 case Triple::mips64el:
David Majnemerff1d0842015-12-22 01:39:04 +0000617 case Triple::mipsel:
618 case Triple::msp430:
619 case Triple::nvptx:
620 case Triple::nvptx64:
621 case Triple::ppc64le:
Rafael Espindola24254892015-03-18 22:19:16 +0000622 case Triple::r600:
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +0000623 case Triple::renderscript32:
624 case Triple::renderscript64:
Alex Bradburyb6e784a2016-11-01 16:47:54 +0000625 case Triple::riscv32:
626 case Triple::riscv64:
David Majnemerff1d0842015-12-22 01:39:04 +0000627 case Triple::shave:
Rafael Espindola24254892015-03-18 22:19:16 +0000628 case Triple::sparc:
David Majnemerff1d0842015-12-22 01:39:04 +0000629 case Triple::sparcel:
Rafael Espindola24254892015-03-18 22:19:16 +0000630 case Triple::sparcv9:
David Majnemerff1d0842015-12-22 01:39:04 +0000631 case Triple::spir:
632 case Triple::spir64:
Rafael Espindola24254892015-03-18 22:19:16 +0000633 case Triple::systemz:
David Majnemerff1d0842015-12-22 01:39:04 +0000634 case Triple::tce:
635 case Triple::thumbeb:
Dan Gohman05ac43f2015-12-17 01:39:00 +0000636 case Triple::wasm32:
637 case Triple::wasm64:
Rafael Espindola24254892015-03-18 22:19:16 +0000638 case Triple::xcore:
Rafael Espindola7f454402015-03-19 02:40:56 +0000639 return Triple::ELF;
640
641 case Triple::ppc:
642 case Triple::ppc64:
643 if (T.isOSDarwin())
644 return Triple::MachO;
Rafael Espindola24254892015-03-18 22:19:16 +0000645 return Triple::ELF;
646 }
David Majnemerff1d0842015-12-22 01:39:04 +0000647 llvm_unreachable("unknown architecture");
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000648}
649
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000650/// \brief Construct a triple from the string representation provided.
651///
Chandler Carruth1f3325a2012-02-21 08:31:18 +0000652/// This stores the string representation and parses the various pieces into
653/// enum members.
Chandler Carruth2d27b0f2012-02-21 03:39:36 +0000654Triple::Triple(const Twine &Str)
Chandler Carruthf054eca2015-09-10 07:51:43 +0000655 : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
656 Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
657 ObjectFormat(UnknownObjectFormat) {
658 // Do minimal parsing by hand here.
659 SmallVector<StringRef, 4> Components;
660 StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
661 if (Components.size() > 0) {
662 Arch = parseArch(Components[0]);
663 SubArch = parseSubArch(Components[0]);
664 if (Components.size() > 1) {
665 Vendor = parseVendor(Components[1]);
666 if (Components.size() > 2) {
667 OS = parseOS(Components[2]);
668 if (Components.size() > 3) {
669 Environment = parseEnvironment(Components[3]);
670 ObjectFormat = parseFormat(Components[3]);
671 }
672 }
673 }
674 }
675 if (ObjectFormat == UnknownObjectFormat)
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000676 ObjectFormat = getDefaultFormat(*this);
Chandler Carruth2d27b0f2012-02-21 03:39:36 +0000677}
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000678
679/// \brief Construct a triple from string representations of the architecture,
680/// vendor, and OS.
681///
Chandler Carruth1f3325a2012-02-21 08:31:18 +0000682/// This joins each argument into a canonical string representation and parses
683/// them into enum members. It leaves the environment unknown and omits it from
684/// the string representation.
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000685Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
686 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
Chandler Carruthaec97082012-02-21 08:53:32 +0000687 Arch(parseArch(ArchStr.str())),
Renato Golinc17a07b2014-07-18 12:00:48 +0000688 SubArch(parseSubArch(ArchStr.str())),
Chandler Carruthaec97082012-02-21 08:53:32 +0000689 Vendor(parseVendor(VendorStr.str())),
690 OS(parseOS(OSStr.str())),
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000691 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
692 ObjectFormat = getDefaultFormat(*this);
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000693}
694
695/// \brief Construct a triple from string representations of the architecture,
696/// vendor, OS, and environment.
697///
Chandler Carruth1f3325a2012-02-21 08:31:18 +0000698/// This joins each argument into a canonical string representation and parses
699/// them into enum members.
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000700Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
701 const Twine &EnvironmentStr)
702 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
703 EnvironmentStr).str()),
Chandler Carruthaec97082012-02-21 08:53:32 +0000704 Arch(parseArch(ArchStr.str())),
Renato Golinc17a07b2014-07-18 12:00:48 +0000705 SubArch(parseSubArch(ArchStr.str())),
Chandler Carruthaec97082012-02-21 08:53:32 +0000706 Vendor(parseVendor(VendorStr.str())),
707 OS(parseOS(OSStr.str())),
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000708 Environment(parseEnvironment(EnvironmentStr.str())),
709 ObjectFormat(parseFormat(EnvironmentStr.str())) {
710 if (ObjectFormat == Triple::UnknownObjectFormat)
711 ObjectFormat = getDefaultFormat(*this);
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000712}
713
Duncan Sands501dff72010-08-12 11:31:39 +0000714std::string Triple::normalize(StringRef Str) {
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000715 bool IsMinGW32 = false;
716 bool IsCygwin = false;
717
Duncan Sands501dff72010-08-12 11:31:39 +0000718 // Parse into components.
719 SmallVector<StringRef, 4> Components;
Chandler Carruth47712172015-09-10 06:07:03 +0000720 Str.split(Components, '-');
Duncan Sands501dff72010-08-12 11:31:39 +0000721
722 // If the first component corresponds to a known architecture, preferentially
723 // use it for the architecture. If the second component corresponds to a
724 // known vendor, preferentially use it for the vendor, etc. This avoids silly
725 // component movement when a component parses as (eg) both a valid arch and a
726 // valid os.
727 ArchType Arch = UnknownArch;
728 if (Components.size() > 0)
Chandler Carruthaec97082012-02-21 08:53:32 +0000729 Arch = parseArch(Components[0]);
Duncan Sands501dff72010-08-12 11:31:39 +0000730 VendorType Vendor = UnknownVendor;
731 if (Components.size() > 1)
Chandler Carruthaec97082012-02-21 08:53:32 +0000732 Vendor = parseVendor(Components[1]);
Duncan Sands501dff72010-08-12 11:31:39 +0000733 OSType OS = UnknownOS;
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000734 if (Components.size() > 2) {
Chandler Carruthaec97082012-02-21 08:53:32 +0000735 OS = parseOS(Components[2]);
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000736 IsCygwin = Components[2].startswith("cygwin");
737 IsMinGW32 = Components[2].startswith("mingw");
738 }
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000739 EnvironmentType Environment = UnknownEnvironment;
740 if (Components.size() > 3)
Chandler Carruthaec97082012-02-21 08:53:32 +0000741 Environment = parseEnvironment(Components[3]);
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000742 ObjectFormatType ObjectFormat = UnknownObjectFormat;
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000743 if (Components.size() > 4)
744 ObjectFormat = parseFormat(Components[4]);
Duncan Sands501dff72010-08-12 11:31:39 +0000745
746 // Note which components are already in their final position. These will not
747 // be moved.
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000748 bool Found[4];
Duncan Sands501dff72010-08-12 11:31:39 +0000749 Found[0] = Arch != UnknownArch;
750 Found[1] = Vendor != UnknownVendor;
751 Found[2] = OS != UnknownOS;
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000752 Found[3] = Environment != UnknownEnvironment;
Duncan Sands501dff72010-08-12 11:31:39 +0000753
754 // If they are not there already, permute the components into their canonical
755 // positions by seeing if they parse as a valid architecture, and if so moving
756 // the component to the architecture position etc.
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000757 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
Duncan Sands501dff72010-08-12 11:31:39 +0000758 if (Found[Pos])
759 continue; // Already in the canonical position.
760
761 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
762 // Do not reparse any components that already matched.
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000763 if (Idx < array_lengthof(Found) && Found[Idx])
Duncan Sands501dff72010-08-12 11:31:39 +0000764 continue;
765
766 // Does this component parse as valid for the target position?
767 bool Valid = false;
768 StringRef Comp = Components[Idx];
769 switch (Pos) {
Craig Toppera2886c22012-02-07 05:05:23 +0000770 default: llvm_unreachable("unexpected component type!");
Duncan Sands501dff72010-08-12 11:31:39 +0000771 case 0:
Chandler Carruthaec97082012-02-21 08:53:32 +0000772 Arch = parseArch(Comp);
Duncan Sands501dff72010-08-12 11:31:39 +0000773 Valid = Arch != UnknownArch;
774 break;
775 case 1:
Chandler Carruthaec97082012-02-21 08:53:32 +0000776 Vendor = parseVendor(Comp);
Duncan Sands501dff72010-08-12 11:31:39 +0000777 Valid = Vendor != UnknownVendor;
778 break;
779 case 2:
Chandler Carruthaec97082012-02-21 08:53:32 +0000780 OS = parseOS(Comp);
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000781 IsCygwin = Comp.startswith("cygwin");
782 IsMinGW32 = Comp.startswith("mingw");
783 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
Duncan Sands501dff72010-08-12 11:31:39 +0000784 break;
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000785 case 3:
Chandler Carruthaec97082012-02-21 08:53:32 +0000786 Environment = parseEnvironment(Comp);
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000787 Valid = Environment != UnknownEnvironment;
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000788 if (!Valid) {
789 ObjectFormat = parseFormat(Comp);
790 Valid = ObjectFormat != UnknownObjectFormat;
791 }
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000792 break;
Duncan Sands501dff72010-08-12 11:31:39 +0000793 }
794 if (!Valid)
795 continue; // Nope, try the next component.
796
797 // Move the component to the target position, pushing any non-fixed
798 // components that are in the way to the right. This tends to give
799 // good results in the common cases of a forgotten vendor component
800 // or a wrongly positioned environment.
801 if (Pos < Idx) {
802 // Insert left, pushing the existing components to the right. For
803 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
804 StringRef CurrentComponent(""); // The empty component.
805 // Replace the component we are moving with an empty component.
806 std::swap(CurrentComponent, Components[Idx]);
807 // Insert the component being moved at Pos, displacing any existing
808 // components to the right.
809 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
810 // Skip over any fixed components.
Chandler Carruth362087b2012-02-21 09:29:14 +0000811 while (i < array_lengthof(Found) && Found[i])
812 ++i;
Duncan Sands501dff72010-08-12 11:31:39 +0000813 // Place the component at the new position, getting the component
814 // that was at this position - it will be moved right.
815 std::swap(CurrentComponent, Components[i]);
816 }
817 } else if (Pos > Idx) {
818 // Push right by inserting empty components until the component at Idx
819 // reaches the target position Pos. For example, pc-a -> -pc-a when
820 // moving pc to the second position.
821 do {
822 // Insert one empty component at Idx.
823 StringRef CurrentComponent(""); // The empty component.
Duncan Sandsfdfdbd02011-02-02 10:08:38 +0000824 for (unsigned i = Idx; i < Components.size();) {
Duncan Sands501dff72010-08-12 11:31:39 +0000825 // Place the component at the new position, getting the component
826 // that was at this position - it will be moved right.
827 std::swap(CurrentComponent, Components[i]);
828 // If it was placed on top of an empty component then we are done.
829 if (CurrentComponent.empty())
830 break;
Duncan Sandsfdfdbd02011-02-02 10:08:38 +0000831 // Advance to the next component, skipping any fixed components.
Anders Carlsson630125a2011-02-05 18:19:35 +0000832 while (++i < array_lengthof(Found) && Found[i])
833 ;
Duncan Sands501dff72010-08-12 11:31:39 +0000834 }
835 // The last component was pushed off the end - append it.
836 if (!CurrentComponent.empty())
837 Components.push_back(CurrentComponent);
838
839 // Advance Idx to the component's new position.
Chandler Carruth362087b2012-02-21 09:29:14 +0000840 while (++Idx < array_lengthof(Found) && Found[Idx])
841 ;
Duncan Sands501dff72010-08-12 11:31:39 +0000842 } while (Idx < Pos); // Add more until the final position is reached.
843 }
844 assert(Pos < Components.size() && Components[Pos] == Comp &&
845 "Component moved wrong!");
846 Found[Pos] = true;
847 break;
848 }
849 }
850
851 // Special case logic goes here. At this point Arch, Vendor and OS have the
852 // correct values for the computed components.
David Majnemeraac4ea02015-06-01 23:38:09 +0000853 std::string NormalizedEnvironment;
854 if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
855 StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
856 if (AndroidVersion.empty()) {
857 Components[3] = "android";
858 } else {
859 NormalizedEnvironment = Twine("android", AndroidVersion).str();
860 Components[3] = NormalizedEnvironment;
861 }
862 }
Duncan Sands501dff72010-08-12 11:31:39 +0000863
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000864 if (OS == Triple::Win32) {
865 Components.resize(4);
866 Components[2] = "windows";
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000867 if (Environment == UnknownEnvironment) {
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +0000868 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000869 Components[3] = "msvc";
870 else
871 Components[3] = getObjectFormatTypeName(ObjectFormat);
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000872 }
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000873 } else if (IsMinGW32) {
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000874 Components.resize(4);
875 Components[2] = "windows";
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +0000876 Components[3] = "gnu";
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000877 } else if (IsCygwin) {
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000878 Components.resize(4);
879 Components[2] = "windows";
880 Components[3] = "cygnus";
881 }
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000882 if (IsMinGW32 || IsCygwin ||
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +0000883 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
884 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
885 Components.resize(5);
886 Components[4] = getObjectFormatTypeName(ObjectFormat);
887 }
888 }
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000889
Duncan Sands501dff72010-08-12 11:31:39 +0000890 // Stick the corrected components back together to form the normalized string.
891 std::string Normalized;
892 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
893 if (i) Normalized += '-';
894 Normalized += Components[i];
895 }
896 return Normalized;
897}
898
Daniel Dunbar19e70762009-07-26 03:31:47 +0000899StringRef Triple::getArchName() const {
900 return StringRef(Data).split('-').first; // Isolate first component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000901}
902
Daniel Dunbar19e70762009-07-26 03:31:47 +0000903StringRef Triple::getVendorName() const {
904 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
905 return Tmp.split('-').first; // Isolate second component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000906}
907
Daniel Dunbar19e70762009-07-26 03:31:47 +0000908StringRef Triple::getOSName() const {
909 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
910 Tmp = Tmp.split('-').second; // Strip second component
911 return Tmp.split('-').first; // Isolate third component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000912}
913
Daniel Dunbar19e70762009-07-26 03:31:47 +0000914StringRef Triple::getEnvironmentName() const {
915 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
916 Tmp = Tmp.split('-').second; // Strip second component
917 return Tmp.split('-').second; // Strip third component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000918}
919
Daniel Dunbar19e70762009-07-26 03:31:47 +0000920StringRef Triple::getOSAndEnvironmentName() const {
921 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
922 return Tmp.split('-').second; // Strip second component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000923}
924
Chris Lattner553c9f32009-08-12 06:19:40 +0000925static unsigned EatNumber(StringRef &Str) {
926 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000927 unsigned Result = 0;
Jim Grosbachf638b262010-12-17 02:10:59 +0000928
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000929 do {
930 // Consume the leading digit.
Chris Lattner553c9f32009-08-12 06:19:40 +0000931 Result = Result*10 + (Str[0] - '0');
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000932
Chris Lattner553c9f32009-08-12 06:19:40 +0000933 // Eat the digit.
934 Str = Str.substr(1);
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000935 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
Jim Grosbachf638b262010-12-17 02:10:59 +0000936
Chris Lattner553c9f32009-08-12 06:19:40 +0000937 return Result;
938}
939
David Majnemeraac4ea02015-06-01 23:38:09 +0000940static void parseVersionFromName(StringRef Name, unsigned &Major,
941 unsigned &Minor, unsigned &Micro) {
942 // Any unset version defaults to 0.
943 Major = Minor = Micro = 0;
944
945 // Parse up to three components.
946 unsigned *Components[3] = {&Major, &Minor, &Micro};
947 for (unsigned i = 0; i != 3; ++i) {
948 if (Name.empty() || Name[0] < '0' || Name[0] > '9')
949 break;
950
951 // Consume the leading number.
952 *Components[i] = EatNumber(Name);
953
954 // Consume the separator, if present.
955 if (Name.startswith("."))
956 Name = Name.substr(1);
957 }
958}
959
960void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
961 unsigned &Micro) const {
962 StringRef EnvironmentName = getEnvironmentName();
963 StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
964 if (EnvironmentName.startswith(EnvironmentTypeName))
965 EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
David Majnemer3a4ce892015-06-01 23:45:25 +0000966
David Majnemeraac4ea02015-06-01 23:38:09 +0000967 parseVersionFromName(EnvironmentName, Major, Minor, Micro);
968}
969
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000970void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
971 unsigned &Micro) const {
Chris Lattner553c9f32009-08-12 06:19:40 +0000972 StringRef OSName = getOSName();
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000973 // Assume that the OS portion of the triple starts with the canonical name.
974 StringRef OSTypeName = getOSTypeName(getOS());
975 if (OSName.startswith(OSTypeName))
976 OSName = OSName.substr(OSTypeName.size());
Jim Grosbachf638b262010-12-17 02:10:59 +0000977
David Majnemeraac4ea02015-06-01 23:38:09 +0000978 parseVersionFromName(OSName, Major, Minor, Micro);
Chris Lattner553c9f32009-08-12 06:19:40 +0000979}
980
Bob Wilsonaa30aff2012-01-31 22:32:29 +0000981bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
982 unsigned &Micro) const {
983 getOSVersion(Major, Minor, Micro);
984
985 switch (getOS()) {
Craig Toppera2886c22012-02-07 05:05:23 +0000986 default: llvm_unreachable("unexpected OS for Darwin triple");
Bob Wilsonaa30aff2012-01-31 22:32:29 +0000987 case Darwin:
988 // Default to darwin8, i.e., MacOSX 10.4.
989 if (Major == 0)
990 Major = 8;
991 // Darwin version numbers are skewed from OS X versions.
992 if (Major < 4)
993 return false;
994 Micro = 0;
995 Minor = Major - 4;
996 Major = 10;
997 break;
998 case MacOSX:
999 // Default to 10.4.
1000 if (Major == 0) {
1001 Major = 10;
1002 Minor = 4;
1003 }
1004 if (Major != 10)
1005 return false;
1006 break;
1007 case IOS:
Tim Northover2d4d1612015-10-28 22:36:05 +00001008 case TvOS:
1009 case WatchOS:
Bob Wilsonaa30aff2012-01-31 22:32:29 +00001010 // Ignore the version from the triple. This is only handled because the
1011 // the clang driver combines OS X and IOS support into a common Darwin
1012 // toolchain that wants to know the OS X version number even when targeting
1013 // IOS.
1014 Major = 10;
1015 Minor = 4;
1016 Micro = 0;
1017 break;
1018 }
1019 return true;
1020}
1021
Chad Rosierd84eaac2012-05-09 17:23:48 +00001022void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
1023 unsigned &Micro) const {
1024 switch (getOS()) {
1025 default: llvm_unreachable("unexpected OS for Darwin triple");
1026 case Darwin:
1027 case MacOSX:
1028 // Ignore the version from the triple. This is only handled because the
1029 // the clang driver combines OS X and IOS support into a common Darwin
1030 // toolchain that wants to know the iOS version number even when targeting
1031 // OS X.
Tim Northover3e8df692013-12-10 11:53:16 +00001032 Major = 5;
Chad Rosierd84eaac2012-05-09 17:23:48 +00001033 Minor = 0;
1034 Micro = 0;
Chad Rosier2778cbc2012-05-09 17:38:47 +00001035 break;
Chad Rosierd84eaac2012-05-09 17:23:48 +00001036 case IOS:
Tim Northover2d4d1612015-10-28 22:36:05 +00001037 case TvOS:
Chad Rosierd84eaac2012-05-09 17:23:48 +00001038 getOSVersion(Major, Minor, Micro);
Tim Northover00ed9962014-03-29 10:18:08 +00001039 // Default to 5.0 (or 7.0 for arm64).
Chad Rosier9d7b1ce2012-05-09 18:23:00 +00001040 if (Major == 0)
Tim Northovere19bed72014-07-23 12:32:47 +00001041 Major = (getArch() == aarch64) ? 7 : 5;
Chad Rosierd84eaac2012-05-09 17:23:48 +00001042 break;
Tim Northover5e6fce62015-10-28 22:57:14 +00001043 case WatchOS:
1044 llvm_unreachable("conflicting triple info");
1045 }
1046}
1047
1048void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
1049 unsigned &Micro) const {
1050 switch (getOS()) {
1051 default: llvm_unreachable("unexpected OS for Darwin triple");
1052 case Darwin:
1053 case MacOSX:
1054 // Ignore the version from the triple. This is only handled because the
1055 // the clang driver combines OS X and IOS support into a common Darwin
1056 // toolchain that wants to know the iOS version number even when targeting
1057 // OS X.
1058 Major = 2;
1059 Minor = 0;
1060 Micro = 0;
1061 break;
1062 case WatchOS:
1063 getOSVersion(Major, Minor, Micro);
1064 if (Major == 0)
1065 Major = 2;
1066 break;
1067 case IOS:
1068 llvm_unreachable("conflicting triple info");
Chad Rosierd84eaac2012-05-09 17:23:48 +00001069 }
1070}
1071
Daniel Dunbar19e70762009-07-26 03:31:47 +00001072void Triple::setTriple(const Twine &Str) {
Chandler Carruth2d27b0f2012-02-21 03:39:36 +00001073 *this = Triple(Str);
Daniel Dunbar4abd5662009-04-01 21:53:23 +00001074}
1075
1076void Triple::setArch(ArchType Kind) {
1077 setArchName(getArchTypeName(Kind));
1078}
1079
1080void Triple::setVendor(VendorType Kind) {
1081 setVendorName(getVendorTypeName(Kind));
1082}
1083
1084void Triple::setOS(OSType Kind) {
1085 setOSName(getOSTypeName(Kind));
1086}
1087
Duncan Sands84a3bdd2010-09-16 08:25:48 +00001088void Triple::setEnvironment(EnvironmentType Kind) {
Reid Kleckner5fe405d2015-02-13 22:05:50 +00001089 if (ObjectFormat == getDefaultFormat(*this))
1090 return setEnvironmentName(getEnvironmentTypeName(Kind));
1091
1092 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1093 getObjectFormatTypeName(ObjectFormat)).str());
Duncan Sands84a3bdd2010-09-16 08:25:48 +00001094}
1095
Saleem Abdulrasool35476332014-03-06 20:47:11 +00001096void Triple::setObjectFormat(ObjectFormatType Kind) {
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +00001097 if (Environment == UnknownEnvironment)
1098 return setEnvironmentName(getObjectFormatTypeName(Kind));
1099
Benjamin Kramercccdadc2014-07-08 14:55:06 +00001100 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1101 getObjectFormatTypeName(Kind)).str());
Saleem Abdulrasool35476332014-03-06 20:47:11 +00001102}
1103
Daniel Dunbarad36e8a2009-11-06 10:58:06 +00001104void Triple::setArchName(StringRef Str) {
Jeffrey Yasskine2595b52009-10-06 21:45:26 +00001105 // Work around a miscompilation bug for Twines in gcc 4.0.3.
1106 SmallString<64> Triple;
1107 Triple += Str;
1108 Triple += "-";
1109 Triple += getVendorName();
1110 Triple += "-";
1111 Triple += getOSAndEnvironmentName();
Yaron Keren92e1b622015-03-18 10:17:07 +00001112 setTriple(Triple);
Daniel Dunbar4abd5662009-04-01 21:53:23 +00001113}
1114
Daniel Dunbarad36e8a2009-11-06 10:58:06 +00001115void Triple::setVendorName(StringRef Str) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +00001116 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1117}
1118
Daniel Dunbarad36e8a2009-11-06 10:58:06 +00001119void Triple::setOSName(StringRef Str) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +00001120 if (hasEnvironment())
1121 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1122 "-" + getEnvironmentName());
1123 else
1124 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1125}
1126
Daniel Dunbarad36e8a2009-11-06 10:58:06 +00001127void Triple::setEnvironmentName(StringRef Str) {
1128 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
Daniel Dunbar4abd5662009-04-01 21:53:23 +00001129 "-" + Str);
1130}
1131
Daniel Dunbarad36e8a2009-11-06 10:58:06 +00001132void Triple::setOSAndEnvironmentName(StringRef Str) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +00001133 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1134}
Chandler Carruthb90c1022012-01-31 04:52:32 +00001135
1136static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1137 switch (Arch) {
1138 case llvm::Triple::UnknownArch:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001139 return 0;
1140
Dylan McKayb1d469c2015-10-16 03:10:30 +00001141 case llvm::Triple::avr:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001142 case llvm::Triple::msp430:
1143 return 16;
1144
Chandler Carruthb90c1022012-01-31 04:52:32 +00001145 case llvm::Triple::arm:
Christian Pirker2a111602014-03-28 14:35:30 +00001146 case llvm::Triple::armeb:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001147 case llvm::Triple::hexagon:
1148 case llvm::Triple::le32:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001149 case llvm::Triple::mips:
1150 case llvm::Triple::mipsel:
Justin Holewinskiae556d32012-05-04 20:18:50 +00001151 case llvm::Triple::nvptx:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001152 case llvm::Triple::ppc:
Anton Korobeynikovf32638d2012-03-09 10:09:36 +00001153 case llvm::Triple::r600:
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001154 case llvm::Triple::riscv32:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001155 case llvm::Triple::sparc:
Douglas Katzmane0ff2822015-04-29 19:15:08 +00001156 case llvm::Triple::sparcel:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001157 case llvm::Triple::tce:
1158 case llvm::Triple::thumb:
Christian Pirker2a111602014-03-28 14:35:30 +00001159 case llvm::Triple::thumbeb:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001160 case llvm::Triple::x86:
1161 case llvm::Triple::xcore:
Matt Arsenault3f9b0212014-09-19 19:52:11 +00001162 case llvm::Triple::amdil:
1163 case llvm::Triple::hsail:
Guy Benyeia4d31a32012-11-15 10:35:47 +00001164 case llvm::Triple::spir:
Eric Christopher54fe1b22014-07-10 17:26:54 +00001165 case llvm::Triple::kalimba:
Jacques Pienaardbfe8702016-02-11 17:16:20 +00001166 case llvm::Triple::lanai:
Douglas Katzman1b5767f2015-06-12 18:31:38 +00001167 case llvm::Triple::shave:
Dan Gohman10e730a2015-06-29 23:51:55 +00001168 case llvm::Triple::wasm32:
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001169 case llvm::Triple::renderscript32:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001170 return 32;
1171
Tim Northovere0e3aef2013-01-31 12:12:40 +00001172 case llvm::Triple::aarch64:
Christian Pirker6c2f4d42014-02-24 11:34:50 +00001173 case llvm::Triple::aarch64_be:
Tom Stellard07f11602015-01-06 18:00:00 +00001174 case llvm::Triple::amdgcn:
Alexei Starovoitov8cf9a4c2015-06-05 16:11:14 +00001175 case llvm::Triple::bpfel:
1176 case llvm::Triple::bpfeb:
JF Bastien32972ef2014-09-12 17:54:17 +00001177 case llvm::Triple::le64:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001178 case llvm::Triple::mips64:
1179 case llvm::Triple::mips64el:
Justin Holewinskiae556d32012-05-04 20:18:50 +00001180 case llvm::Triple::nvptx64:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001181 case llvm::Triple::ppc64:
Bill Schmidt0a9170d2013-07-26 01:35:43 +00001182 case llvm::Triple::ppc64le:
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001183 case llvm::Triple::riscv64:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001184 case llvm::Triple::sparcv9:
Richard Sandiforda238c5e2013-05-03 11:05:17 +00001185 case llvm::Triple::systemz:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001186 case llvm::Triple::x86_64:
Matt Arsenault3f9b0212014-09-19 19:52:11 +00001187 case llvm::Triple::amdil64:
1188 case llvm::Triple::hsail64:
Guy Benyeia4d31a32012-11-15 10:35:47 +00001189 case llvm::Triple::spir64:
Dan Gohman10e730a2015-06-29 23:51:55 +00001190 case llvm::Triple::wasm64:
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001191 case llvm::Triple::renderscript64:
Chandler Carruthb90c1022012-01-31 04:52:32 +00001192 return 64;
1193 }
1194 llvm_unreachable("Invalid architecture value");
1195}
1196
1197bool Triple::isArch64Bit() const {
1198 return getArchPointerBitWidth(getArch()) == 64;
1199}
1200
1201bool Triple::isArch32Bit() const {
1202 return getArchPointerBitWidth(getArch()) == 32;
1203}
1204
1205bool Triple::isArch16Bit() const {
1206 return getArchPointerBitWidth(getArch()) == 16;
1207}
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001208
1209Triple Triple::get32BitArchVariant() const {
1210 Triple T(*this);
1211 switch (getArch()) {
1212 case Triple::UnknownArch:
Tom Stellard07f11602015-01-06 18:00:00 +00001213 case Triple::amdgcn:
Dylan McKayb1d469c2015-10-16 03:10:30 +00001214 case Triple::avr:
Alexei Starovoitov8cf9a4c2015-06-05 16:11:14 +00001215 case Triple::bpfel:
1216 case Triple::bpfeb:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001217 case Triple::msp430:
Richard Sandiforda238c5e2013-05-03 11:05:17 +00001218 case Triple::systemz:
Bill Schmidt0a9170d2013-07-26 01:35:43 +00001219 case Triple::ppc64le:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001220 T.setArch(UnknownArch);
1221 break;
1222
1223 case Triple::amdil:
Matt Arsenault3f9b0212014-09-19 19:52:11 +00001224 case Triple::hsail:
Micah Villmow48c8ddc2012-10-01 17:01:31 +00001225 case Triple::spir:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001226 case Triple::arm:
Christian Pirker2a111602014-03-28 14:35:30 +00001227 case Triple::armeb:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001228 case Triple::hexagon:
Eric Christopher54fe1b22014-07-10 17:26:54 +00001229 case Triple::kalimba:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001230 case Triple::le32:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001231 case Triple::mips:
1232 case Triple::mipsel:
Justin Holewinskiae556d32012-05-04 20:18:50 +00001233 case Triple::nvptx:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001234 case Triple::ppc:
Anton Korobeynikovf32638d2012-03-09 10:09:36 +00001235 case Triple::r600:
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001236 case Triple::riscv32:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001237 case Triple::sparc:
Douglas Katzmane0ff2822015-04-29 19:15:08 +00001238 case Triple::sparcel:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001239 case Triple::tce:
1240 case Triple::thumb:
Christian Pirker2a111602014-03-28 14:35:30 +00001241 case Triple::thumbeb:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001242 case Triple::x86:
1243 case Triple::xcore:
Jacques Pienaardbfe8702016-02-11 17:16:20 +00001244 case Triple::lanai:
Douglas Katzman1b5767f2015-06-12 18:31:38 +00001245 case Triple::shave:
Dan Gohman10e730a2015-06-29 23:51:55 +00001246 case Triple::wasm32:
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001247 case Triple::renderscript32:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001248 // Already 32-bit.
1249 break;
1250
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001251 case Triple::aarch64: T.setArch(Triple::arm); break;
1252 case Triple::aarch64_be: T.setArch(Triple::armeb); break;
1253 case Triple::le64: T.setArch(Triple::le32); break;
1254 case Triple::mips64: T.setArch(Triple::mips); break;
1255 case Triple::mips64el: T.setArch(Triple::mipsel); break;
1256 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
1257 case Triple::ppc64: T.setArch(Triple::ppc); break;
1258 case Triple::sparcv9: T.setArch(Triple::sparc); break;
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001259 case Triple::riscv64: T.setArch(Triple::riscv32); break;
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001260 case Triple::x86_64: T.setArch(Triple::x86); break;
1261 case Triple::amdil64: T.setArch(Triple::amdil); break;
1262 case Triple::hsail64: T.setArch(Triple::hsail); break;
1263 case Triple::spir64: T.setArch(Triple::spir); break;
1264 case Triple::wasm64: T.setArch(Triple::wasm32); break;
1265 case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001266 }
1267 return T;
1268}
1269
1270Triple Triple::get64BitArchVariant() const {
1271 Triple T(*this);
1272 switch (getArch()) {
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001273 case Triple::UnknownArch:
Dylan McKayb1d469c2015-10-16 03:10:30 +00001274 case Triple::avr:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001275 case Triple::hexagon:
Eric Christopher54fe1b22014-07-10 17:26:54 +00001276 case Triple::kalimba:
Jacques Pienaardbfe8702016-02-11 17:16:20 +00001277 case Triple::lanai:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001278 case Triple::msp430:
Anton Korobeynikovf32638d2012-03-09 10:09:36 +00001279 case Triple::r600:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001280 case Triple::tce:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001281 case Triple::xcore:
Douglas Katzmane0ff2822015-04-29 19:15:08 +00001282 case Triple::sparcel:
Douglas Katzman1b5767f2015-06-12 18:31:38 +00001283 case Triple::shave:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001284 T.setArch(UnknownArch);
1285 break;
1286
Tim Northovere0e3aef2013-01-31 12:12:40 +00001287 case Triple::aarch64:
Christian Pirker6c2f4d42014-02-24 11:34:50 +00001288 case Triple::aarch64_be:
Alexei Starovoitov8cf9a4c2015-06-05 16:11:14 +00001289 case Triple::bpfel:
1290 case Triple::bpfeb:
JF Bastien32972ef2014-09-12 17:54:17 +00001291 case Triple::le64:
Matt Arsenault3f9b0212014-09-19 19:52:11 +00001292 case Triple::amdil64:
Tom Stellard07f11602015-01-06 18:00:00 +00001293 case Triple::amdgcn:
Matt Arsenault3f9b0212014-09-19 19:52:11 +00001294 case Triple::hsail64:
1295 case Triple::spir64:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001296 case Triple::mips64:
1297 case Triple::mips64el:
Justin Holewinskiae556d32012-05-04 20:18:50 +00001298 case Triple::nvptx64:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001299 case Triple::ppc64:
Bill Schmidt0a9170d2013-07-26 01:35:43 +00001300 case Triple::ppc64le:
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001301 case Triple::riscv64:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001302 case Triple::sparcv9:
Richard Sandiforda238c5e2013-05-03 11:05:17 +00001303 case Triple::systemz:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001304 case Triple::x86_64:
Dan Gohman10e730a2015-06-29 23:51:55 +00001305 case Triple::wasm64:
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001306 case Triple::renderscript64:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001307 // Already 64-bit.
1308 break;
1309
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001310 case Triple::arm: T.setArch(Triple::aarch64); break;
1311 case Triple::armeb: T.setArch(Triple::aarch64_be); break;
1312 case Triple::le32: T.setArch(Triple::le64); break;
1313 case Triple::mips: T.setArch(Triple::mips64); break;
1314 case Triple::mipsel: T.setArch(Triple::mips64el); break;
1315 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
1316 case Triple::ppc: T.setArch(Triple::ppc64); break;
1317 case Triple::sparc: T.setArch(Triple::sparcv9); break;
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001318 case Triple::riscv32: T.setArch(Triple::riscv64); break;
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001319 case Triple::x86: T.setArch(Triple::x86_64); break;
1320 case Triple::amdil: T.setArch(Triple::amdil64); break;
1321 case Triple::hsail: T.setArch(Triple::hsail64); break;
1322 case Triple::spir: T.setArch(Triple::spir64); break;
1323 case Triple::thumb: T.setArch(Triple::aarch64); break;
1324 case Triple::thumbeb: T.setArch(Triple::aarch64_be); break;
1325 case Triple::wasm32: T.setArch(Triple::wasm64); break;
1326 case Triple::renderscript32: T.setArch(Triple::renderscript64); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +00001327 }
1328 return T;
1329}
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001330
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001331Triple Triple::getBigEndianArchVariant() const {
1332 Triple T(*this);
Davide Italiano901269c2016-06-29 20:01:39 +00001333 // Already big endian.
1334 if (!isLittleEndian())
1335 return T;
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001336 switch (getArch()) {
1337 case Triple::UnknownArch:
1338 case Triple::amdgcn:
1339 case Triple::amdil64:
1340 case Triple::amdil:
Dylan McKayb1d469c2015-10-16 03:10:30 +00001341 case Triple::avr:
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001342 case Triple::hexagon:
1343 case Triple::hsail64:
1344 case Triple::hsail:
1345 case Triple::kalimba:
1346 case Triple::le32:
1347 case Triple::le64:
1348 case Triple::msp430:
1349 case Triple::nvptx64:
1350 case Triple::nvptx:
1351 case Triple::r600:
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001352 case Triple::riscv32:
1353 case Triple::riscv64:
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001354 case Triple::shave:
1355 case Triple::spir64:
1356 case Triple::spir:
1357 case Triple::wasm32:
1358 case Triple::wasm64:
1359 case Triple::x86:
1360 case Triple::x86_64:
1361 case Triple::xcore:
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001362 case Triple::renderscript32:
1363 case Triple::renderscript64:
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001364
1365 // ARM is intentionally unsupported here, changing the architecture would
1366 // drop any arch suffixes.
1367 case Triple::arm:
1368 case Triple::thumb:
1369 T.setArch(UnknownArch);
1370 break;
1371
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001372 case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1373 case Triple::bpfel: T.setArch(Triple::bpfeb); break;
1374 case Triple::mips64el:T.setArch(Triple::mips64); break;
1375 case Triple::mipsel: T.setArch(Triple::mips); break;
1376 case Triple::ppc64le: T.setArch(Triple::ppc64); break;
1377 case Triple::sparcel: T.setArch(Triple::sparc); break;
Davide Italiano901269c2016-06-29 20:01:39 +00001378 default:
1379 llvm_unreachable("getBigEndianArchVariant: unknown triple.");
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001380 }
1381 return T;
1382}
1383
1384Triple Triple::getLittleEndianArchVariant() const {
1385 Triple T(*this);
Davide Italiano901269c2016-06-29 20:01:39 +00001386 if (isLittleEndian())
1387 return T;
1388
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001389 switch (getArch()) {
1390 case Triple::UnknownArch:
Jacques Pienaardbfe8702016-02-11 17:16:20 +00001391 case Triple::lanai:
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001392 case Triple::ppc:
1393 case Triple::sparcv9:
1394 case Triple::systemz:
1395 case Triple::tce:
1396
1397 // ARM is intentionally unsupported here, changing the architecture would
1398 // drop any arch suffixes.
1399 case Triple::armeb:
1400 case Triple::thumbeb:
1401 T.setArch(UnknownArch);
1402 break;
1403
Davide Italiano901269c2016-06-29 20:01:39 +00001404 case Triple::aarch64_be: T.setArch(Triple::aarch64); break;
1405 case Triple::bpfeb: T.setArch(Triple::bpfel); break;
1406 case Triple::mips64: T.setArch(Triple::mips64el); break;
1407 case Triple::mips: T.setArch(Triple::mipsel); break;
1408 case Triple::ppc64: T.setArch(Triple::ppc64le); break;
1409 case Triple::sparc: T.setArch(Triple::sparcel); break;
1410 default:
1411 llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
1412 }
1413 return T;
1414}
1415
1416bool Triple::isLittleEndian() const {
1417 switch (getArch()) {
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001418 case Triple::aarch64:
1419 case Triple::amdgcn:
1420 case Triple::amdil64:
1421 case Triple::amdil:
1422 case Triple::arm:
Dylan McKayb1d469c2015-10-16 03:10:30 +00001423 case Triple::avr:
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001424 case Triple::bpfel:
1425 case Triple::hexagon:
1426 case Triple::hsail64:
1427 case Triple::hsail:
1428 case Triple::kalimba:
1429 case Triple::le32:
1430 case Triple::le64:
1431 case Triple::mips64el:
1432 case Triple::mipsel:
1433 case Triple::msp430:
1434 case Triple::nvptx64:
1435 case Triple::nvptx:
1436 case Triple::ppc64le:
1437 case Triple::r600:
Alex Bradburyb6e784a2016-11-01 16:47:54 +00001438 case Triple::riscv32:
1439 case Triple::riscv64:
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001440 case Triple::shave:
1441 case Triple::sparcel:
1442 case Triple::spir64:
1443 case Triple::spir:
1444 case Triple::thumb:
1445 case Triple::wasm32:
1446 case Triple::wasm64:
1447 case Triple::x86:
1448 case Triple::x86_64:
1449 case Triple::xcore:
Pirama Arumuga Nainar9c3aec22016-07-02 00:23:09 +00001450 case Triple::renderscript32:
1451 case Triple::renderscript64:
Davide Italiano901269c2016-06-29 20:01:39 +00001452 return true;
1453 default:
1454 return false;
Benjamin Kramer4ea14a62015-07-06 23:58:14 +00001455 }
Davide Italiano941685e2016-06-29 01:56:27 +00001456}
1457
Chandler Carruth3309ef62015-08-30 07:51:04 +00001458StringRef Triple::getARMCPUForArch(StringRef MArch) const {
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001459 if (MArch.empty())
1460 MArch = getArchName();
Chandler Carruthbb47b9a2015-08-30 02:09:48 +00001461 MArch = ARM::getCanonicalArchName(MArch);
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001462
Renato Goline8048f02015-05-20 15:05:07 +00001463 // Some defaults are forced.
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001464 switch (getOS()) {
Ed Masteea0257a2014-09-09 17:47:24 +00001465 case llvm::Triple::FreeBSD:
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001466 case llvm::Triple::NetBSD:
Renato Golin66b682a2015-05-27 19:49:53 +00001467 if (!MArch.empty() && MArch == "v6")
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001468 return "arm1176jzf-s";
1469 break;
1470 case llvm::Triple::Win32:
1471 // FIXME: this is invalid for WindowsCE
1472 return "cortex-a9";
Artyom Skrobov7f0fc9c2015-11-20 16:46:14 +00001473 case llvm::Triple::MacOSX:
1474 case llvm::Triple::IOS:
1475 case llvm::Triple::WatchOS:
Tim Northover94bdbd02016-02-11 23:49:08 +00001476 case llvm::Triple::TvOS:
Artyom Skrobov7f0fc9c2015-11-20 16:46:14 +00001477 if (MArch == "v7k")
1478 return "cortex-a7";
1479 break;
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001480 default:
1481 break;
1482 }
1483
Renato Goline8048f02015-05-20 15:05:07 +00001484 if (MArch.empty())
Chandler Carruth3309ef62015-08-30 07:51:04 +00001485 return StringRef();
John Brawn50ed9472015-05-08 12:52:02 +00001486
Chandler Carruth3309ef62015-08-30 07:51:04 +00001487 StringRef CPU = ARM::getDefaultCPU(MArch);
1488 if (!CPU.empty())
Renato Goline8048f02015-05-20 15:05:07 +00001489 return CPU;
1490
1491 // If no specific architecture version is requested, return the minimum CPU
1492 // required by the OS and environment.
1493 switch (getOS()) {
1494 case llvm::Triple::NetBSD:
1495 switch (getEnvironment()) {
1496 case llvm::Triple::GNUEABIHF:
1497 case llvm::Triple::GNUEABI:
1498 case llvm::Triple::EABIHF:
1499 case llvm::Triple::EABI:
1500 return "arm926ej-s";
John Brawn50ed9472015-05-08 12:52:02 +00001501 default:
Renato Goline8048f02015-05-20 15:05:07 +00001502 return "strongarm";
John Brawn50ed9472015-05-08 12:52:02 +00001503 }
Renato Goline8048f02015-05-20 15:05:07 +00001504 case llvm::Triple::NaCl:
1505 return "cortex-a8";
1506 default:
1507 switch (getEnvironment()) {
1508 case llvm::Triple::EABIHF:
1509 case llvm::Triple::GNUEABIHF:
Rafael Espindolaa895a0c2016-06-24 21:14:33 +00001510 case llvm::Triple::MuslEABIHF:
Renato Goline8048f02015-05-20 15:05:07 +00001511 return "arm1176jzf-s";
1512 default:
1513 return "arm7tdmi";
1514 }
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001515 }
John Brawn50ed9472015-05-08 12:52:02 +00001516
Renato Goline8048f02015-05-20 15:05:07 +00001517 llvm_unreachable("invalid arch name");
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +00001518}