Blame - llvm/lib/Support/Triple.cpp - toolchain/llvm-project

blob: d419463e6a5e6f640432f96076a45758be24321c [file] [log] [blame]

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