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