Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / a3b594c480166f4c91ee488d85cfc4767566fee7 / . / llvm / lib / Support / Triple.cpp
blob: d4b150a6cb18fc1c70412e595b1f17154cdbcb98 [file] [log] [blame]
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]1//===--- Triple.cpp - Target triple helper class --------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/ADT/Triple.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +0000[diff] [blame]11#include "llvm/ADT/STLExtras.h"
Jeffrey Yasskine2595b52009-10-06 21:45:26 +0000[diff] [blame]12#include "llvm/ADT/SmallString.h"
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]13#include "llvm/ADT/StringSwitch.h"
David Blaikie46a9f012012-01-20 21:51:11 +0000[diff] [blame]14#include "llvm/Support/ErrorHandling.h"
Mikhail Glushenkov12062ba2009-04-02 01:11:37 +0000[diff] [blame]15#include <cstring>
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]16using namespace llvm;
17
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]18const char *Triple::getArchTypeName(ArchType Kind) {
19 switch (Kind) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]20 case UnknownArch: return "unknown";
Jim Grosbachf638b262010-12-17 02:10:59 +0000[diff] [blame]21
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]22 case aarch64: return "aarch64";
23 case aarch64_be: return "aarch64_be";
24 case arm: return "arm";
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]25 case armeb: return "armeb";
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000[diff] [blame]26 case bpf: return "bpf";
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]27 case hexagon: return "hexagon";
28 case mips: return "mips";
29 case mipsel: return "mipsel";
30 case mips64: return "mips64";
31 case mips64el: return "mips64el";
32 case msp430: return "msp430";
33 case ppc64: return "powerpc64";
34 case ppc64le: return "powerpc64le";
35 case ppc: return "powerpc";
36 case r600: return "r600";
Tom Stellard07f11602015-01-06 18:00:00 +0000[diff] [blame]37 case amdgcn: return "amdgcn";
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]38 case sparc: return "sparc";
39 case sparcv9: return "sparcv9";
40 case systemz: return "s390x";
41 case tce: return "tce";
42 case thumb: return "thumb";
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]43 case thumbeb: return "thumbeb";
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]44 case x86: return "i386";
45 case x86_64: return "x86_64";
46 case xcore: return "xcore";
47 case nvptx: return "nvptx";
48 case nvptx64: return "nvptx64";
49 case le32: return "le32";
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]50 case le64: return "le64";
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]51 case amdil: return "amdil";
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]52 case amdil64: return "amdil64";
53 case hsail: return "hsail";
54 case hsail64: return "hsail64";
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]55 case spir: return "spir";
56 case spir64: return "spir64";
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]57 case kalimba: return "kalimba";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]58 }
59
David Blaikie46a9f012012-01-20 21:51:11 +0000[diff] [blame]60 llvm_unreachable("Invalid ArchType!");
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]61}
62
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]63const char *Triple::getArchTypePrefix(ArchType Kind) {
64 switch (Kind) {
65 default:
Craig Topperc10719f2014-04-07 04:17:22 +0000[diff] [blame]66 return nullptr;
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]67
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]68 case aarch64:
69 case aarch64_be: return "aarch64";
Tim Northovere0e3aef2013-01-31 12:12:40 +0000[diff] [blame]70
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]71 case arm:
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]72 case armeb:
73 case thumb:
74 case thumbeb: return "arm";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]75
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]76 case ppc64:
Bill Schmidt0a9170d2013-07-26 01:35:43 +0000[diff] [blame]77 case ppc64le:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]78 case ppc: return "ppc";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]79
Benjamin Kramerae3c3002012-06-28 19:09:53 +0000[diff] [blame]80 case mips:
81 case mipsel:
82 case mips64:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]83 case mips64el: return "mips";
Benjamin Kramerae3c3002012-06-28 19:09:53 +0000[diff] [blame]84
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]85 case hexagon: return "hexagon";
Tony Linthicum1213a7a2011-12-12 21:14:40 +0000[diff] [blame]86
Tom Stellard07f11602015-01-06 18:00:00 +0000[diff] [blame]87 case amdgcn:
88 case r600: return "amdgpu";
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000[diff] [blame]89
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000[diff] [blame]90 case bpf: return "bpf";
91
Chris Lattner8228b112010-02-04 06:34:01 +0000[diff] [blame]92 case sparcv9:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]93 case sparc: return "sparc";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]94
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]95 case systemz: return "systemz";
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000[diff] [blame]96
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]97 case x86:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]98 case x86_64: return "x86";
Nick Lewycky4c82c6c2010-09-07 18:14:24 +0000[diff] [blame]99
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]100 case xcore: return "xcore";
Nick Lewycky4c82c6c2010-09-07 18:14:24 +0000[diff] [blame]101
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]102 case nvptx: return "nvptx";
103 case nvptx64: return "nvptx";
Tim Northover00ed9962014-03-29 10:18:08 +0000[diff] [blame]104
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]105 case le32: return "le32";
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]106 case le64: return "le64";
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]107
108 case amdil:
109 case amdil64: return "amdil";
110
111 case hsail:
112 case hsail64: return "hsail";
113
114 case spir:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]115 case spir64: return "spir";
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]116 case kalimba: return "kalimba";
Daniel Dunbarb8dc4ea2009-08-24 09:53:06 +0000[diff] [blame]117 }
118}
119
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]120const char *Triple::getVendorTypeName(VendorType Kind) {
121 switch (Kind) {
122 case UnknownVendor: return "unknown";
123
124 case Apple: return "apple";
Chris Lattner07921952009-08-14 18:48:13 +0000[diff] [blame]125 case PC: return "pc";
John Thompsond0332e42011-03-15 21:51:56 +0000[diff] [blame]126 case SCEI: return "scei";
Hal Finkelf208af02012-04-02 18:31:33 +0000[diff] [blame]127 case BGP: return "bgp";
128 case BGQ: return "bgq";
Hal Finkelb5d177e2012-08-28 02:10:30 +0000[diff] [blame]129 case Freescale: return "fsl";
Duncan Sandsd5772de2012-10-12 11:08:57 +0000[diff] [blame]130 case IBM: return "ibm";
Daniel Sandersc5626f42014-07-09 16:03:10 +0000[diff] [blame]131 case ImaginationTechnologies: return "img";
Daniel Sandersdc6a9412014-07-18 14:28:19 +0000[diff] [blame]132 case MipsTechnologies: return "mti";
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000[diff] [blame]133 case NVIDIA: return "nvidia";
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]134 case CSR: return "csr";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]135 }
136
David Blaikie46a9f012012-01-20 21:51:11 +0000[diff] [blame]137 llvm_unreachable("Invalid VendorType!");
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]138}
139
140const char *Triple::getOSTypeName(OSType Kind) {
141 switch (Kind) {
142 case UnknownOS: return "unknown";
143
Ed Schoutendae71892015-03-09 18:40:45 +0000[diff] [blame]144 case CloudABI: return "cloudabi";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]145 case Darwin: return "darwin";
Daniel Dunbare3384c42009-05-22 02:24:11 +0000[diff] [blame]146 case DragonFly: return "dragonfly";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]147 case FreeBSD: return "freebsd";
Daniel Dunbard74bac72011-04-19 20:19:27 +0000[diff] [blame]148 case IOS: return "ios";
Duncan Sandsfe44f672011-07-26 15:30:04 +0000[diff] [blame]149 case KFreeBSD: return "kfreebsd";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]150 case Linux: return "linux";
Edward O'Callaghanba993b82009-11-19 11:59:00 +0000[diff] [blame]151 case Lv2: return "lv2";
Daniel Dunbar0854f342011-04-19 23:34:12 +0000[diff] [blame]152 case MacOSX: return "macosx";
Chris Lattner01218d52009-07-13 20:22:23 +0000[diff] [blame]153 case NetBSD: return "netbsd";
Duncan Sands14814d42009-06-29 13:36:13 +0000[diff] [blame]154 case OpenBSD: return "openbsd";
Daniel Dunbar781f94d2009-08-18 04:43:27 +0000[diff] [blame]155 case Solaris: return "solaris";
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]156 case Win32: return "windows";
Chris Lattner27f20492009-10-16 02:06:30 +0000[diff] [blame]157 case Haiku: return "haiku";
Chris Lattnerca97c922010-07-07 15:52:27 +0000[diff] [blame]158 case Minix: return "minix";
Douglas Gregorde3c9262011-07-01 22:41:06 +0000[diff] [blame]159 case RTEMS: return "rtems";
Eli Benderskyabe54632012-12-04 18:37:26 +0000[diff] [blame]160 case NaCl: return "nacl";
Hal Finkelf208af02012-04-02 18:31:33 +0000[diff] [blame]161 case CNK: return "cnk";
Eric Christopher22738d02012-08-06 20:52:18 +0000[diff] [blame]162 case Bitrig: return "bitrig";
Duncan Sandsd5772de2012-10-12 11:08:57 +0000[diff] [blame]163 case AIX: return "aix";
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000[diff] [blame]164 case CUDA: return "cuda";
165 case NVCL: return "nvcl";
Tom Stellard4082a6c2014-12-02 16:45:47 +0000[diff] [blame]166 case AMDHSA: return "amdhsa";
Alex Rosenberg38babd12015-01-25 22:46:59 +0000[diff] [blame]167 case PS4: return "ps4";
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]168 }
169
David Blaikie46a9f012012-01-20 21:51:11 +0000[diff] [blame]170 llvm_unreachable("Invalid OSType");
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]171}
172
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]173const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
174 switch (Kind) {
175 case UnknownEnvironment: return "unknown";
Renato Golin83758d5c2011-01-21 18:25:47 +0000[diff] [blame]176 case GNU: return "gnu";
Rafael Espindolaf5e78fa2012-01-18 23:35:29 +0000[diff] [blame]177 case GNUEABIHF: return "gnueabihf";
Renato Golin83758d5c2011-01-21 18:25:47 +0000[diff] [blame]178 case GNUEABI: return "gnueabi";
Eli Bendersky0893e102013-01-22 18:02:49 +0000[diff] [blame]179 case GNUX32: return "gnux32";
David Woodhouse71d15ed2014-01-20 12:02:25 +0000[diff] [blame]180 case CODE16: return "code16";
Renato Golin83758d5c2011-01-21 18:25:47 +0000[diff] [blame]181 case EABI: return "eabi";
Joerg Sonnenberger8fe41b72013-12-16 18:51:28 +0000[diff] [blame]182 case EABIHF: return "eabihf";
Logan Chien9ab55b82012-09-02 09:29:46 +0000[diff] [blame]183 case Android: return "android";
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]184 case MSVC: return "msvc";
185 case Itanium: return "itanium";
186 case Cygnus: return "cygnus";
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]187 }
188
David Blaikie46a9f012012-01-20 21:51:11 +0000[diff] [blame]189 llvm_unreachable("Invalid EnvironmentType!");
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]190}
191
Daniel Dunbarad36e8a2009-11-06 10:58:06 +0000[diff] [blame]192Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]193 return StringSwitch<Triple::ArchType>(Name)
Tim Northovere0e3aef2013-01-31 12:12:40 +0000[diff] [blame]194 .Case("aarch64", aarch64)
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]195 .Case("aarch64_be", aarch64_be)
Tim Northovere19bed72014-07-23 12:32:47 +0000[diff] [blame]196 .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]197 .Case("arm", arm)
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]198 .Case("armeb", armeb)
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000[diff] [blame]199 .Case("bpf", bpf)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]200 .Case("mips", mips)
201 .Case("mipsel", mipsel)
202 .Case("mips64", mips64)
203 .Case("mips64el", mips64el)
204 .Case("msp430", msp430)
205 .Case("ppc64", ppc64)
206 .Case("ppc32", ppc)
207 .Case("ppc", ppc)
Bill Schmidt0a9170d2013-07-26 01:35:43 +0000[diff] [blame]208 .Case("ppc64le", ppc64le)
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000[diff] [blame]209 .Case("r600", r600)
Tom Stellard07f11602015-01-06 18:00:00 +0000[diff] [blame]210 .Case("amdgcn", amdgcn)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]211 .Case("hexagon", hexagon)
212 .Case("sparc", sparc)
213 .Case("sparcv9", sparcv9)
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000[diff] [blame]214 .Case("systemz", systemz)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]215 .Case("tce", tce)
216 .Case("thumb", thumb)
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]217 .Case("thumbeb", thumbeb)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]218 .Case("x86", x86)
219 .Case("x86-64", x86_64)
220 .Case("xcore", xcore)
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]221 .Case("nvptx", nvptx)
222 .Case("nvptx64", nvptx64)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]223 .Case("le32", le32)
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]224 .Case("le64", le64)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]225 .Case("amdil", amdil)
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]226 .Case("amdil64", amdil64)
227 .Case("hsail", hsail)
228 .Case("hsail64", hsail64)
Micah Villmow48c8ddc2012-10-01 17:01:31 +0000[diff] [blame]229 .Case("spir", spir)
Guy Benyeia4d31a32012-11-15 10:35:47 +0000[diff] [blame]230 .Case("spir64", spir64)
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]231 .Case("kalimba", kalimba)
Chandler Carruthff6f3562012-02-12 09:27:38 +0000[diff] [blame]232 .Default(UnknownArch);
Daniel Dunbar0f16ea52009-08-03 04:03:51 +0000[diff] [blame]233}
234
Renato Golin609bf922014-11-17 14:08:57 +0000[diff] [blame]235static Triple::ArchType parseARMArch(StringRef ArchName) {
236 size_t offset = StringRef::npos;
237 Triple::ArchType arch = Triple::UnknownArch;
238 bool isThumb = ArchName.startswith("thumb");
239
240 if (ArchName.equals("arm"))
241 return Triple::arm;
242 if (ArchName.equals("armeb"))
243 return Triple::armeb;
244 if (ArchName.equals("thumb"))
245 return Triple::thumb;
246 if (ArchName.equals("thumbeb"))
247 return Triple::thumbeb;
248 if (ArchName.equals("arm64") || ArchName.equals("aarch64"))
249 return Triple::aarch64;
250 if (ArchName.equals("aarch64_be"))
251 return Triple::aarch64_be;
252
253 if (ArchName.startswith("armv")) {
254 offset = 3;
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000[diff] [blame]255 if (ArchName.endswith("eb")) {
256 arch = Triple::armeb;
257 ArchName = ArchName.substr(0, ArchName.size() - 2);
258 } else
259 arch = Triple::arm;
Renato Golin609bf922014-11-17 14:08:57 +0000[diff] [blame]260 } else if (ArchName.startswith("armebv")) {
261 offset = 5;
262 arch = Triple::armeb;
263 } else if (ArchName.startswith("thumbv")) {
264 offset = 5;
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000[diff] [blame]265 if (ArchName.endswith("eb")) {
266 arch = Triple::thumbeb;
267 ArchName = ArchName.substr(0, ArchName.size() - 2);
268 } else
269 arch = Triple::thumb;
Renato Golin609bf922014-11-17 14:08:57 +0000[diff] [blame]270 } else if (ArchName.startswith("thumbebv")) {
271 offset = 7;
272 arch = Triple::thumbeb;
273 }
274 return StringSwitch<Triple::ArchType>(ArchName.substr(offset))
275 .Cases("v2", "v2a", isThumb ? Triple::UnknownArch : arch)
276 .Cases("v3", "v3m", isThumb ? Triple::UnknownArch : arch)
277 .Cases("v4", "v4t", arch)
278 .Cases("v5", "v5e", "v5t", "v5te", "v5tej", arch)
Bradley Smithe997b452015-02-10 15:15:08 +0000[diff] [blame]279 .Cases("v6", "v6j", "v6k", "v6m", "v6sm", arch)
Renato Golin609bf922014-11-17 14:08:57 +0000[diff] [blame]280 .Cases("v6t2", "v6z", "v6zk", arch)
281 .Cases("v7", "v7a", "v7em", "v7l", arch)
282 .Cases("v7m", "v7r", "v7s", arch)
283 .Cases("v8", "v8a", arch)
Vladimir Sukharevc632cda2015-03-26 17:05:54 +0000[diff] [blame]284 .Cases("v8.1", "v8.1a", arch)
Renato Golin609bf922014-11-17 14:08:57 +0000[diff] [blame]285 .Default(Triple::UnknownArch);
286}
287
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]288static Triple::ArchType parseArch(StringRef ArchName) {
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000[diff] [blame]289 Triple::ArchType ARMArch(parseARMArch(ArchName));
290
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]291 return StringSwitch<Triple::ArchType>(ArchName)
292 .Cases("i386", "i486", "i586", "i686", Triple::x86)
293 // FIXME: Do we need to support these?
294 .Cases("i786", "i886", "i986", Triple::x86)
Jim Grosbach664d1482013-11-16 00:52:57 +0000[diff] [blame]295 .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]296 .Case("powerpc", Triple::ppc)
297 .Cases("powerpc64", "ppu", Triple::ppc64)
Bill Schmidt0a9170d2013-07-26 01:35:43 +0000[diff] [blame]298 .Case("powerpc64le", Triple::ppc64le)
Renato Golin609bf922014-11-17 14:08:57 +0000[diff] [blame]299 .Case("xscale", Triple::arm)
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000[diff] [blame]300 .Case("xscaleeb", Triple::armeb)
301 .StartsWith("arm", ARMArch)
302 .StartsWith("thumb", ARMArch)
303 .StartsWith("aarch64", ARMArch)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]304 .Case("msp430", Triple::msp430)
305 .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
Chandler Carruth0c7a7cc2012-02-22 11:32:54 +0000[diff] [blame]306 .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]307 .Cases("mips64", "mips64eb", Triple::mips64)
308 .Case("mips64el", Triple::mips64el)
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000[diff] [blame]309 .Case("r600", Triple::r600)
Tom Stellard07f11602015-01-06 18:00:00 +0000[diff] [blame]310 .Case("amdgcn", Triple::amdgcn)
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000[diff] [blame]311 .Case("bpf", Triple::bpf)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]312 .Case("hexagon", Triple::hexagon)
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000[diff] [blame]313 .Case("s390x", Triple::systemz)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]314 .Case("sparc", Triple::sparc)
Jakob Stoklund Olesenabc3d232013-05-14 17:47:27 +0000[diff] [blame]315 .Cases("sparcv9", "sparc64", Triple::sparcv9)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]316 .Case("tce", Triple::tce)
317 .Case("xcore", Triple::xcore)
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]318 .Case("nvptx", Triple::nvptx)
319 .Case("nvptx64", Triple::nvptx64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]320 .Case("le32", Triple::le32)
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]321 .Case("le64", Triple::le64)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]322 .Case("amdil", Triple::amdil)
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]323 .Case("amdil64", Triple::amdil64)
324 .Case("hsail", Triple::hsail)
325 .Case("hsail64", Triple::hsail64)
Micah Villmow48c8ddc2012-10-01 17:01:31 +0000[diff] [blame]326 .Case("spir", Triple::spir)
Guy Benyeia4d31a32012-11-15 10:35:47 +0000[diff] [blame]327 .Case("spir64", Triple::spir64)
Matthew Gardiner3b15a892014-09-05 06:46:43 +0000[diff] [blame]328 .StartsWith("kalimba", Triple::kalimba)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]329 .Default(Triple::UnknownArch);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]330}
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]331
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]332static Triple::VendorType parseVendor(StringRef VendorName) {
333 return StringSwitch<Triple::VendorType>(VendorName)
334 .Case("apple", Triple::Apple)
335 .Case("pc", Triple::PC)
336 .Case("scei", Triple::SCEI)
Hal Finkelf208af02012-04-02 18:31:33 +0000[diff] [blame]337 .Case("bgp", Triple::BGP)
338 .Case("bgq", Triple::BGQ)
Hal Finkelb5d177e2012-08-28 02:10:30 +0000[diff] [blame]339 .Case("fsl", Triple::Freescale)
Duncan Sandsd5772de2012-10-12 11:08:57 +0000[diff] [blame]340 .Case("ibm", Triple::IBM)
Daniel Sandersc5626f42014-07-09 16:03:10 +0000[diff] [blame]341 .Case("img", Triple::ImaginationTechnologies)
Daniel Sandersdc6a9412014-07-18 14:28:19 +0000[diff] [blame]342 .Case("mti", Triple::MipsTechnologies)
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000[diff] [blame]343 .Case("nvidia", Triple::NVIDIA)
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]344 .Case("csr", Triple::CSR)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]345 .Default(Triple::UnknownVendor);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]346}
347
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]348static Triple::OSType parseOS(StringRef OSName) {
349 return StringSwitch<Triple::OSType>(OSName)
Ed Schoutendae71892015-03-09 18:40:45 +0000[diff] [blame]350 .StartsWith("cloudabi", Triple::CloudABI)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]351 .StartsWith("darwin", Triple::Darwin)
352 .StartsWith("dragonfly", Triple::DragonFly)
353 .StartsWith("freebsd", Triple::FreeBSD)
354 .StartsWith("ios", Triple::IOS)
355 .StartsWith("kfreebsd", Triple::KFreeBSD)
356 .StartsWith("linux", Triple::Linux)
357 .StartsWith("lv2", Triple::Lv2)
358 .StartsWith("macosx", Triple::MacOSX)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]359 .StartsWith("netbsd", Triple::NetBSD)
360 .StartsWith("openbsd", Triple::OpenBSD)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]361 .StartsWith("solaris", Triple::Solaris)
362 .StartsWith("win32", Triple::Win32)
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]363 .StartsWith("windows", Triple::Win32)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]364 .StartsWith("haiku", Triple::Haiku)
365 .StartsWith("minix", Triple::Minix)
366 .StartsWith("rtems", Triple::RTEMS)
Eli Benderskyabe54632012-12-04 18:37:26 +0000[diff] [blame]367 .StartsWith("nacl", Triple::NaCl)
Hal Finkelf208af02012-04-02 18:31:33 +0000[diff] [blame]368 .StartsWith("cnk", Triple::CNK)
Eric Christopher22738d02012-08-06 20:52:18 +0000[diff] [blame]369 .StartsWith("bitrig", Triple::Bitrig)
Duncan Sandsd5772de2012-10-12 11:08:57 +0000[diff] [blame]370 .StartsWith("aix", Triple::AIX)
Justin Holewinskib6e6cd32013-06-21 18:51:49 +0000[diff] [blame]371 .StartsWith("cuda", Triple::CUDA)
372 .StartsWith("nvcl", Triple::NVCL)
Tom Stellard4082a6c2014-12-02 16:45:47 +0000[diff] [blame]373 .StartsWith("amdhsa", Triple::AMDHSA)
Alex Rosenberg38babd12015-01-25 22:46:59 +0000[diff] [blame]374 .StartsWith("ps4", Triple::PS4)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]375 .Default(Triple::UnknownOS);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]376}
377
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]378static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
379 return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
Joerg Sonnenberger8fe41b72013-12-16 18:51:28 +0000[diff] [blame]380 .StartsWith("eabihf", Triple::EABIHF)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]381 .StartsWith("eabi", Triple::EABI)
382 .StartsWith("gnueabihf", Triple::GNUEABIHF)
383 .StartsWith("gnueabi", Triple::GNUEABI)
Eli Bendersky0893e102013-01-22 18:02:49 +0000[diff] [blame]384 .StartsWith("gnux32", Triple::GNUX32)
David Woodhouse71d15ed2014-01-20 12:02:25 +0000[diff] [blame]385 .StartsWith("code16", Triple::CODE16)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]386 .StartsWith("gnu", Triple::GNU)
Logan Chien9ab55b82012-09-02 09:29:46 +0000[diff] [blame]387 .StartsWith("android", Triple::Android)
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]388 .StartsWith("msvc", Triple::MSVC)
389 .StartsWith("itanium", Triple::Itanium)
390 .StartsWith("cygnus", Triple::Cygnus)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]391 .Default(Triple::UnknownEnvironment);
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]392}
393
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]394static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
395 return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
396 .EndsWith("coff", Triple::COFF)
397 .EndsWith("elf", Triple::ELF)
398 .EndsWith("macho", Triple::MachO)
399 .Default(Triple::UnknownObjectFormat);
400}
401
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]402static Triple::SubArchType parseSubArch(StringRef SubArchName) {
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000[diff] [blame]403 if (SubArchName.endswith("eb"))
404 SubArchName = SubArchName.substr(0, SubArchName.size() - 2);
405
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]406 return StringSwitch<Triple::SubArchType>(SubArchName)
Vladimir Sukharevc632cda2015-03-26 17:05:54 +0000[diff] [blame]407 .EndsWith("v8.1a", Triple::ARMSubArch_v8_1a)
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]408 .EndsWith("v8", Triple::ARMSubArch_v8)
409 .EndsWith("v8a", Triple::ARMSubArch_v8)
410 .EndsWith("v7", Triple::ARMSubArch_v7)
411 .EndsWith("v7a", Triple::ARMSubArch_v7)
412 .EndsWith("v7em", Triple::ARMSubArch_v7em)
413 .EndsWith("v7l", Triple::ARMSubArch_v7)
414 .EndsWith("v7m", Triple::ARMSubArch_v7m)
415 .EndsWith("v7r", Triple::ARMSubArch_v7)
416 .EndsWith("v7s", Triple::ARMSubArch_v7s)
417 .EndsWith("v6", Triple::ARMSubArch_v6)
418 .EndsWith("v6m", Triple::ARMSubArch_v6m)
Bradley Smithe997b452015-02-10 15:15:08 +0000[diff] [blame]419 .EndsWith("v6sm", Triple::ARMSubArch_v6m)
Renato Golin12350602015-03-17 11:55:28 +0000[diff] [blame]420 .EndsWith("v6k", Triple::ARMSubArch_v6k)
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]421 .EndsWith("v6t2", Triple::ARMSubArch_v6t2)
422 .EndsWith("v5", Triple::ARMSubArch_v5)
423 .EndsWith("v5e", Triple::ARMSubArch_v5)
424 .EndsWith("v5t", Triple::ARMSubArch_v5)
425 .EndsWith("v5te", Triple::ARMSubArch_v5te)
426 .EndsWith("v4t", Triple::ARMSubArch_v4t)
Matthew Gardiner3b15a892014-09-05 06:46:43 +0000[diff] [blame]427 .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
428 .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
429 .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]430 .Default(Triple::NoSubArch);
431}
432
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]433static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
434 switch (Kind) {
435 case Triple::UnknownObjectFormat: return "";
436 case Triple::COFF: return "coff";
437 case Triple::ELF: return "elf";
438 case Triple::MachO: return "macho";
439 }
440 llvm_unreachable("unknown object format type");
441}
442
443static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
Rafael Espindola24254892015-03-18 22:19:16 +0000[diff] [blame]444 switch (T.getArch()) {
445 default:
446 break;
447 case Triple::hexagon:
448 case Triple::mips:
449 case Triple::mipsel:
450 case Triple::mips64:
451 case Triple::mips64el:
452 case Triple::r600:
453 case Triple::amdgcn:
454 case Triple::sparc:
455 case Triple::sparcv9:
456 case Triple::systemz:
457 case Triple::xcore:
Rafael Espindola7f454402015-03-19 02:40:56 +0000[diff] [blame]458 case Triple::ppc64le:
459 return Triple::ELF;
460
461 case Triple::ppc:
462 case Triple::ppc64:
463 if (T.isOSDarwin())
464 return Triple::MachO;
Rafael Espindola24254892015-03-18 22:19:16 +0000[diff] [blame]465 return Triple::ELF;
466 }
467
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]468 if (T.isOSDarwin())
469 return Triple::MachO;
470 else if (T.isOSWindows())
471 return Triple::COFF;
472 return Triple::ELF;
473}
474
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000[diff] [blame]475/// \brief Construct a triple from the string representation provided.
476///
Chandler Carruth1f3325a2012-02-21 08:31:18 +0000[diff] [blame]477/// This stores the string representation and parses the various pieces into
478/// enum members.
Chandler Carruth2d27b0f2012-02-21 03:39:36 +0000[diff] [blame]479Triple::Triple(const Twine &Str)
480 : Data(Str.str()),
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]481 Arch(parseArch(getArchName())),
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]482 SubArch(parseSubArch(getArchName())),
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]483 Vendor(parseVendor(getVendorName())),
484 OS(parseOS(getOSName())),
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]485 Environment(parseEnvironment(getEnvironmentName())),
486 ObjectFormat(parseFormat(getEnvironmentName())) {
487 if (ObjectFormat == Triple::UnknownObjectFormat)
488 ObjectFormat = getDefaultFormat(*this);
Chandler Carruth2d27b0f2012-02-21 03:39:36 +0000[diff] [blame]489}
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000[diff] [blame]490
491/// \brief Construct a triple from string representations of the architecture,
492/// vendor, and OS.
493///
Chandler Carruth1f3325a2012-02-21 08:31:18 +0000[diff] [blame]494/// This joins each argument into a canonical string representation and parses
495/// them into enum members. It leaves the environment unknown and omits it from
496/// the string representation.
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000[diff] [blame]497Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
498 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]499 Arch(parseArch(ArchStr.str())),
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]500 SubArch(parseSubArch(ArchStr.str())),
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]501 Vendor(parseVendor(VendorStr.str())),
502 OS(parseOS(OSStr.str())),
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]503 Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
504 ObjectFormat = getDefaultFormat(*this);
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000[diff] [blame]505}
506
507/// \brief Construct a triple from string representations of the architecture,
508/// vendor, OS, and environment.
509///
Chandler Carruth1f3325a2012-02-21 08:31:18 +0000[diff] [blame]510/// This joins each argument into a canonical string representation and parses
511/// them into enum members.
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000[diff] [blame]512Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
513 const Twine &EnvironmentStr)
514 : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
515 EnvironmentStr).str()),
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]516 Arch(parseArch(ArchStr.str())),
Renato Golinc17a07b2014-07-18 12:00:48 +0000[diff] [blame]517 SubArch(parseSubArch(ArchStr.str())),
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]518 Vendor(parseVendor(VendorStr.str())),
519 OS(parseOS(OSStr.str())),
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]520 Environment(parseEnvironment(EnvironmentStr.str())),
521 ObjectFormat(parseFormat(EnvironmentStr.str())) {
522 if (ObjectFormat == Triple::UnknownObjectFormat)
523 ObjectFormat = getDefaultFormat(*this);
Chandler Carruth0d887dd2012-02-20 00:02:47 +0000[diff] [blame]524}
525
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]526std::string Triple::normalize(StringRef Str) {
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000[diff] [blame]527 bool IsMinGW32 = false;
528 bool IsCygwin = false;
529
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]530 // Parse into components.
531 SmallVector<StringRef, 4> Components;
Chandler Carruth6ea6de72012-02-21 09:12:48 +0000[diff] [blame]532 Str.split(Components, "-");
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]533
534 // If the first component corresponds to a known architecture, preferentially
535 // use it for the architecture. If the second component corresponds to a
536 // known vendor, preferentially use it for the vendor, etc. This avoids silly
537 // component movement when a component parses as (eg) both a valid arch and a
538 // valid os.
539 ArchType Arch = UnknownArch;
540 if (Components.size() > 0)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]541 Arch = parseArch(Components[0]);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]542 VendorType Vendor = UnknownVendor;
543 if (Components.size() > 1)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]544 Vendor = parseVendor(Components[1]);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]545 OSType OS = UnknownOS;
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000[diff] [blame]546 if (Components.size() > 2) {
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]547 OS = parseOS(Components[2]);
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000[diff] [blame]548 IsCygwin = Components[2].startswith("cygwin");
549 IsMinGW32 = Components[2].startswith("mingw");
550 }
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]551 EnvironmentType Environment = UnknownEnvironment;
552 if (Components.size() > 3)
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]553 Environment = parseEnvironment(Components[3]);
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]554 ObjectFormatType ObjectFormat = UnknownObjectFormat;
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000[diff] [blame]555 if (Components.size() > 4)
556 ObjectFormat = parseFormat(Components[4]);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]557
558 // Note which components are already in their final position. These will not
559 // be moved.
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]560 bool Found[4];
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]561 Found[0] = Arch != UnknownArch;
562 Found[1] = Vendor != UnknownVendor;
563 Found[2] = OS != UnknownOS;
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]564 Found[3] = Environment != UnknownEnvironment;
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]565
566 // If they are not there already, permute the components into their canonical
567 // positions by seeing if they parse as a valid architecture, and if so moving
568 // the component to the architecture position etc.
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]569 for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]570 if (Found[Pos])
571 continue; // Already in the canonical position.
572
573 for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
574 // Do not reparse any components that already matched.
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]575 if (Idx < array_lengthof(Found) && Found[Idx])
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]576 continue;
577
578 // Does this component parse as valid for the target position?
579 bool Valid = false;
580 StringRef Comp = Components[Idx];
581 switch (Pos) {
Craig Toppera2886c22012-02-07 05:05:23 +0000[diff] [blame]582 default: llvm_unreachable("unexpected component type!");
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]583 case 0:
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]584 Arch = parseArch(Comp);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]585 Valid = Arch != UnknownArch;
586 break;
587 case 1:
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]588 Vendor = parseVendor(Comp);
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]589 Valid = Vendor != UnknownVendor;
590 break;
591 case 2:
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]592 OS = parseOS(Comp);
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000[diff] [blame]593 IsCygwin = Comp.startswith("cygwin");
594 IsMinGW32 = Comp.startswith("mingw");
595 Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]596 break;
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]597 case 3:
Chandler Carruthaec97082012-02-21 08:53:32 +0000[diff] [blame]598 Environment = parseEnvironment(Comp);
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]599 Valid = Environment != UnknownEnvironment;
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]600 if (!Valid) {
601 ObjectFormat = parseFormat(Comp);
602 Valid = ObjectFormat != UnknownObjectFormat;
603 }
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]604 break;
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]605 }
606 if (!Valid)
607 continue; // Nope, try the next component.
608
609 // Move the component to the target position, pushing any non-fixed
610 // components that are in the way to the right. This tends to give
611 // good results in the common cases of a forgotten vendor component
612 // or a wrongly positioned environment.
613 if (Pos < Idx) {
614 // Insert left, pushing the existing components to the right. For
615 // example, a-b-i386 -> i386-a-b when moving i386 to the front.
616 StringRef CurrentComponent(""); // The empty component.
617 // Replace the component we are moving with an empty component.
618 std::swap(CurrentComponent, Components[Idx]);
619 // Insert the component being moved at Pos, displacing any existing
620 // components to the right.
621 for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
622 // Skip over any fixed components.
Chandler Carruth362087b2012-02-21 09:29:14 +0000[diff] [blame]623 while (i < array_lengthof(Found) && Found[i])
624 ++i;
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]625 // Place the component at the new position, getting the component
626 // that was at this position - it will be moved right.
627 std::swap(CurrentComponent, Components[i]);
628 }
629 } else if (Pos > Idx) {
630 // Push right by inserting empty components until the component at Idx
631 // reaches the target position Pos. For example, pc-a -> -pc-a when
632 // moving pc to the second position.
633 do {
634 // Insert one empty component at Idx.
635 StringRef CurrentComponent(""); // The empty component.
Duncan Sandsfdfdbd02011-02-02 10:08:38 +0000[diff] [blame]636 for (unsigned i = Idx; i < Components.size();) {
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]637 // Place the component at the new position, getting the component
638 // that was at this position - it will be moved right.
639 std::swap(CurrentComponent, Components[i]);
640 // If it was placed on top of an empty component then we are done.
641 if (CurrentComponent.empty())
642 break;
Duncan Sandsfdfdbd02011-02-02 10:08:38 +0000[diff] [blame]643 // Advance to the next component, skipping any fixed components.
Anders Carlsson630125a2011-02-05 18:19:35 +0000[diff] [blame]644 while (++i < array_lengthof(Found) && Found[i])
645 ;
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]646 }
647 // The last component was pushed off the end - append it.
648 if (!CurrentComponent.empty())
649 Components.push_back(CurrentComponent);
650
651 // Advance Idx to the component's new position.
Chandler Carruth362087b2012-02-21 09:29:14 +0000[diff] [blame]652 while (++Idx < array_lengthof(Found) && Found[Idx])
653 ;
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]654 } while (Idx < Pos); // Add more until the final position is reached.
655 }
656 assert(Pos < Components.size() && Components[Pos] == Comp &&
657 "Component moved wrong!");
658 Found[Pos] = true;
659 break;
660 }
661 }
662
663 // Special case logic goes here. At this point Arch, Vendor and OS have the
664 // correct values for the computed components.
665
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]666 if (OS == Triple::Win32) {
667 Components.resize(4);
668 Components[2] = "windows";
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000[diff] [blame]669 if (Environment == UnknownEnvironment) {
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +0000[diff] [blame]670 if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000[diff] [blame]671 Components[3] = "msvc";
672 else
673 Components[3] = getObjectFormatTypeName(ObjectFormat);
Saleem Abdulrasoolf80b49b2014-03-30 07:19:31 +0000[diff] [blame]674 }
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000[diff] [blame]675 } else if (IsMinGW32) {
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]676 Components.resize(4);
677 Components[2] = "windows";
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +0000[diff] [blame]678 Components[3] = "gnu";
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000[diff] [blame]679 } else if (IsCygwin) {
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]680 Components.resize(4);
681 Components[2] = "windows";
682 Components[3] = "cygnus";
683 }
Saleem Abdulrasool0e1b31c2014-08-09 23:12:20 +0000[diff] [blame]684 if (IsMinGW32 || IsCygwin ||
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +0000[diff] [blame]685 (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
686 if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
687 Components.resize(5);
688 Components[4] = getObjectFormatTypeName(ObjectFormat);
689 }
690 }
Saleem Abdulrasooledbdd2e2014-03-27 22:50:05 +0000[diff] [blame]691
Duncan Sands501dff72010-08-12 11:31:39 +0000[diff] [blame]692 // Stick the corrected components back together to form the normalized string.
693 std::string Normalized;
694 for (unsigned i = 0, e = Components.size(); i != e; ++i) {
695 if (i) Normalized += '-';
696 Normalized += Components[i];
697 }
698 return Normalized;
699}
700
Daniel Dunbar19e70762009-07-26 03:31:47 +0000[diff] [blame]701StringRef Triple::getArchName() const {
702 return StringRef(Data).split('-').first; // Isolate first component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]703}
704
Daniel Dunbar19e70762009-07-26 03:31:47 +0000[diff] [blame]705StringRef Triple::getVendorName() const {
706 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
707 return Tmp.split('-').first; // Isolate second component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]708}
709
Daniel Dunbar19e70762009-07-26 03:31:47 +0000[diff] [blame]710StringRef Triple::getOSName() const {
711 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
712 Tmp = Tmp.split('-').second; // Strip second component
713 return Tmp.split('-').first; // Isolate third component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]714}
715
Daniel Dunbar19e70762009-07-26 03:31:47 +0000[diff] [blame]716StringRef Triple::getEnvironmentName() const {
717 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
718 Tmp = Tmp.split('-').second; // Strip second component
719 return Tmp.split('-').second; // Strip third component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]720}
721
Daniel Dunbar19e70762009-07-26 03:31:47 +0000[diff] [blame]722StringRef Triple::getOSAndEnvironmentName() const {
723 StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
724 return Tmp.split('-').second; // Strip second component
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]725}
726
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]727static unsigned EatNumber(StringRef &Str) {
728 assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]729 unsigned Result = 0;
Jim Grosbachf638b262010-12-17 02:10:59 +0000[diff] [blame]730
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]731 do {
732 // Consume the leading digit.
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]733 Result = Result*10 + (Str[0] - '0');
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]734
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]735 // Eat the digit.
736 Str = Str.substr(1);
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]737 } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
Jim Grosbachf638b262010-12-17 02:10:59 +0000[diff] [blame]738
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]739 return Result;
740}
741
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]742void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
743 unsigned &Micro) const {
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]744 StringRef OSName = getOSName();
Jim Grosbachf638b262010-12-17 02:10:59 +0000[diff] [blame]745
Dan Albert675cffc2015-03-03 18:23:51 +0000[diff] [blame]746 // For Android, we care about the Android version rather than the Linux
747 // version.
748 if (getEnvironment() == Android) {
749 OSName = getEnvironmentName().substr(strlen("android"));
750 if (OSName.startswith("eabi"))
751 OSName = OSName.substr(strlen("eabi"));
752 }
753
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]754 // Assume that the OS portion of the triple starts with the canonical name.
755 StringRef OSTypeName = getOSTypeName(getOS());
756 if (OSName.startswith(OSTypeName))
757 OSName = OSName.substr(OSTypeName.size());
Jim Grosbachf638b262010-12-17 02:10:59 +0000[diff] [blame]758
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]759 // Any unset version defaults to 0.
760 Major = Minor = Micro = 0;
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]761
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]762 // Parse up to three components.
763 unsigned *Components[3] = { &Major, &Minor, &Micro };
764 for (unsigned i = 0; i != 3; ++i) {
765 if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
766 break;
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]767
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]768 // Consume the leading number.
769 *Components[i] = EatNumber(OSName);
Jim Grosbachf638b262010-12-17 02:10:59 +0000[diff] [blame]770
Daniel Dunbar99f904c2011-04-19 20:24:34 +0000[diff] [blame]771 // Consume the separator, if present.
772 if (OSName.startswith("."))
773 OSName = OSName.substr(1);
774 }
Chris Lattner553c9f32009-08-12 06:19:40 +0000[diff] [blame]775}
776
Bob Wilsonaa30aff2012-01-31 22:32:29 +0000[diff] [blame]777bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
778 unsigned &Micro) const {
779 getOSVersion(Major, Minor, Micro);
780
781 switch (getOS()) {
Craig Toppera2886c22012-02-07 05:05:23 +0000[diff] [blame]782 default: llvm_unreachable("unexpected OS for Darwin triple");
Bob Wilsonaa30aff2012-01-31 22:32:29 +0000[diff] [blame]783 case Darwin:
784 // Default to darwin8, i.e., MacOSX 10.4.
785 if (Major == 0)
786 Major = 8;
787 // Darwin version numbers are skewed from OS X versions.
788 if (Major < 4)
789 return false;
790 Micro = 0;
791 Minor = Major - 4;
792 Major = 10;
793 break;
794 case MacOSX:
795 // Default to 10.4.
796 if (Major == 0) {
797 Major = 10;
798 Minor = 4;
799 }
800 if (Major != 10)
801 return false;
802 break;
803 case IOS:
804 // Ignore the version from the triple. This is only handled because the
805 // the clang driver combines OS X and IOS support into a common Darwin
806 // toolchain that wants to know the OS X version number even when targeting
807 // IOS.
808 Major = 10;
809 Minor = 4;
810 Micro = 0;
811 break;
812 }
813 return true;
814}
815
Chad Rosierd84eaac2012-05-09 17:23:48 +0000[diff] [blame]816void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
817 unsigned &Micro) const {
818 switch (getOS()) {
819 default: llvm_unreachable("unexpected OS for Darwin triple");
820 case Darwin:
821 case MacOSX:
822 // Ignore the version from the triple. This is only handled because the
823 // the clang driver combines OS X and IOS support into a common Darwin
824 // toolchain that wants to know the iOS version number even when targeting
825 // OS X.
Tim Northover3e8df692013-12-10 11:53:16 +0000[diff] [blame]826 Major = 5;
Chad Rosierd84eaac2012-05-09 17:23:48 +0000[diff] [blame]827 Minor = 0;
828 Micro = 0;
Chad Rosier2778cbc2012-05-09 17:38:47 +0000[diff] [blame]829 break;
Chad Rosierd84eaac2012-05-09 17:23:48 +0000[diff] [blame]830 case IOS:
831 getOSVersion(Major, Minor, Micro);
Tim Northover00ed9962014-03-29 10:18:08 +0000[diff] [blame]832 // Default to 5.0 (or 7.0 for arm64).
Chad Rosier9d7b1ce2012-05-09 18:23:00 +0000[diff] [blame]833 if (Major == 0)
Tim Northovere19bed72014-07-23 12:32:47 +0000[diff] [blame]834 Major = (getArch() == aarch64) ? 7 : 5;
Chad Rosierd84eaac2012-05-09 17:23:48 +0000[diff] [blame]835 break;
836 }
837}
838
Daniel Dunbar19e70762009-07-26 03:31:47 +0000[diff] [blame]839void Triple::setTriple(const Twine &Str) {
Chandler Carruth2d27b0f2012-02-21 03:39:36 +0000[diff] [blame]840 *this = Triple(Str);
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]841}
842
843void Triple::setArch(ArchType Kind) {
844 setArchName(getArchTypeName(Kind));
845}
846
847void Triple::setVendor(VendorType Kind) {
848 setVendorName(getVendorTypeName(Kind));
849}
850
851void Triple::setOS(OSType Kind) {
852 setOSName(getOSTypeName(Kind));
853}
854
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]855void Triple::setEnvironment(EnvironmentType Kind) {
Reid Kleckner5fe405d2015-02-13 22:05:50 +0000[diff] [blame]856 if (ObjectFormat == getDefaultFormat(*this))
857 return setEnvironmentName(getEnvironmentTypeName(Kind));
858
859 setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
860 getObjectFormatTypeName(ObjectFormat)).str());
Duncan Sands84a3bdd2010-09-16 08:25:48 +0000[diff] [blame]861}
862
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]863void Triple::setObjectFormat(ObjectFormatType Kind) {
Saleem Abdulrasool28b82bc2014-03-31 16:34:41 +0000[diff] [blame]864 if (Environment == UnknownEnvironment)
865 return setEnvironmentName(getObjectFormatTypeName(Kind));
866
Benjamin Kramercccdadc2014-07-08 14:55:06 +0000[diff] [blame]867 setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
868 getObjectFormatTypeName(Kind)).str());
Saleem Abdulrasool35476332014-03-06 20:47:11 +0000[diff] [blame]869}
870
Daniel Dunbarad36e8a2009-11-06 10:58:06 +0000[diff] [blame]871void Triple::setArchName(StringRef Str) {
Jeffrey Yasskine2595b52009-10-06 21:45:26 +0000[diff] [blame]872 // Work around a miscompilation bug for Twines in gcc 4.0.3.
873 SmallString<64> Triple;
874 Triple += Str;
875 Triple += "-";
876 Triple += getVendorName();
877 Triple += "-";
878 Triple += getOSAndEnvironmentName();
Yaron Keren92e1b622015-03-18 10:17:07 +0000[diff] [blame]879 setTriple(Triple);
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]880}
881
Daniel Dunbarad36e8a2009-11-06 10:58:06 +0000[diff] [blame]882void Triple::setVendorName(StringRef Str) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]883 setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
884}
885
Daniel Dunbarad36e8a2009-11-06 10:58:06 +0000[diff] [blame]886void Triple::setOSName(StringRef Str) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]887 if (hasEnvironment())
888 setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
889 "-" + getEnvironmentName());
890 else
891 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
892}
893
Daniel Dunbarad36e8a2009-11-06 10:58:06 +0000[diff] [blame]894void Triple::setEnvironmentName(StringRef Str) {
895 setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]896 "-" + Str);
897}
898
Daniel Dunbarad36e8a2009-11-06 10:58:06 +0000[diff] [blame]899void Triple::setOSAndEnvironmentName(StringRef Str) {
Daniel Dunbar4abd5662009-04-01 21:53:23 +0000[diff] [blame]900 setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
901}
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]902
903static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
904 switch (Arch) {
905 case llvm::Triple::UnknownArch:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]906 return 0;
907
908 case llvm::Triple::msp430:
909 return 16;
910
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]911 case llvm::Triple::arm:
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]912 case llvm::Triple::armeb:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]913 case llvm::Triple::hexagon:
914 case llvm::Triple::le32:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]915 case llvm::Triple::mips:
916 case llvm::Triple::mipsel:
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]917 case llvm::Triple::nvptx:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]918 case llvm::Triple::ppc:
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000[diff] [blame]919 case llvm::Triple::r600:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]920 case llvm::Triple::sparc:
921 case llvm::Triple::tce:
922 case llvm::Triple::thumb:
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]923 case llvm::Triple::thumbeb:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]924 case llvm::Triple::x86:
925 case llvm::Triple::xcore:
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]926 case llvm::Triple::amdil:
927 case llvm::Triple::hsail:
Guy Benyeia4d31a32012-11-15 10:35:47 +0000[diff] [blame]928 case llvm::Triple::spir:
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]929 case llvm::Triple::kalimba:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]930 return 32;
931
Tim Northovere0e3aef2013-01-31 12:12:40 +0000[diff] [blame]932 case llvm::Triple::aarch64:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]933 case llvm::Triple::aarch64_be:
Tom Stellard07f11602015-01-06 18:00:00 +0000[diff] [blame]934 case llvm::Triple::amdgcn:
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000[diff] [blame]935 case llvm::Triple::bpf:
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]936 case llvm::Triple::le64:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]937 case llvm::Triple::mips64:
938 case llvm::Triple::mips64el:
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]939 case llvm::Triple::nvptx64:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]940 case llvm::Triple::ppc64:
Bill Schmidt0a9170d2013-07-26 01:35:43 +0000[diff] [blame]941 case llvm::Triple::ppc64le:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]942 case llvm::Triple::sparcv9:
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000[diff] [blame]943 case llvm::Triple::systemz:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]944 case llvm::Triple::x86_64:
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]945 case llvm::Triple::amdil64:
946 case llvm::Triple::hsail64:
Guy Benyeia4d31a32012-11-15 10:35:47 +0000[diff] [blame]947 case llvm::Triple::spir64:
Chandler Carruthb90c1022012-01-31 04:52:32 +0000[diff] [blame]948 return 64;
949 }
950 llvm_unreachable("Invalid architecture value");
951}
952
953bool Triple::isArch64Bit() const {
954 return getArchPointerBitWidth(getArch()) == 64;
955}
956
957bool Triple::isArch32Bit() const {
958 return getArchPointerBitWidth(getArch()) == 32;
959}
960
961bool Triple::isArch16Bit() const {
962 return getArchPointerBitWidth(getArch()) == 16;
963}
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]964
965Triple Triple::get32BitArchVariant() const {
966 Triple T(*this);
967 switch (getArch()) {
968 case Triple::UnknownArch:
Tim Northovere0e3aef2013-01-31 12:12:40 +0000[diff] [blame]969 case Triple::aarch64:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]970 case Triple::aarch64_be:
Tom Stellard07f11602015-01-06 18:00:00 +0000[diff] [blame]971 case Triple::amdgcn:
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000[diff] [blame]972 case Triple::bpf:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]973 case Triple::msp430:
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000[diff] [blame]974 case Triple::systemz:
Bill Schmidt0a9170d2013-07-26 01:35:43 +0000[diff] [blame]975 case Triple::ppc64le:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]976 T.setArch(UnknownArch);
977 break;
978
979 case Triple::amdil:
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]980 case Triple::hsail:
Micah Villmow48c8ddc2012-10-01 17:01:31 +0000[diff] [blame]981 case Triple::spir:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]982 case Triple::arm:
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]983 case Triple::armeb:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]984 case Triple::hexagon:
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]985 case Triple::kalimba:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]986 case Triple::le32:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]987 case Triple::mips:
988 case Triple::mipsel:
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]989 case Triple::nvptx:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]990 case Triple::ppc:
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000[diff] [blame]991 case Triple::r600:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]992 case Triple::sparc:
993 case Triple::tce:
994 case Triple::thumb:
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]995 case Triple::thumbeb:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]996 case Triple::x86:
997 case Triple::xcore:
998 // Already 32-bit.
999 break;
1000
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]1001 case Triple::le64: T.setArch(Triple::le32); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1002 case Triple::mips64: T.setArch(Triple::mips); break;
1003 case Triple::mips64el: T.setArch(Triple::mipsel); break;
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]1004 case Triple::nvptx64: T.setArch(Triple::nvptx); break;
Bob Wilsona2790b12014-03-09 23:17:28 +0000[diff] [blame]1005 case Triple::ppc64: T.setArch(Triple::ppc); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1006 case Triple::sparcv9: T.setArch(Triple::sparc); break;
1007 case Triple::x86_64: T.setArch(Triple::x86); break;
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]1008 case Triple::amdil64: T.setArch(Triple::amdil); break;
1009 case Triple::hsail64: T.setArch(Triple::hsail); break;
Guy Benyeia4d31a32012-11-15 10:35:47 +0000[diff] [blame]1010 case Triple::spir64: T.setArch(Triple::spir); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1011 }
1012 return T;
1013}
1014
1015Triple Triple::get64BitArchVariant() const {
1016 Triple T(*this);
1017 switch (getArch()) {
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1018 case Triple::UnknownArch:
Tim Northoveraf6bfb22014-03-30 07:25:23 +0000[diff] [blame]1019 case Triple::arm:
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]1020 case Triple::armeb:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1021 case Triple::hexagon:
Eric Christopher54fe1b22014-07-10 17:26:54 +0000[diff] [blame]1022 case Triple::kalimba:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1023 case Triple::msp430:
Anton Korobeynikovf32638d2012-03-09 10:09:36 +0000[diff] [blame]1024 case Triple::r600:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1025 case Triple::tce:
1026 case Triple::thumb:
Christian Pirker2a111602014-03-28 14:35:30 +0000[diff] [blame]1027 case Triple::thumbeb:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1028 case Triple::xcore:
1029 T.setArch(UnknownArch);
1030 break;
1031
Tim Northovere0e3aef2013-01-31 12:12:40 +0000[diff] [blame]1032 case Triple::aarch64:
Christian Pirker6c2f4d42014-02-24 11:34:50 +0000[diff] [blame]1033 case Triple::aarch64_be:
Alexei Starovoitove4c8c802015-01-24 17:51:26 +0000[diff] [blame]1034 case Triple::bpf:
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]1035 case Triple::le64:
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]1036 case Triple::amdil64:
Tom Stellard07f11602015-01-06 18:00:00 +0000[diff] [blame]1037 case Triple::amdgcn:
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]1038 case Triple::hsail64:
1039 case Triple::spir64:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1040 case Triple::mips64:
1041 case Triple::mips64el:
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]1042 case Triple::nvptx64:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1043 case Triple::ppc64:
Bill Schmidt0a9170d2013-07-26 01:35:43 +0000[diff] [blame]1044 case Triple::ppc64le:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1045 case Triple::sparcv9:
Richard Sandiforda238c5e2013-05-03 11:05:17 +0000[diff] [blame]1046 case Triple::systemz:
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1047 case Triple::x86_64:
1048 // Already 64-bit.
1049 break;
1050
JF Bastien32972ef2014-09-12 17:54:17 +0000[diff] [blame]1051 case Triple::le32: T.setArch(Triple::le64); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1052 case Triple::mips: T.setArch(Triple::mips64); break;
1053 case Triple::mipsel: T.setArch(Triple::mips64el); break;
Justin Holewinskiae556d32012-05-04 20:18:50 +0000[diff] [blame]1054 case Triple::nvptx: T.setArch(Triple::nvptx64); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1055 case Triple::ppc: T.setArch(Triple::ppc64); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1056 case Triple::sparc: T.setArch(Triple::sparcv9); break;
1057 case Triple::x86: T.setArch(Triple::x86_64); break;
Matt Arsenault3f9b0212014-09-19 19:52:11 +0000[diff] [blame]1058 case Triple::amdil: T.setArch(Triple::amdil64); break;
1059 case Triple::hsail: T.setArch(Triple::hsail64); break;
Guy Benyeia4d31a32012-11-15 10:35:47 +0000[diff] [blame]1060 case Triple::spir: T.setArch(Triple::spir64); break;
Chandler Carruth07cfb4b2012-02-06 20:46:33 +0000[diff] [blame]1061 }
1062 return T;
1063}
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1064
1065// FIXME: tblgen this.
1066const char *Triple::getARMCPUForArch(StringRef MArch) const {
1067 if (MArch.empty())
1068 MArch = getArchName();
1069
1070 switch (getOS()) {
Ed Masteea0257a2014-09-09 17:47:24 +0000[diff] [blame]1071 case llvm::Triple::FreeBSD:
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1072 case llvm::Triple::NetBSD:
1073 if (MArch == "armv6")
1074 return "arm1176jzf-s";
1075 break;
1076 case llvm::Triple::Win32:
1077 // FIXME: this is invalid for WindowsCE
1078 return "cortex-a9";
1079 default:
1080 break;
1081 }
1082
1083 const char *result = nullptr;
1084 size_t offset = StringRef::npos;
1085 if (MArch.startswith("arm"))
1086 offset = 3;
1087 if (MArch.startswith("thumb"))
1088 offset = 5;
1089 if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
1090 offset += 2;
Joerg Sonnenberger429edc12015-01-26 11:41:48 +0000[diff] [blame]1091 if (MArch.endswith("eb"))
1092 MArch = MArch.substr(0, MArch.size() - 2);
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1093 if (offset != StringRef::npos)
1094 result = llvm::StringSwitch<const char *>(MArch.substr(offset))
1095 .Cases("v2", "v2a", "arm2")
1096 .Case("v3", "arm6")
1097 .Case("v3m", "arm7m")
1098 .Case("v4", "strongarm")
1099 .Case("v4t", "arm7tdmi")
1100 .Cases("v5", "v5t", "arm10tdmi")
1101 .Cases("v5e", "v5te", "arm1022e")
1102 .Case("v5tej", "arm926ej-s")
Renato Golin12350602015-03-17 11:55:28 +0000[diff] [blame]1103 .Case("v6", "arm1136jf-s")
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1104 .Case("v6j", "arm1136j-s")
Renato Golin12350602015-03-17 11:55:28 +0000[diff] [blame]1105 .Cases("v6k", "v6z", "v6zk", "arm1176jzf-s")
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1106 .Case("v6t2", "arm1156t2-s")
Bradley Smithe997b452015-02-10 15:15:08 +0000[diff] [blame]1107 .Cases("v6m", "v6-m", "v6sm", "v6s-m", "cortex-m0")
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1108 .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
1109 .Cases("v7s", "v7-s", "swift")
1110 .Cases("v7r", "v7-r", "cortex-r4")
1111 .Cases("v7m", "v7-m", "cortex-m3")
1112 .Cases("v7em", "v7e-m", "cortex-m4")
1113 .Cases("v8", "v8a", "v8-a", "cortex-a53")
Vladimir Sukharevc632cda2015-03-26 17:05:54 +0000[diff] [blame]1114 .Cases("v8.1a", "v8.1-a", "generic-armv8.1-a")
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1115 .Default(nullptr);
1116 else
1117 result = llvm::StringSwitch<const char *>(MArch)
1118 .Case("ep9312", "ep9312")
1119 .Case("iwmmxt", "iwmmxt")
1120 .Case("xscale", "xscale")
1121 .Default(nullptr);
1122
1123 if (result)
1124 return result;
1125
1126 // If all else failed, return the most base CPU with thumb interworking
1127 // supported by LLVM.
1128 // FIXME: Should warn once that we're falling back.
1129 switch (getOS()) {
1130 case llvm::Triple::NetBSD:
1131 switch (getEnvironment()) {
1132 case llvm::Triple::GNUEABIHF:
1133 case llvm::Triple::GNUEABI:
1134 case llvm::Triple::EABIHF:
1135 case llvm::Triple::EABI:
1136 return "arm926ej-s";
1137 default:
1138 return "strongarm";
1139 }
Derek Schuffa3b594c2015-03-26 21:58:46 +0000[diff] [blame^]1140 case llvm::Triple::NaCl:
1141 return "cortex-a8";
Argyrios Kyrtzidis730abd22014-07-11 21:44:54 +0000[diff] [blame]1142 default:
1143 switch (getEnvironment()) {
1144 case llvm::Triple::EABIHF:
1145 case llvm::Triple::GNUEABIHF:
1146 return "arm1176jzf-s";
1147 default:
1148 return "arm7tdmi";
1149 }
1150 }
1151}