31 case amdgcn:
return "amdgcn";
33 case amdil:
return "amdil";
34 case arc:
return "arc";
35 case arm:
return "arm";
36 case armeb:
return "armeb";
37 case avr:
return "avr";
38 case bpfeb:
return "bpfeb";
39 case bpfel:
return "bpfel";
40 case csky:
return "csky";
41 case dxil:
return "dxil";
44 case hsail:
return "hsail";
46 case lanai:
return "lanai";
49 case m68k:
return "m68k";
50 case mips64:
return "mips64";
52 case mips:
return "mips";
53 case mipsel:
return "mipsel";
54 case msp430:
return "msp430";
56 case nvptx:
return "nvptx";
57 case ppc64:
return "powerpc64";
58 case ppc64le:
return "powerpc64le";
59 case ppc:
return "powerpc";
60 case ppcle:
return "powerpcle";
61 case r600:
return "r600";
66 case shave:
return "shave";
67 case sparc:
return "sparc";
70 case spir64:
return "spir64";
71 case spir:
return "spir";
72 case spirv:
return "spirv";
76 case tce:
return "tce";
77 case tcele:
return "tcele";
78 case thumb:
return "thumb";
81 case wasm32:
return "wasm32";
82 case wasm64:
return "wasm64";
83 case x86:
return "i386";
84 case x86_64:
return "x86_64";
85 case xcore:
return "xcore";
86 case xtensa:
return "xtensa";
100 return "mipsisa32r6el";
104 return "mipsisa64r6";
108 return "mipsisa64r6el";
176 case arc:
return "arc";
183 case avr:
return "avr";
188 case ppcle:
return "ppc";
190 case m68k:
return "m68k";
197 case hexagon:
return "hexagon";
199 case amdgcn:
return "amdgcn";
200 case r600:
return "r600";
203 case bpfeb:
return "bpf";
207 case sparc:
return "sparc";
212 case x86_64:
return "x86";
214 case xcore:
return "xcore";
217 case nvptx:
return "nvvm";
227 case spir64:
return "spir";
233 case kalimba:
return "kalimba";
234 case lanai:
return "lanai";
235 case shave:
return "shave";
237 case wasm64:
return "wasm";
242 case ve:
return "ve";
243 case csky:
return "csky";
248 case dxil:
return "dx";
250 case xtensa:
return "xtensa";
258 case AMD:
return "amd";
259 case Apple:
return "apple";
260 case CSR:
return "csr";
262 case IBM:
return "ibm";
266 case Mesa:
return "mesa";
268 case NVIDIA:
return "nvidia";
270 case PC:
return "pc";
271 case SCEI:
return "scei";
272 case SUSE:
return "suse";
282 case AIX:
return "aix";
283 case AMDHSA:
return "amdhsa";
284 case AMDPAL:
return "amdpal";
286 case CUDA:
return "cuda";
287 case Darwin:
return "darwin";
292 case FreeBSD:
return "freebsd";
293 case Fuchsia:
return "fuchsia";
294 case Haiku:
return "haiku";
296 case Hurd:
return "hurd";
297 case IOS:
return "ios";
299 case Linux:
return "linux";
300 case Lv2:
return "lv2";
301 case MacOSX:
return "macosx";
302 case Mesa3D:
return "mesa3d";
303 case NVCL:
return "nvcl";
304 case NaCl:
return "nacl";
305 case NetBSD:
return "netbsd";
306 case OpenBSD:
return "openbsd";
307 case PS4:
return "ps4";
308 case PS5:
return "ps5";
309 case RTEMS:
return "rtems";
310 case Solaris:
return "solaris";
312 case TvOS:
return "tvos";
313 case UEFI:
return "uefi";
314 case WASI:
return "wasi";
315 case WatchOS:
return "watchos";
316 case Win32:
return "windows";
317 case ZOS:
return "zos";
319 case LiteOS:
return "liteos";
320 case XROS:
return "xros";
321 case Vulkan:
return "vulkan";
330 case Android:
return "android";
331 case CODE16:
return "code16";
332 case CoreCLR:
return "coreclr";
333 case Cygnus:
return "cygnus";
334 case EABI:
return "eabi";
335 case EABIHF:
return "eabihf";
336 case GNU:
return "gnu";
337 case GNUT64:
return "gnut64";
340 case GNUEABI:
return "gnueabi";
344 case GNUF32:
return "gnuf32";
345 case GNUF64:
return "gnuf64";
346 case GNUSF:
return "gnusf";
347 case GNUX32:
return "gnux32";
349 case Itanium:
return "itanium";
350 case MSVC:
return "msvc";
351 case MacABI:
return "macabi";
352 case Musl:
return "musl";
363 case MuslX32:
return "muslx32";
365 case Pixel:
return "pixel";
366 case Vertex:
return "vertex";
368 case Hull:
return "hull";
369 case Domain:
return "domain";
370 case Compute:
return "compute";
371 case Library:
return "library";
374 case AnyHit:
return "anyhit";
376 case Miss:
return "miss";
378 case Mesh:
return "mesh";
395 case COFF:
return "coff";
396 case ELF:
return "elf";
397 case GOFF:
return "goff";
398 case MachO:
return "macho";
399 case Wasm:
return "wasm";
400 case XCOFF:
return "xcoff";
402 case SPIRV:
return "spirv";
408 if (ArchName ==
"bpf") {
413 }
else if (ArchName ==
"bpf_be" || ArchName ==
"bpfeb") {
415 }
else if (ArchName ==
"bpf_le" || ArchName ==
"bpfel") {
536 if (ArchName.
empty())
585 .
Cases(
"mips",
"mipseb",
"mipsallegrex",
"mipsisa32r6",
"mipsr6",
587 .
Cases(
"mipsel",
"mipsallegrexel",
"mipsisa32r6el",
"mipsr6el",
589 .
Cases(
"mips64",
"mips64eb",
"mipsn32",
"mipsisa64r6",
"mips64r6",
591 .
Cases(
"mips64el",
"mipsn32el",
"mipsisa64r6el",
"mips64r6el",
614 .
Cases(
"spirv32",
"spirv32v1.0",
"spirv32v1.1",
"spirv32v1.2",
615 "spirv32v1.3",
"spirv32v1.4",
"spirv32v1.5",
617 .
Cases(
"spirv64",
"spirv64v1.0",
"spirv64v1.1",
"spirv64v1.2",
618 "spirv64v1.3",
"spirv64v1.4",
"spirv64v1.5",
631 .
Cases(
"dxil",
"dxilv1.0",
"dxilv1.1",
"dxilv1.2",
"dxilv1.3",
632 "dxilv1.4",
"dxilv1.5",
"dxilv1.6",
"dxilv1.7",
"dxilv1.8",
791 if (SubArchName ==
"powerpcspe")
794 if (SubArchName ==
"arm64e")
797 if (SubArchName ==
"arm64ec")
827 if (ARMSubArch.
empty())
836 case ARM::ArchKind::ARMV4:
838 case ARM::ArchKind::ARMV4T:
840 case ARM::ArchKind::ARMV5T:
842 case ARM::ArchKind::ARMV5TE:
843 case ARM::ArchKind::IWMMXT:
844 case ARM::ArchKind::IWMMXT2:
845 case ARM::ArchKind::XSCALE:
846 case ARM::ArchKind::ARMV5TEJ:
848 case ARM::ArchKind::ARMV6:
850 case ARM::ArchKind::ARMV6K:
851 case ARM::ArchKind::ARMV6KZ:
853 case ARM::ArchKind::ARMV6T2:
855 case ARM::ArchKind::ARMV6M:
857 case ARM::ArchKind::ARMV7A:
858 case ARM::ArchKind::ARMV7R:
860 case ARM::ArchKind::ARMV7VE:
862 case ARM::ArchKind::ARMV7K:
864 case ARM::ArchKind::ARMV7M:
866 case ARM::ArchKind::ARMV7S:
868 case ARM::ArchKind::ARMV7EM:
870 case ARM::ArchKind::ARMV8A:
872 case ARM::ArchKind::ARMV8_1A:
874 case ARM::ArchKind::ARMV8_2A:
876 case ARM::ArchKind::ARMV8_3A:
878 case ARM::ArchKind::ARMV8_4A:
880 case ARM::ArchKind::ARMV8_5A:
882 case ARM::ArchKind::ARMV8_6A:
884 case ARM::ArchKind::ARMV8_7A:
886 case ARM::ArchKind::ARMV8_8A:
888 case ARM::ArchKind::ARMV8_9A:
890 case ARM::ArchKind::ARMV9A:
892 case ARM::ArchKind::ARMV9_1A:
894 case ARM::ArchKind::ARMV9_2A:
896 case ARM::ArchKind::ARMV9_3A:
898 case ARM::ArchKind::ARMV9_4A:
900 case ARM::ArchKind::ARMV9_5A:
902 case ARM::ArchKind::ARMV9_6A:
904 case ARM::ArchKind::ARMV8R:
906 case ARM::ArchKind::ARMV8MBaseline:
908 case ARM::ArchKind::ARMV8MMainline:
910 case ARM::ArchKind::ARMV8_1MMainline:
918 switch (
T.getArch()) {
1016 :
Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
1017 Vendor(UnknownVendor),
OS(UnknownOS), Environment(UnknownEnvironment),
1018 ObjectFormat(UnknownObjectFormat) {
1022 if (Components.
size() > 0) {
1025 if (Components.
size() > 1) {
1027 if (Components.
size() > 2) {
1029 if (Components.
size() > 3) {
1056 :
Data((ArchStr +
Twine(
'-') + VendorStr +
Twine(
'-') + OSStr).str()),
1061 Environment(), ObjectFormat(
Triple::UnknownObjectFormat) {
1071 const Twine &EnvironmentStr)
1073 EnvironmentStr).str()),
1091 const unsigned SMMajor = 6;
1094 if (std::optional<unsigned> SMMinor = Ver.
getMinor()) {
1122 if (ShaderModelStr ==
"shadermodel6.x") {
1132 bool IsMinGW32 =
false;
1133 bool IsCygwin =
false;
1137 Str.split(Components,
'-');
1145 if (Components.
size() > 0)
1148 if (Components.
size() > 1)
1151 if (Components.
size() > 2) {
1153 IsCygwin = Components[2].starts_with(
"cygwin");
1154 IsMinGW32 = Components[2].starts_with(
"mingw");
1157 if (Components.
size() > 3)
1160 if (Components.
size() > 4)
1174 for (
unsigned Pos = 0; Pos != std::size(Found); ++Pos) {
1180 if (
Idx < std::size(Found) && Found[
Idx])
1226 for (
unsigned i = Pos; !CurrentComponent.
empty(); ++i) {
1228 while (i < std::size(Found) && Found[i])
1232 std::swap(CurrentComponent, Components[i]);
1234 }
else if (Pos >
Idx) {
1241 for (
unsigned i =
Idx; i < Components.
size();) {
1244 std::swap(CurrentComponent, Components[i]);
1246 if (CurrentComponent.
empty())
1249 while (++i < std::size(Found) && Found[i])
1253 if (!CurrentComponent.
empty())
1257 while (++
Idx < std::size(Found) && Found[
Idx])
1259 }
while (
Idx < Pos);
1261 assert(Pos < Components.
size() && Components[Pos] == Comp &&
1262 "Component moved wrong!");
1270 if (Found[0] && !Found[1] && !Found[2] && Found[3] &&
1271 Components[1] ==
"none" && Components[2].empty())
1272 std::swap(Components[1], Components[2]);
1281 std::string NormalizedEnvironment;
1284 StringRef AndroidVersion = Components[3].drop_front(strlen(
"androideabi"));
1285 if (AndroidVersion.
empty()) {
1286 Components[3] =
"android";
1288 NormalizedEnvironment =
Twine(
"android", AndroidVersion).
str();
1289 Components[3] = NormalizedEnvironment;
1295 Components[3] =
"gnueabihf";
1299 Components[2] =
"windows";
1302 Components[3] =
"msvc";
1306 }
else if (IsMinGW32) {
1308 Components[2] =
"windows";
1309 Components[3] =
"gnu";
1310 }
else if (IsCygwin) {
1312 Components[2] =
"windows";
1313 Components[3] =
"cygnus";
1315 if (IsMinGW32 || IsCygwin ||
1328 if (Components[0] ==
"dxil") {
1329 if (Components.
size() > 4) {
1338 return join(Components,
"-");
1347 return Tmp.
split(
'-').first;
1352 Tmp = Tmp.
split(
'-').second;
1353 return Tmp.
split(
'-').first;
1358 Tmp = Tmp.
split(
'-').second;
1359 return Tmp.
split(
'-').second;
1364 return Tmp.
split(
'-').second;
1370 return Version.withoutBuild();
1382 if (EnvironmentName ==
"none")
1388 if (EnvironmentName.
contains(
"-")) {
1393 const std::string tmp = (
Twine(
"-") + ObjectFormatTypeName).
str();
1397 return EnvironmentName;
1427 if (
Version.getMajor() <= 19) {
1436 if (
Version.getMajor() == 0) {
1438 }
else if (
Version.getMajor() < 10) {
1521 return Version.withMajorReplaced(19);
1543 if (ValidVersionMap.
contains(VulkanVersion) &&
1544 (ValidVersionMap.
lookup(VulkanVersion) == SpirvVersion ||
1546 return VulkanVersion;
2047 return *
this ==
Other;
2053 if (
Other.isOSVersionLT(*
this))
2060 unsigned Micro)
const {
2071 assert(Major >= 11 &&
"Unexpected major version");
2125 "incorrect HLSL stage order");
2127 "incorrect HLSL stage order");
2129 "incorrect HLSL stage order");
2131 "incorrect HLSL stage order");
2133 "incorrect HLSL stage order");
2135 "incorrect HLSL stage order");
2137 "incorrect HLSL stage order");
2139 "incorrect HLSL stage order");
2141 "incorrect HLSL stage order");
2143 "incorrect HLSL stage order");
2145 "incorrect HLSL stage order");
2147 "incorrect HLSL stage order");
2149 "incorrect HLSL stage order");
2151 "incorrect HLSL stage order");
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName)
static VersionTuple parseVersionFromName(StringRef Name)
static Triple::ObjectFormatType getDefaultFormat(const Triple &T)
static Triple::ArchType parseARMArch(StringRef ArchName)
static Triple::OSType parseOS(StringRef OSName)
static StringRef getDXILArchNameFromShaderModel(StringRef ShaderModelStr)
static Triple::ArchType parseBPFArch(StringRef ArchName)
static Triple::SubArchType parseSubArch(StringRef SubArchName)
static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName)
static Triple::ArchType parseArch(StringRef ArchName)
static Triple::VendorType parseVendor(StringRef VendorName)
Defines the llvm::VersionTuple class, which represents a version in the form major[....
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
bool contains(const_arg_type_t< KeyT > Val) const
Return true if the specified key is in the map, false otherwise.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
bool consume_back(StringRef Suffix)
Returns true if this StringRef has the given suffix and removes that suffix.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
empty - Check if the string is empty.
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
constexpr size_t size() const
size - Get the string size.
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
StringSwitch & StartsWith(StringLiteral S, T Value)
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, T Value)
StringSwitch & EndsWith(StringLiteral S, T Value)
Triple - Helper class for working with autoconf configuration names.
bool isMacOSXVersionLT(unsigned Major, unsigned Minor=0, unsigned Micro=0) const
Comparison function for checking OS X version compatibility, which handles supporting skewed version ...
VersionTuple getOSVersion() const
Parse the version number from the OS name component of the triple, if present.
StringRef getVendorName() const
Get the vendor (second) component of the triple.
VersionTuple getWatchOSVersion() const
Parse the version number as with getOSVersion.
void setArchName(StringRef Str)
Set the architecture (first) component of the triple by name.
void setObjectFormat(ObjectFormatType Kind)
Set the object file format.
llvm::Triple get32BitArchVariant() const
Form a triple with a 32-bit variant of the current architecture.
Triple()=default
Default constructor is the same as an empty string and leaves all triple fields unknown.
std::string normalize() const
Return the normalized form of this triple's string.
unsigned getArchPointerBitWidth() const
Returns the pointer width of this architecture.
llvm::Triple getLittleEndianArchVariant() const
Form a triple with a little endian variant of the current architecture.
static StringRef getVendorTypeName(VendorType Kind)
Get the canonical name for the Kind vendor.
ObjectFormatType getObjectFormat() const
Get the object format for this triple.
SubArchType getSubArch() const
get the parsed subarchitecture type for this triple.
bool isArm64e() const
Tests whether the target is the Apple "arm64e" AArch64 subarch.
void setVendorName(StringRef Str)
Set the vendor (second) component of the triple by name.
void setOSAndEnvironmentName(StringRef Str)
Set the operating system and optional environment components with a single string.
llvm::Triple get64BitArchVariant() const
Form a triple with a 64-bit variant of the current architecture.
bool isLittleEndian() const
Tests whether the target triple is little endian.
void setEnvironment(EnvironmentType Kind)
Set the environment (fourth) component of the triple to a known type.
StringRef getOSName() const
Get the operating system (third) component of the triple.
void setTriple(const Twine &Str)
Set all components to the new triple Str.
OSType getOS() const
Get the parsed operating system type of this triple.
VersionTuple getEnvironmentVersion() const
Parse the version number from the OS name component of the triple, if present.
static ArchType getArchTypeForLLVMName(StringRef Str)
The canonical type for the given LLVM architecture name (e.g., "x86").
ArchType getArch() const
Get the parsed architecture type of this triple.
StringRef getEnvironmentName() const
Get the optional environment (fourth) component of the triple, or "" if empty.
bool isSimulatorEnvironment() const
VersionTuple getDXILVersion() const
Parse the DXIL version number from the OSVersion and DXIL version (SubArch).
const std::string & str() const
EnvironmentType getEnvironment() const
Get the parsed environment type of this triple.
VersionTuple getVulkanVersion() const
Parse the Vulkan version number from the OSVersion and SPIR-V version (SubArch).
VersionTuple getDriverKitVersion() const
Parse the version number as with getOSVersion.
static StringRef getArchTypeName(ArchType Kind)
Get the canonical name for the Kind architecture.
static StringRef getOSTypeName(OSType Kind)
Get the canonical name for the Kind operating system.
std::string merge(const Triple &Other) const
Merge target triples.
@ ImaginationTechnologies
VersionTuple getMinimumSupportedOSVersion() const
Some platforms have different minimum supported OS versions that varies by the architecture specified...
bool isArch64Bit() const
Test whether the architecture is 64-bit.
StringRef getOSAndEnvironmentName() const
Get the operating system and optional environment components as a single string (separated by a '-' i...
@ ARMSubArch_v8m_mainline
@ ARMSubArch_v8m_baseline
@ ARMSubArch_v8_1m_mainline
bool getMacOSXVersion(VersionTuple &Version) const
Parse the version number as with getOSVersion and then translate generic "darwin" versions to the cor...
bool isMacOSX() const
Is this a Mac OS X triple.
void setEnvironmentName(StringRef Str)
Set the optional environment (fourth) component of the triple by name.
void setOS(OSType Kind)
Set the operating system (third) component of the triple to a known type.
void setOSName(StringRef Str)
Set the operating system (third) component of the triple by name.
VendorType getVendor() const
Get the parsed vendor type of this triple.
static StringRef getEnvironmentTypeName(EnvironmentType Kind)
Get the canonical name for the Kind environment.
bool isOSVersionLT(unsigned Major, unsigned Minor=0, unsigned Micro=0) const
Helper function for doing comparisons against version numbers included in the target triple.
static VersionTuple getCanonicalVersionForOS(OSType OSKind, const VersionTuple &Version)
Returns a canonicalized OS version number for the specified OS.
StringRef getArchName() const
Get the architecture (first) component of the triple.
bool isMacCatalystEnvironment() const
static StringRef getObjectFormatTypeName(ObjectFormatType ObjectFormat)
Get the name for the Object format.
bool isArch16Bit() const
Test whether the architecture is 16-bit.
llvm::Triple getBigEndianArchVariant() const
Form a triple with a big endian variant of the current architecture.
VersionTuple getiOSVersion() const
Parse the version number as with getOSVersion.
StringRef getEnvironmentVersionString() const
Get the version component of the environment component as a single string (the version after the envi...
bool isArch32Bit() const
Test whether the architecture is 32-bit.
bool isCompatibleWith(const Triple &Other) const
Test whether target triples are compatible.
bool hasEnvironment() const
Does this triple have the optional environment (fourth) component?
static StringRef getArchTypePrefix(ArchType Kind)
Get the "prefix" canonical name for the Kind architecture.
void setArch(ArchType Kind, SubArchType SubArch=NoSubArch)
Set the architecture (first) component of the triple to a known type.
void setVendor(VendorType Kind)
Set the vendor (second) component of the triple to a known type.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
std::string str() const
Return the twine contents as a std::string.
Represents a version number in the form major[.minor[.subminor[.build]]].
unsigned getMajor() const
Retrieve the major version number.
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero).
std::optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
StringRef getCanonicalArchName(StringRef Arch)
MArch is expected to be of the form (arm|thumb)?(eb)?(v.
ISAKind parseArchISA(StringRef Arch)
ArchKind parseArch(StringRef Arch)
ProfileKind parseArchProfile(StringRef Arch)
unsigned parseArchVersion(StringRef Arch)
EndianKind parseArchEndian(StringRef Arch)
@ C
The default llvm calling convention, compatible with C.
static const bool IsLittleEndianHost
This is an optimization pass for GlobalISel generic memory operations.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.