maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/Support/Triple.cpp

786 lines
24 KiB
C++
Raw Normal View History

Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
//===--- Triple.cpp - Target triple helper class --------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/Triple.h"
Use the new script to sort the includes of every file under lib. Sooooo many of these had incorrect or strange main module includes. I have manually inspected all of these, and fixed the main module include to be the nearest plausible thing I could find. If you own or care about any of these source files, I encourage you to take some time and check that these edits were sensible. I can't have broken anything (I strictly added headers, and reordered them, never removed), but they may not be the headers you'd really like to identify as containing the API being implemented. Many forward declarations and missing includes were added to a header files to allow them to parse cleanly when included first. The main module rule does in fact have its merits. =] llvm-svn: 169131
2012-12-04 00:50:05 +08:00
#include "llvm/ADT/STLExtras.h"
r83391 was completely broken since Twines keep references to their inputs, and some of the inputs were temporaries. Here's a real fix for the miscompilation. Thanks to sabre for pointing out the problem. llvm-svn: 83417
2009-10-07 05:45:26 +08:00
#include "llvm/ADT/SmallString.h"
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
#include "llvm/ADT/StringSwitch.h"
More dead code removal (using -Wunreachable-code) llvm-svn: 148578
2012-01-21 05:51:11 +08:00
#include "llvm/Support/ErrorHandling.h"
Fix build on Linux. llvm-svn: 68269
2009-04-02 09:11:37 +08:00
#include <cstring>
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
using namespace llvm;
const char *Triple::getArchTypeName(ArchType Kind) {
switch (Kind) {
case UnknownArch: return "unknown";
Trailing whitespace and 80 column fixups. llvm-svn: 122026
2010-12-17 10:10:59 +08:00
Add AArch64 as an experimental target. This patch adds support for AArch64 (ARM's 64-bit architecture) to LLVM in the "experimental" category. Currently, it won't be built unless requested explicitly. This initial commit should have support for: + Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions (except the late addition CRC instructions). + CodeGen features required for C++03 and C99. + Compilation for the "small" memory model: code+static data < 4GB. + Absolute and position-independent code. + GNU-style (i.e. "__thread") TLS. + Debugging information. The principal omission, currently, is performance tuning. This patch excludes the NEON support also reviewed due to an outbreak of batshit insanity in our legal department. That will be committed soon bringing the changes to precisely what has been approved. Further reviews would be gratefully received. llvm-svn: 174054
2013-01-31 20:12:40 +08:00
case aarch64: return "aarch64";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case arm: return "arm";
Hexagon backend support llvm-svn: 146412
2011-12-13 05:14:40 +08:00
case hexagon: return "hexagon";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case mips: return "mips";
case mipsel: return "mipsel";
Add mips64 & mips64el to Triple. Patch by Liu with modifications. llvm-svn: 140157
2011-09-21 02:09:37 +08:00
case mips64: return "mips64";
case mips64el:return "mips64el";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case msp430: return "msp430";
Oops, forgot XCore. Sorry XCore! llvm-svn: 77125
2009-07-26 12:52:45 +08:00
case ppc64: return "powerpc64";
case ppc: return "powerpc";
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
case r600: return "r600";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case sparc: return "sparc";
add support for the sparcv9-*-* target triple to turn on 64-bit sparc codegen. Patch by Nathan Keynes! llvm-svn: 95293
2010-02-04 14:34:01 +08:00
case sparcv9: return "sparcv9";
Add triple parsing support for TCE. llvm-svn: 79461
2009-08-20 04:46:03 +08:00
case tce: return "tce";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case thumb: return "thumb";
case x86: return "i386";
case x86_64: return "x86_64";
Oops, forgot XCore. Sorry XCore! llvm-svn: 77125
2009-07-26 12:52:45 +08:00
case xcore: return "xcore";
Adding the MicroBlaze backend. The MicroBlaze is a highly configurable 32-bit soft-microprocessor for use on Xilinx FPGAs. For more information see: http://www.xilinx.com/tools/microblaze.htm http://en.wikipedia.org/wiki/MicroBlaze The current LLVM MicroBlaze backend generates assembly which can be compiled using the an appropriate binutils assembler. llvm-svn: 96969
2010-02-24 03:15:24 +08:00
case mblaze: return "mblaze";
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case nvptx: return "nvptx";
case nvptx64: return "nvptx64";
This patch adds support of le32 pseudo-cpu that stands for generic 32-bit little-endian CPU. Used by PNaCl and Emscripten. llvm-svn: 138335
2011-08-24 00:59:00 +08:00
case le32: return "le32";
Add AMDIL as valid target triple to LLVM. Submitted by: Villmow, Micah <Micah.Villmow@amd.com> llvm-svn: 138734
2011-08-29 23:44:55 +08:00
case amdil: return "amdil";
Add in support for SPIR to LLVM core. This adds a new target and two new calling conventions. llvm-svn: 164948
2012-10-02 01:01:31 +08:00
case spir: return "spir";
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
case spir64: return "spir64";
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
More dead code removal (using -Wunreachable-code) llvm-svn: 148578
2012-01-21 05:51:11 +08:00
llvm_unreachable("Invalid ArchType!");
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
Add llvm::Triple::getArchTypePrefix for getting the intrinsic prefix for an identifier architecture. llvm-svn: 79906
2009-08-24 17:53:06 +08:00
const char *Triple::getArchTypePrefix(ArchType Kind) {
switch (Kind) {
default:
return 0;
Add AArch64 as an experimental target. This patch adds support for AArch64 (ARM's 64-bit architecture) to LLVM in the "experimental" category. Currently, it won't be built unless requested explicitly. This initial commit should have support for: + Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions (except the late addition CRC instructions). + CodeGen features required for C++03 and C99. + Compilation for the "small" memory model: code+static data < 4GB. + Absolute and position-independent code. + GNU-style (i.e. "__thread") TLS. + Debugging information. The principal omission, currently, is performance tuning. This patch excludes the NEON support also reviewed due to an outbreak of batshit insanity in our legal department. That will be committed soon bringing the changes to precisely what has been approved. Further reviews would be gratefully received. llvm-svn: 174054
2013-01-31 20:12:40 +08:00
case aarch64: return "aarch64";
Add llvm::Triple::getArchTypePrefix for getting the intrinsic prefix for an identifier architecture. llvm-svn: 79906
2009-08-24 17:53:06 +08:00
case arm:
case thumb: return "arm";
case ppc64:
case ppc: return "ppc";
Adding the MicroBlaze backend. The MicroBlaze is a highly configurable 32-bit soft-microprocessor for use on Xilinx FPGAs. For more information see: http://www.xilinx.com/tools/microblaze.htm http://en.wikipedia.org/wiki/MicroBlaze The current LLVM MicroBlaze backend generates assembly which can be compiled using the an appropriate binutils assembler. llvm-svn: 96969
2010-02-24 03:15:24 +08:00
case mblaze: return "mblaze";
Enable automatic GCC<->LLVM intrinsic translation for mips. llvm-svn: 159367
2012-06-29 03:09:53 +08:00
case mips:
case mipsel:
case mips64:
case mips64el:return "mips";
case hexagon: return "hexagon";
Hexagon backend support llvm-svn: 146412
2011-12-13 05:14:40 +08:00
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
case r600: return "r600";
add support for the sparcv9-*-* target triple to turn on 64-bit sparc codegen. Patch by Nathan Keynes! llvm-svn: 95293
2010-02-04 14:34:01 +08:00
case sparcv9:
Add llvm::Triple::getArchTypePrefix for getting the intrinsic prefix for an identifier architecture. llvm-svn: 79906
2009-08-24 17:53:06 +08:00
case sparc: return "sparc";
case x86:
case x86_64: return "x86";
Create PTX backend. Patch by Che-Liang Chiou! llvm-svn: 113235
2010-09-08 02:14:24 +08:00
Add llvm::Triple::getArchTypePrefix for getting the intrinsic prefix for an identifier architecture. llvm-svn: 79906
2009-08-24 17:53:06 +08:00
case xcore: return "xcore";
Create PTX backend. Patch by Che-Liang Chiou! llvm-svn: 113235
2010-09-08 02:14:24 +08:00
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case nvptx: return "nvptx";
case nvptx64: return "nvptx";
This patch adds support of le32 pseudo-cpu that stands for generic 32-bit little-endian CPU. Used by PNaCl and Emscripten. llvm-svn: 138335
2011-08-24 00:59:00 +08:00
case le32: return "le32";
Add AMDIL as valid target triple to LLVM. Submitted by: Villmow, Micah <Micah.Villmow@amd.com> llvm-svn: 138734
2011-08-29 23:44:55 +08:00
case amdil: return "amdil";
Add in support for SPIR to LLVM core. This adds a new target and two new calling conventions. llvm-svn: 164948
2012-10-02 01:01:31 +08:00
case spir: return "spir";
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
case spir64: return "spir";
Add llvm::Triple::getArchTypePrefix for getting the intrinsic prefix for an identifier architecture. llvm-svn: 79906
2009-08-24 17:53:06 +08:00
}
}
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
const char *Triple::getVendorTypeName(VendorType Kind) {
switch (Kind) {
case UnknownVendor: return "unknown";
case Apple: return "apple";
fix "pc" to be lower case in a target triple, patch by Yonggang Luo llvm-svn: 79016
2009-08-15 02:48:13 +08:00
case PC: return "pc";
Add scei vendor llvm-svn: 127705
2011-03-16 05:51:56 +08:00
case SCEI: return "scei";
Add triple support for the IBM BG/P and BG/Q supercomputers. llvm-svn: 153882
2012-04-03 02:31:33 +08:00
case BGP: return "bgp";
case BGQ: return "bgq";
Add the Freescale vendor to Triple. Adds the vendor 'fsl' (used by Freescale SDK) to Triple. This will allow clang support for Freescale cross-compile configurations. Patch by Tobias von Koch. llvm-svn: 162726
2012-08-28 10:10:30 +08:00
case Freescale: return "fsl";
Add powerpc-ibm-aix to Triple. Patch by Kai. llvm-svn: 165792
2012-10-12 19:08:57 +08:00
case IBM: return "ibm";
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
More dead code removal (using -Wunreachable-code) llvm-svn: 148578
2012-01-21 05:51:11 +08:00
llvm_unreachable("Invalid VendorType!");
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
const char *Triple::getOSTypeName(OSType Kind) {
switch (Kind) {
case UnknownOS: return "unknown";
Add support for AuroraUX. Patch by evocallaghan. llvm-svn: 73766
2009-06-19 22:40:01 +08:00
case AuroraUX: return "auroraux";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case Cygwin: return "cygwin";
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
case Darwin: return "darwin";
Add llvm::triple constructor from arch, vendor, os strings, and recognize DragonFly OS type. llvm-svn: 72242
2009-05-22 10:24:11 +08:00
case DragonFly: return "dragonfly";
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
case FreeBSD: return "freebsd";
ADT/Triple: Add support for more explicit "osx" and "ios" OS names. llvm-svn: 129798
2011-04-20 04:19:27 +08:00
case IOS: return "ios";
Teach the Triple class about kfreebsd (FreeBSD kernel with a GNU userspace). llvm-svn: 136085
2011-07-26 23:30:04 +08:00
case KFreeBSD: return "kfreebsd";
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
case Linux: return "linux";
Add PS3 Triple class, Credit to John Thompson. llvm-svn: 89339
2009-11-19 19:59:00 +08:00
case Lv2: return "lv2";
ADT/Triple: Add support for Triple::MacOSX per feedback from Chris, will remove Triple::OSX once Clang has moved. llvm-svn: 129833
2011-04-20 07:34:12 +08:00
case MacOSX: return "macosx";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case MinGW32: return "mingw32";
Add NetBSD to the Triple class, patch by Krister Walfridsson! llvm-svn: 75489
2009-07-14 04:22:23 +08:00
case NetBSD: return "netbsd";
Add triple for OpenBSD. llvm-svn: 74422
2009-06-29 21:36:13 +08:00
case OpenBSD: return "openbsd";
Add Triple matching for pic16 arch and solaris OS. - Patch by Yonggang Luo. llvm-svn: 79314
2009-08-18 12:43:27 +08:00
case Solaris: return "solaris";
Update for API change. llvm-svn: 77124
2009-07-26 12:23:03 +08:00
case Win32: return "win32";
add haiku support, patch by Paul Davey! llvm-svn: 84238
2009-10-16 10:06:30 +08:00
case Haiku: return "haiku";
add some triple for minix, patch by Kees van Reeuwijk from PR7582 llvm-svn: 107785
2010-07-07 23:52:27 +08:00
case Minix: return "minix";
Add initial *-*-rtems* target, from Joel Sherrill llvm-svn: 134282
2011-07-02 06:41:06 +08:00
case RTEMS: return "rtems";
Make NaCl naming consistent. The triple OSType is called NaCl and is represented textually as NativeClient. Also added a link to the native client project for readers unfamiliar with it. A Clang patch will follow shortly. llvm-svn: 169291
2012-12-05 02:37:26 +08:00
case NaCl: return "nacl";
Add triple support for the IBM BG/P and BG/Q supercomputers. llvm-svn: 153882
2012-04-03 02:31:33 +08:00
case CNK: return "cnk";
Add support for the OpenBSD for Bitrig. Patch by David Hill. llvm-svn: 161344
2012-08-07 04:52:18 +08:00
case Bitrig: return "bitrig";
Add powerpc-ibm-aix to Triple. Patch by Kai. llvm-svn: 165792
2012-10-12 19:08:57 +08:00
case AIX: return "aix";
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
More dead code removal (using -Wunreachable-code) llvm-svn: 148578
2012-01-21 05:51:11 +08:00
llvm_unreachable("Invalid OSType");
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
switch (Kind) {
case UnknownEnvironment: return "unknown";
Clang was not parsing target triples involving EABI and was generating wrong IR (wrong PCS) and passing the wrong information down llc via the target-triple printed in IR. I've fixed this by adding the parsing of EABI into LLVM's Triple class and using it to choose the correct PCS in Clang's Tools. A Clang patch is on its way to use this infrastructure. llvm-svn: 123990
2011-01-22 02:25:47 +08:00
case GNU: return "gnu";
Add support for the gnueabihf environment. Patch by Sylvestre Ledru. llvm-svn: 148434
2012-01-19 07:35:29 +08:00
case GNUEABIHF: return "gnueabihf";
Clang was not parsing target triples involving EABI and was generating wrong IR (wrong PCS) and passing the wrong information down llc via the target-triple printed in IR. I've fixed this by adding the parsing of EABI into LLVM's Triple class and using it to choose the correct PCS in Clang's Tools. A Clang patch is on its way to use this infrastructure. llvm-svn: 123990
2011-01-22 02:25:47 +08:00
case GNUEABI: return "gnueabi";
Initial patch for x32 ABI support. Add the x32 environment kind to the triple, and separate the concept of pointer size and callee save stack slot size, since they're not equal on x32. llvm-svn: 173175
2013-01-23 02:02:49 +08:00
case GNUX32: return "gnux32";
Clang was not parsing target triples involving EABI and was generating wrong IR (wrong PCS) and passing the wrong information down llc via the target-triple printed in IR. I've fixed this by adding the parsing of EABI into LLVM's Triple class and using it to choose the correct PCS in Clang's Tools. A Clang patch is on its way to use this infrastructure. llvm-svn: 123990
2011-01-22 02:25:47 +08:00
case EABI: return "eabi";
Patches to build EFI with Clang/LLVM. By Carl Norum. llvm-svn: 124639
2011-02-01 09:14:13 +08:00
case MachO: return "macho";
Rename ANDROIDEABI to Android. Most of the code guarded with ANDROIDEABI are not ARM-specific, and having no relation with arm-eabi. Thus, it will be more natural to call this environment "Android" instead of "ANDROIDEABI". Note: We are not using ANDROID because several projects are using "-DANDROID" as the conditional compilation flag. llvm-svn: 163087
2012-09-02 17:29:46 +08:00
case Android: return "android";
Support for generating ELF objects on Windows. This adds 'elf' as a recognized target triple environment value and overrides the default generated object format on Windows platforms if that value is present. This patch also enables MCJIT tests on Windows using the new environment value. llvm-svn: 165030
2012-10-03 02:38:34 +08:00
case ELF: return "elf";
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
}
More dead code removal (using -Wunreachable-code) llvm-svn: 148578
2012-01-21 05:51:11 +08:00
llvm_unreachable("Invalid EnvironmentType!");
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
}
Pass StringRef by value. llvm-svn: 86251
2009-11-06 18:58:06 +08:00
Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
return StringSwitch<Triple::ArchType>(Name)
Add AArch64 as an experimental target. This patch adds support for AArch64 (ARM's 64-bit architecture) to LLVM in the "experimental" category. Currently, it won't be built unless requested explicitly. This initial commit should have support for: + Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions (except the late addition CRC instructions). + CodeGen features required for C++03 and C99. + Compilation for the "small" memory model: code+static data < 4GB. + Absolute and position-independent code. + GNU-style (i.e. "__thread") TLS. + Debugging information. The principal omission, currently, is performance tuning. This patch excludes the NEON support also reviewed due to an outbreak of batshit insanity in our legal department. That will be committed soon bringing the changes to precisely what has been approved. Further reviews would be gratefully received. llvm-svn: 174054
2013-01-31 20:12:40 +08:00
.Case("aarch64", aarch64)
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
.Case("arm", arm)
.Case("mips", mips)
.Case("mipsel", mipsel)
.Case("mips64", mips64)
.Case("mips64el", mips64el)
.Case("msp430", msp430)
.Case("ppc64", ppc64)
.Case("ppc32", ppc)
.Case("ppc", ppc)
.Case("mblaze", mblaze)
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
.Case("r600", r600)
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
.Case("hexagon", hexagon)
.Case("sparc", sparc)
.Case("sparcv9", sparcv9)
.Case("tce", tce)
.Case("thumb", thumb)
.Case("x86", x86)
.Case("x86-64", x86_64)
.Case("xcore", xcore)
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
.Case("nvptx", nvptx)
.Case("nvptx64", nvptx64)
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
.Case("le32", le32)
.Case("amdil", amdil)
Add in support for SPIR to LLVM core. This adds a new target and two new calling conventions. llvm-svn: 164948
2012-10-02 01:01:31 +08:00
.Case("spir", spir)
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
.Case("spir64", spir64)
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
.Default(UnknownArch);
Pass target triple string in to TargetMachine constructor. This is not just a matter of passing in the target triple from the module; currently backends are making decisions based on the build and host architecture. The goal is to migrate to making these decisions based off of the triple (in conjunction with the feature string). Thus most clients pass in the target triple, or the host triple if that is empty. This has one important change in the way behavior of the JIT and llc. For the JIT, it was previously selecting the Target based on the host (naturally), but it was setting the target machine features based on the triple from the module. Now it is setting the target machine features based on the triple of the host. For LLC, -march was previously only used to select the target, the target machine features were initialized from the module's triple (which may have been empty). Now the target triple is taken from the module, or the host's triple is used if that is empty. Then the triple is adjusted to match -march. The take away is that -march for llc is now used in conjunction with the host triple to initialize the subtarget. If users want more deterministic behavior from llc, they should use -mtriple, or set the triple in the input module. llvm-svn: 77946
2009-08-03 12:03:51 +08:00
}
Fix comment typo. llvm-svn: 99392
2010-03-24 17:05:14 +08:00
// Returns architecture name that is understood by the target assembler.
Added getArchNameForAssembler method to the Triple class for which returns OS and Vendor independent target assembler arch. llvm-svn: 89122
2009-11-18 02:48:27 +08:00
const char *Triple::getArchNameForAssembler() {
ADT/Triple: Add isOSDarwin() and isOSWindows() helper functions. llvm-svn: 129815
2011-04-20 05:12:05 +08:00
if (!isOSDarwin() && getVendor() != Triple::Apple)
Added getArchNameForAssembler method to the Triple class for which returns OS and Vendor independent target assembler arch. llvm-svn: 89122
2009-11-18 02:48:27 +08:00
return NULL;
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
return StringSwitch<const char*>(getArchName())
.Case("i386", "i386")
.Case("x86_64", "x86_64")
.Case("powerpc", "ppc")
.Case("powerpc64", "ppc64")
.Cases("mblaze", "microblaze", "mblaze")
.Case("arm", "arm")
.Cases("armv4t", "thumbv4t", "armv4t")
.Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
.Cases("armv6", "thumbv6", "armv6")
.Cases("armv7", "thumbv7", "armv7")
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
.Case("r600", "r600")
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
.Case("nvptx", "nvptx")
.Case("nvptx64", "nvptx64")
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
.Case("le32", "le32")
.Case("amdil", "amdil")
Add in support for SPIR to LLVM core. This adds a new target and two new calling conventions. llvm-svn: 164948
2012-10-02 01:01:31 +08:00
.Case("spir", "spir")
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
.Case("spir64", "spir64")
Switch a bunch of manual if-chains to use StringSwitch. Clean them up in the process. Some of these are still a bit gross. Still, this cuts 80 some lines out of this ridiculous file. ;] llvm-svn: 150331
2012-02-12 17:27:38 +08:00
.Default(NULL);
Added getArchNameForAssembler method to the Triple class for which returns OS and Vendor independent target assembler arch. llvm-svn: 89122
2009-11-18 02:48:27 +08:00
}
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
static Triple::ArchType parseArch(StringRef ArchName) {
return StringSwitch<Triple::ArchType>(ArchName)
.Cases("i386", "i486", "i586", "i686", Triple::x86)
// FIXME: Do we need to support these?
.Cases("i786", "i886", "i986", Triple::x86)
.Cases("amd64", "x86_64", Triple::x86_64)
.Case("powerpc", Triple::ppc)
.Cases("powerpc64", "ppu", Triple::ppc64)
.Case("mblaze", Triple::mblaze)
Add AArch64 as an experimental target. This patch adds support for AArch64 (ARM's 64-bit architecture) to LLVM in the "experimental" category. Currently, it won't be built unless requested explicitly. This initial commit should have support for: + Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions (except the late addition CRC instructions). + CodeGen features required for C++03 and C99. + Compilation for the "small" memory model: code+static data < 4GB. + Absolute and position-independent code. + GNU-style (i.e. "__thread") TLS. + Debugging information. The principal omission, currently, is performance tuning. This patch excludes the NEON support also reviewed due to an outbreak of batshit insanity in our legal department. That will be committed soon bringing the changes to precisely what has been approved. Further reviews would be gratefully received. llvm-svn: 174054
2013-01-31 20:12:40 +08:00
.Case("aarch64", Triple::aarch64)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Cases("arm", "xscale", Triple::arm)
Trivial cleanup to group the generic 'armvN' cases with the 'arm' case, etc. No functionality changed. llvm-svn: 150867
2012-02-18 12:34:17 +08:00
// FIXME: It would be good to replace these with explicit names for all the
// various suffixes supported.
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.StartsWith("armv", Triple::arm)
.Case("thumb", Triple::thumb)
.StartsWith("thumbv", Triple::thumb)
.Case("msp430", Triple::msp430)
.Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
Support was removed from LLVM's MIPS backend for the PSP variant of that chip in r139383, and the PSP components of the triple are really annoying to parse. Let's leave this chapter behind. There is no reason to expect LLVM to see a PSP-related triple these days, and so no reasonable motivation to support them. It might be reasonable to prune a few of the older MIPS triple forms in general, but as those at least cause no burden on parsing (they aren't both a chip and an OS!), I'm happy to leave them in for now. llvm-svn: 151156
2012-02-22 19:32:54 +08:00
.Cases("mipsel", "mipsallegrexel", Triple::mipsel)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Cases("mips64", "mips64eb", Triple::mips64)
.Case("mips64el", Triple::mips64el)
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
.Case("r600", Triple::r600)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Case("hexagon", Triple::hexagon)
.Case("sparc", Triple::sparc)
.Case("sparcv9", Triple::sparcv9)
.Case("tce", Triple::tce)
.Case("xcore", Triple::xcore)
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
.Case("nvptx", Triple::nvptx)
.Case("nvptx64", Triple::nvptx64)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Case("le32", Triple::le32)
.Case("amdil", Triple::amdil)
Add in support for SPIR to LLVM core. This adds a new target and two new calling conventions. llvm-svn: 164948
2012-10-02 01:01:31 +08:00
.Case("spir", Triple::spir)
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
.Case("spir64", Triple::spir64)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Default(Triple::UnknownArch);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
}
Improve Triple to recognize the OS in i386-mingw32. llvm-svn: 79359
2009-08-19 03:26:55 +08:00
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
static Triple::VendorType parseVendor(StringRef VendorName) {
return StringSwitch<Triple::VendorType>(VendorName)
.Case("apple", Triple::Apple)
.Case("pc", Triple::PC)
.Case("scei", Triple::SCEI)
Add triple support for the IBM BG/P and BG/Q supercomputers. llvm-svn: 153882
2012-04-03 02:31:33 +08:00
.Case("bgp", Triple::BGP)
.Case("bgq", Triple::BGQ)
Add the Freescale vendor to Triple. Adds the vendor 'fsl' (used by Freescale SDK) to Triple. This will allow clang support for Freescale cross-compile configurations. Patch by Tobias von Koch. llvm-svn: 162726
2012-08-28 10:10:30 +08:00
.Case("fsl", Triple::Freescale)
Add powerpc-ibm-aix to Triple. Patch by Kai. llvm-svn: 165792
2012-10-12 19:08:57 +08:00
.Case("ibm", Triple::IBM)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Default(Triple::UnknownVendor);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
}
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
static Triple::OSType parseOS(StringRef OSName) {
return StringSwitch<Triple::OSType>(OSName)
.StartsWith("auroraux", Triple::AuroraUX)
.StartsWith("cygwin", Triple::Cygwin)
.StartsWith("darwin", Triple::Darwin)
.StartsWith("dragonfly", Triple::DragonFly)
.StartsWith("freebsd", Triple::FreeBSD)
.StartsWith("ios", Triple::IOS)
.StartsWith("kfreebsd", Triple::KFreeBSD)
.StartsWith("linux", Triple::Linux)
.StartsWith("lv2", Triple::Lv2)
.StartsWith("macosx", Triple::MacOSX)
.StartsWith("mingw32", Triple::MinGW32)
.StartsWith("netbsd", Triple::NetBSD)
.StartsWith("openbsd", Triple::OpenBSD)
.StartsWith("solaris", Triple::Solaris)
.StartsWith("win32", Triple::Win32)
.StartsWith("haiku", Triple::Haiku)
.StartsWith("minix", Triple::Minix)
.StartsWith("rtems", Triple::RTEMS)
Make NaCl naming consistent. The triple OSType is called NaCl and is represented textually as NativeClient. Also added a link to the native client project for readers unfamiliar with it. A Clang patch will follow shortly. llvm-svn: 169291
2012-12-05 02:37:26 +08:00
.StartsWith("nacl", Triple::NaCl)
Add triple support for the IBM BG/P and BG/Q supercomputers. llvm-svn: 153882
2012-04-03 02:31:33 +08:00
.StartsWith("cnk", Triple::CNK)
Add support for the OpenBSD for Bitrig. Patch by David Hill. llvm-svn: 161344
2012-08-07 04:52:18 +08:00
.StartsWith("bitrig", Triple::Bitrig)
Add powerpc-ibm-aix to Triple. Patch by Kai. llvm-svn: 165792
2012-10-12 19:08:57 +08:00
.StartsWith("aix", Triple::AIX)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Default(Triple::UnknownOS);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
}
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
.StartsWith("eabi", Triple::EABI)
.StartsWith("gnueabihf", Triple::GNUEABIHF)
.StartsWith("gnueabi", Triple::GNUEABI)
Initial patch for x32 ABI support. Add the x32 environment kind to the triple, and separate the concept of pointer size and callee save stack slot size, since they're not equal on x32. llvm-svn: 173175
2013-01-23 02:02:49 +08:00
.StartsWith("gnux32", Triple::GNUX32)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.StartsWith("gnu", Triple::GNU)
.StartsWith("macho", Triple::MachO)
Rename ANDROIDEABI to Android. Most of the code guarded with ANDROIDEABI are not ARM-specific, and having no relation with arm-eabi. Thus, it will be more natural to call this environment "Android" instead of "ANDROIDEABI". Note: We are not using ANDROID because several projects are using "-DANDROID" as the conditional compilation flag. llvm-svn: 163087
2012-09-02 17:29:46 +08:00
.StartsWith("android", Triple::Android)
Support for generating ELF objects on Windows. This adds 'elf' as a recognized target triple environment value and overrides the default generated object format on Windows platforms if that value is present. This patch also enables MCJIT tests on Windows using the new environment value. llvm-svn: 165030
2012-10-03 02:38:34 +08:00
.StartsWith("elf", Triple::ELF)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
.Default(Triple::UnknownEnvironment);
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
}
Move constructors out-of-line and flesh out their documentation. No functionality changed. This is in preparation for some refactoring of how this class behaves. llvm-svn: 150941
2012-02-20 08:02:47 +08:00
/// \brief Construct a triple from the string representation provided.
///
Clean up comments that I missed when changing the triple representation. Somehow, I even missed the ones I wrote just the other day... Thanks to Matt for the code review. llvm-svn: 151045
2012-02-21 16:31:18 +08:00
/// This stores the string representation and parses the various pieces into
/// enum members.
Switch the llvm::Triple class to immediately parse the triple string on construction. Simplify its interface, implementation, and users accordingly as there is no longer an 'uninitialized' state to check for. Also, fixes a bug lurking in the interface as there was one method that didn't correctly check for initialization. llvm-svn: 151024
2012-02-21 11:39:36 +08:00
Triple::Triple(const Twine &Str)
: Data(Str.str()),
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Arch(parseArch(getArchName())),
Vendor(parseVendor(getVendorName())),
OS(parseOS(getOSName())),
Environment(parseEnvironment(getEnvironmentName())) {
Switch the llvm::Triple class to immediately parse the triple string on construction. Simplify its interface, implementation, and users accordingly as there is no longer an 'uninitialized' state to check for. Also, fixes a bug lurking in the interface as there was one method that didn't correctly check for initialization. llvm-svn: 151024
2012-02-21 11:39:36 +08:00
}
Move constructors out-of-line and flesh out their documentation. No functionality changed. This is in preparation for some refactoring of how this class behaves. llvm-svn: 150941
2012-02-20 08:02:47 +08:00
/// \brief Construct a triple from string representations of the architecture,
/// vendor, and OS.
///
Clean up comments that I missed when changing the triple representation. Somehow, I even missed the ones I wrote just the other day... Thanks to Matt for the code review. llvm-svn: 151045
2012-02-21 16:31:18 +08:00
/// This joins each argument into a canonical string representation and parses
/// them into enum members. It leaves the environment unknown and omits it from
/// the string representation.
Move constructors out-of-line and flesh out their documentation. No functionality changed. This is in preparation for some refactoring of how this class behaves. llvm-svn: 150941
2012-02-20 08:02:47 +08:00
Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
: Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Arch(parseArch(ArchStr.str())),
Vendor(parseVendor(VendorStr.str())),
OS(parseOS(OSStr.str())),
Switch the llvm::Triple class to immediately parse the triple string on construction. Simplify its interface, implementation, and users accordingly as there is no longer an 'uninitialized' state to check for. Also, fixes a bug lurking in the interface as there was one method that didn't correctly check for initialization. llvm-svn: 151024
2012-02-21 11:39:36 +08:00
Environment() {
Move constructors out-of-line and flesh out their documentation. No functionality changed. This is in preparation for some refactoring of how this class behaves. llvm-svn: 150941
2012-02-20 08:02:47 +08:00
}
/// \brief Construct a triple from string representations of the architecture,
/// vendor, OS, and environment.
///
Clean up comments that I missed when changing the triple representation. Somehow, I even missed the ones I wrote just the other day... Thanks to Matt for the code review. llvm-svn: 151045
2012-02-21 16:31:18 +08:00
/// This joins each argument into a canonical string representation and parses
/// them into enum members.
Move constructors out-of-line and flesh out their documentation. No functionality changed. This is in preparation for some refactoring of how this class behaves. llvm-svn: 150941
2012-02-20 08:02:47 +08:00
Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
const Twine &EnvironmentStr)
: Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
EnvironmentStr).str()),
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Arch(parseArch(ArchStr.str())),
Vendor(parseVendor(VendorStr.str())),
OS(parseOS(OSStr.str())),
Environment(parseEnvironment(EnvironmentStr.str())) {
Move constructors out-of-line and flesh out their documentation. No functionality changed. This is in preparation for some refactoring of how this class behaves. llvm-svn: 150941
2012-02-20 08:02:47 +08:00
}
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
std::string Triple::normalize(StringRef Str) {
// Parse into components.
SmallVector<StringRef, 4> Components;
Replace a hand rolled loop with a lovely StringRef helper we have these days. No functionality changed. llvm-svn: 151048
2012-02-21 17:12:48 +08:00
Str.split(Components, "-");
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
// If the first component corresponds to a known architecture, preferentially
// use it for the architecture. If the second component corresponds to a
// known vendor, preferentially use it for the vendor, etc. This avoids silly
// component movement when a component parses as (eg) both a valid arch and a
// valid os.
ArchType Arch = UnknownArch;
if (Components.size() > 0)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Arch = parseArch(Components[0]);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
VendorType Vendor = UnknownVendor;
if (Components.size() > 1)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Vendor = parseVendor(Components[1]);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
OSType OS = UnknownOS;
if (Components.size() > 2)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
OS = parseOS(Components[2]);
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
EnvironmentType Environment = UnknownEnvironment;
if (Components.size() > 3)
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Environment = parseEnvironment(Components[3]);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
// Note which components are already in their final position. These will not
// be moved.
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
bool Found[4];
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
Found[0] = Arch != UnknownArch;
Found[1] = Vendor != UnknownVendor;
Found[2] = OS != UnknownOS;
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
Found[3] = Environment != UnknownEnvironment;
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
// If they are not there already, permute the components into their canonical
// positions by seeing if they parse as a valid architecture, and if so moving
// the component to the architecture position etc.
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
if (Found[Pos])
continue; // Already in the canonical position.
for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
// Do not reparse any components that already matched.
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
if (Idx < array_lengthof(Found) && Found[Idx])
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
continue;
// Does this component parse as valid for the target position?
bool Valid = false;
StringRef Comp = Components[Idx];
switch (Pos) {
Convert assert(0) to llvm_unreachable llvm-svn: 149967
2012-02-07 13:05:23 +08:00
default: llvm_unreachable("unexpected component type!");
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
case 0:
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Arch = parseArch(Comp);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
Valid = Arch != UnknownArch;
break;
case 1:
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Vendor = parseVendor(Comp);
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
Valid = Vendor != UnknownVendor;
break;
case 2:
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
OS = parseOS(Comp);
Remove NoVendor and NoOS, added in commit 123990, from Triple. While it may be useful to understand "none", this is not the place for it. Tweak the fix to Normalize while there: the fix added in 123990 works correctly, but I like this way better. Finally, now that Triple understands some non-trivial environment values, teach the unittests about them. llvm-svn: 124720
2011-02-02 18:08:38 +08:00
Valid = OS != UnknownOS;
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
break;
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
case 3:
Pull the parsing helper functions out of the Triple interface entirely. They're private static methods but we can just make them static functions in the implementation. It makes the implementations a touch more wordy, but takes another chunk out of the header file. Also, take the opportunity to switch the names to the new coding conventions. No functionality changed here. llvm-svn: 151047
2012-02-21 16:53:32 +08:00
Environment = parseEnvironment(Comp);
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
Valid = Environment != UnknownEnvironment;
break;
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
}
if (!Valid)
continue; // Nope, try the next component.
// Move the component to the target position, pushing any non-fixed
// components that are in the way to the right. This tends to give
// good results in the common cases of a forgotten vendor component
// or a wrongly positioned environment.
if (Pos < Idx) {
// Insert left, pushing the existing components to the right. For
// example, a-b-i386 -> i386-a-b when moving i386 to the front.
StringRef CurrentComponent(""); // The empty component.
// Replace the component we are moving with an empty component.
std::swap(CurrentComponent, Components[Idx]);
// Insert the component being moved at Pos, displacing any existing
// components to the right.
for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
// Skip over any fixed components.
Tiny cosmetic change to use the same style for all of the while loops in the normalize routine, especially the empty while loops. llvm-svn: 151050
2012-02-21 17:29:14 +08:00
while (i < array_lengthof(Found) && Found[i])
++i;
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
// Place the component at the new position, getting the component
// that was at this position - it will be moved right.
std::swap(CurrentComponent, Components[i]);
}
} else if (Pos > Idx) {
// Push right by inserting empty components until the component at Idx
// reaches the target position Pos. For example, pc-a -> -pc-a when
// moving pc to the second position.
do {
// Insert one empty component at Idx.
StringRef CurrentComponent(""); // The empty component.
Remove NoVendor and NoOS, added in commit 123990, from Triple. While it may be useful to understand "none", this is not the place for it. Tweak the fix to Normalize while there: the fix added in 123990 works correctly, but I like this way better. Finally, now that Triple understands some non-trivial environment values, teach the unittests about them. llvm-svn: 124720
2011-02-02 18:08:38 +08:00
for (unsigned i = Idx; i < Components.size();) {
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
// Place the component at the new position, getting the component
// that was at this position - it will be moved right.
std::swap(CurrentComponent, Components[i]);
// If it was placed on top of an empty component then we are done.
if (CurrentComponent.empty())
break;
Remove NoVendor and NoOS, added in commit 123990, from Triple. While it may be useful to understand "none", this is not the place for it. Tweak the fix to Normalize while there: the fix added in 123990 works correctly, but I like this way better. Finally, now that Triple understands some non-trivial environment values, teach the unittests about them. llvm-svn: 124720
2011-02-02 18:08:38 +08:00
// Advance to the next component, skipping any fixed components.
Fix a clang warning. llvm-svn: 124960
2011-02-06 02:19:35 +08:00
while (++i < array_lengthof(Found) && Found[i])
;
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
}
// The last component was pushed off the end - append it.
if (!CurrentComponent.empty())
Components.push_back(CurrentComponent);
// Advance Idx to the component's new position.
Tiny cosmetic change to use the same style for all of the while loops in the normalize routine, especially the empty while loops. llvm-svn: 151050
2012-02-21 17:29:14 +08:00
while (++Idx < array_lengthof(Found) && Found[Idx])
;
Add a 'normalize' method to the Triple class, which takes a mucked up target triple and straightens it out. This does less than gcc's script config.sub, for example it turns i386-mingw32 into i386--mingw32 not i386-pc-mingw32, but it does a decent job of turning funky triples into something that the rest of the Triple class can understand. The plan is to use this to canonicalize triple's when they are first provided by users, and have the rest of LLVM only deal with canonical triples. Once this is done the special case workarounds in the Triple constructor can be removed, making the class more regular and easier to use. The comments and unittests for the Triple class are already adjusted in this patch appropriately for this brave new world of increased uniformity. llvm-svn: 110909
2010-08-12 19:31:39 +08:00
} while (Idx < Pos); // Add more until the final position is reached.
}
assert(Pos < Components.size() && Components[Pos] == Comp &&
"Component moved wrong!");
Found[Pos] = true;
break;
}
}
// Special case logic goes here. At this point Arch, Vendor and OS have the
// correct values for the computed components.
// Stick the corrected components back together to form the normalized string.
std::string Normalized;
for (unsigned i = 0, e = Components.size(); i != e; ++i) {
if (i) Normalized += '-';
Normalized += Components[i];
}
return Normalized;
}
Update Triple to use StringRef/Twine based APIs. - This is now shorter, simpler, safer, and more efficient, what a deal. llvm-svn: 77119
2009-07-26 11:31:47 +08:00
StringRef Triple::getArchName() const {
return StringRef(Data).split('-').first; // Isolate first component
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
Update Triple to use StringRef/Twine based APIs. - This is now shorter, simpler, safer, and more efficient, what a deal. llvm-svn: 77119
2009-07-26 11:31:47 +08:00
StringRef Triple::getVendorName() const {
StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
return Tmp.split('-').first; // Isolate second component
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
Update Triple to use StringRef/Twine based APIs. - This is now shorter, simpler, safer, and more efficient, what a deal. llvm-svn: 77119
2009-07-26 11:31:47 +08:00
StringRef Triple::getOSName() const {
StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
Tmp = Tmp.split('-').second; // Strip second component
return Tmp.split('-').first; // Isolate third component
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
Update Triple to use StringRef/Twine based APIs. - This is now shorter, simpler, safer, and more efficient, what a deal. llvm-svn: 77119
2009-07-26 11:31:47 +08:00
StringRef Triple::getEnvironmentName() const {
StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
Tmp = Tmp.split('-').second; // Strip second component
return Tmp.split('-').second; // Strip third component
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
Update Triple to use StringRef/Twine based APIs. - This is now shorter, simpler, safer, and more efficient, what a deal. llvm-svn: 77119
2009-07-26 11:31:47 +08:00
StringRef Triple::getOSAndEnvironmentName() const {
StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
return Tmp.split('-').second; // Strip second component
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
add a couple of helpers to the Triple class for decoding the darwin version string. This should help consolidate the variety of weird functions we have scattered around the codebase that do stuff like this. llvm-svn: 78792
2009-08-12 14:19:40 +08:00
static unsigned EatNumber(StringRef &Str) {
assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
unsigned Result = 0;
Trailing whitespace and 80 column fixups. llvm-svn: 122026
2010-12-17 10:10:59 +08:00
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
do {
// Consume the leading digit.
add a couple of helpers to the Triple class for decoding the darwin version string. This should help consolidate the variety of weird functions we have scattered around the codebase that do stuff like this. llvm-svn: 78792
2009-08-12 14:19:40 +08:00
Result = Result*10 + (Str[0] - '0');
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
add a couple of helpers to the Triple class for decoding the darwin version string. This should help consolidate the variety of weird functions we have scattered around the codebase that do stuff like this. llvm-svn: 78792
2009-08-12 14:19:40 +08:00
// Eat the digit.
Str = Str.substr(1);
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
} while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
Trailing whitespace and 80 column fixups. llvm-svn: 122026
2010-12-17 10:10:59 +08:00
add a couple of helpers to the Triple class for decoding the darwin version string. This should help consolidate the variety of weird functions we have scattered around the codebase that do stuff like this. llvm-svn: 78792
2009-08-12 14:19:40 +08:00
return Result;
}
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
unsigned &Micro) const {
add a couple of helpers to the Triple class for decoding the darwin version string. This should help consolidate the variety of weird functions we have scattered around the codebase that do stuff like this. llvm-svn: 78792
2009-08-12 14:19:40 +08:00
StringRef OSName = getOSName();
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
// Assume that the OS portion of the triple starts with the canonical name.
StringRef OSTypeName = getOSTypeName(getOS());
if (OSName.startswith(OSTypeName))
OSName = OSName.substr(OSTypeName.size());
Trailing whitespace and 80 column fixups. llvm-svn: 122026
2010-12-17 10:10:59 +08:00
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
// Any unset version defaults to 0.
Major = Minor = Micro = 0;
Trailing whitespace and 80 column fixups. llvm-svn: 122026
2010-12-17 10:10:59 +08:00
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
// Parse up to three components.
unsigned *Components[3] = { &Major, &Minor, &Micro };
for (unsigned i = 0; i != 3; ++i) {
if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
break;
Trailing whitespace and 80 column fixups. llvm-svn: 122026
2010-12-17 10:10:59 +08:00
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
// Consume the leading number.
*Components[i] = EatNumber(OSName);
add a couple of helpers to the Triple class for decoding the darwin version string. This should help consolidate the variety of weird functions we have scattered around the codebase that do stuff like this. llvm-svn: 78792
2009-08-12 14:19:40 +08:00
ADT/Triple: Generalize and simplify getDarwinNumber to just be getOSVersion. llvm-svn: 129799
2011-04-20 04:24:34 +08:00
// Consume the separator, if present.
if (OSName.startswith("."))
OSName = OSName.substr(1);
}
add a couple of helpers to the Triple class for decoding the darwin version string. This should help consolidate the variety of weird functions we have scattered around the codebase that do stuff like this. llvm-svn: 78792
2009-08-12 14:19:40 +08:00
}
Add Triple::getMacOSXVersion to replace crufty code in the clang driver. This new function provides a way to get the Mac OS X version number from either generic "darwin" triples of macosx triples. llvm-svn: 149438
2012-02-01 06:32:29 +08:00
bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
unsigned &Micro) const {
getOSVersion(Major, Minor, Micro);
switch (getOS()) {
Convert assert(0) to llvm_unreachable llvm-svn: 149967
2012-02-07 13:05:23 +08:00
default: llvm_unreachable("unexpected OS for Darwin triple");
Add Triple::getMacOSXVersion to replace crufty code in the clang driver. This new function provides a way to get the Mac OS X version number from either generic "darwin" triples of macosx triples. llvm-svn: 149438
2012-02-01 06:32:29 +08:00
case Darwin:
// Default to darwin8, i.e., MacOSX 10.4.
if (Major == 0)
Major = 8;
// Darwin version numbers are skewed from OS X versions.
if (Major < 4)
return false;
Micro = 0;
Minor = Major - 4;
Major = 10;
break;
case MacOSX:
// Default to 10.4.
if (Major == 0) {
Major = 10;
Minor = 4;
}
if (Major != 10)
return false;
break;
case IOS:
// Ignore the version from the triple. This is only handled because the
// the clang driver combines OS X and IOS support into a common Darwin
// toolchain that wants to know the OS X version number even when targeting
// IOS.
Major = 10;
Minor = 4;
Micro = 0;
break;
}
return true;
}
Add Triple::getiOSVersion. This new function provides a way to get the iOS version number from ios triples. Part of rdar://11409204 llvm-svn: 156483
2012-05-10 01:23:48 +08:00
void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
unsigned &Micro) const {
switch (getOS()) {
default: llvm_unreachable("unexpected OS for Darwin triple");
case Darwin:
case MacOSX:
// Ignore the version from the triple. This is only handled because the
// the clang driver combines OS X and IOS support into a common Darwin
// toolchain that wants to know the iOS version number even when targeting
// OS X.
Set the default iOS version to 3.0. llvm-svn: 156492
2012-05-10 02:23:00 +08:00
Major = 3;
Add Triple::getiOSVersion. This new function provides a way to get the iOS version number from ios triples. Part of rdar://11409204 llvm-svn: 156483
2012-05-10 01:23:48 +08:00
Minor = 0;
Micro = 0;
Don't return true on a function with a void return type. llvm-svn: 156484
2012-05-10 01:38:47 +08:00
break;
Add Triple::getiOSVersion. This new function provides a way to get the iOS version number from ios triples. Part of rdar://11409204 llvm-svn: 156483
2012-05-10 01:23:48 +08:00
case IOS:
getOSVersion(Major, Minor, Micro);
Set the default iOS version to 3.0. llvm-svn: 156492
2012-05-10 02:23:00 +08:00
// Default to 3.0.
if (Major == 0)
Major = 3;
Add Triple::getiOSVersion. This new function provides a way to get the iOS version number from ios triples. Part of rdar://11409204 llvm-svn: 156483
2012-05-10 01:23:48 +08:00
break;
}
}
Update Triple to use StringRef/Twine based APIs. - This is now shorter, simpler, safer, and more efficient, what a deal. llvm-svn: 77119
2009-07-26 11:31:47 +08:00
void Triple::setTriple(const Twine &Str) {
Switch the llvm::Triple class to immediately parse the triple string on construction. Simplify its interface, implementation, and users accordingly as there is no longer an 'uninitialized' state to check for. Also, fixes a bug lurking in the interface as there was one method that didn't correctly check for initialization. llvm-svn: 151024
2012-02-21 11:39:36 +08:00
*this = Triple(Str);
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
void Triple::setArch(ArchType Kind) {
setArchName(getArchTypeName(Kind));
}
void Triple::setVendor(VendorType Kind) {
setVendorName(getVendorTypeName(Kind));
}
void Triple::setOS(OSType Kind) {
setOSName(getOSTypeName(Kind));
}
Add better support for environment portion of triple. Original patch by Cameron Esfahani, tweaked to use array_lengthof. llvm-svn: 114073
2010-09-16 16:25:48 +08:00
void Triple::setEnvironment(EnvironmentType Kind) {
setEnvironmentName(getEnvironmentTypeName(Kind));
}
Pass StringRef by value. llvm-svn: 86251
2009-11-06 18:58:06 +08:00
void Triple::setArchName(StringRef Str) {
r83391 was completely broken since Twines keep references to their inputs, and some of the inputs were temporaries. Here's a real fix for the miscompilation. Thanks to sabre for pointing out the problem. llvm-svn: 83417
2009-10-07 05:45:26 +08:00
// Work around a miscompilation bug for Twines in gcc 4.0.3.
SmallString<64> Triple;
Triple += Str;
Triple += "-";
Triple += getVendorName();
Triple += "-";
Triple += getOSAndEnvironmentName();
setTriple(Triple.str());
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
}
Pass StringRef by value. llvm-svn: 86251
2009-11-06 18:58:06 +08:00
void Triple::setVendorName(StringRef Str) {
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
}
Pass StringRef by value. llvm-svn: 86251
2009-11-06 18:58:06 +08:00
void Triple::setOSName(StringRef Str) {
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
if (hasEnvironment())
setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
"-" + getEnvironmentName());
else
setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
}
Pass StringRef by value. llvm-svn: 86251
2009-11-06 18:58:06 +08:00
void Triple::setEnvironmentName(StringRef Str) {
setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
"-" + Str);
}
Pass StringRef by value. llvm-svn: 86251
2009-11-06 18:58:06 +08:00
void Triple::setOSAndEnvironmentName(StringRef Str) {
Add llvm::Triple class for abstracting access to target triples. - The code is silly, I'm just amusing myself. Rewrite to be efficient if you like. :) Also, if you wish to debate the proper names of the triple components I'm all ears. llvm-svn: 68252
2009-04-02 05:53:23 +08:00
setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
}
Add various coarse bit-width architecture predicates to llvm::Triple. These are very useful for frontends and other utilities reasoning about or selecting between triples. llvm-svn: 149353
2012-01-31 12:52:32 +08:00
static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
switch (Arch) {
case llvm::Triple::UnknownArch:
return 0;
case llvm::Triple::msp430:
return 16;
case llvm::Triple::amdil:
case llvm::Triple::arm:
case llvm::Triple::hexagon:
case llvm::Triple::le32:
case llvm::Triple::mblaze:
case llvm::Triple::mips:
case llvm::Triple::mipsel:
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case llvm::Triple::nvptx:
Add various coarse bit-width architecture predicates to llvm::Triple. These are very useful for frontends and other utilities reasoning about or selecting between triples. llvm-svn: 149353
2012-01-31 12:52:32 +08:00
case llvm::Triple::ppc:
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
case llvm::Triple::r600:
Add various coarse bit-width architecture predicates to llvm::Triple. These are very useful for frontends and other utilities reasoning about or selecting between triples. llvm-svn: 149353
2012-01-31 12:52:32 +08:00
case llvm::Triple::sparc:
case llvm::Triple::tce:
case llvm::Triple::thumb:
case llvm::Triple::x86:
case llvm::Triple::xcore:
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
case llvm::Triple::spir:
Add various coarse bit-width architecture predicates to llvm::Triple. These are very useful for frontends and other utilities reasoning about or selecting between triples. llvm-svn: 149353
2012-01-31 12:52:32 +08:00
return 32;
Add AArch64 as an experimental target. This patch adds support for AArch64 (ARM's 64-bit architecture) to LLVM in the "experimental" category. Currently, it won't be built unless requested explicitly. This initial commit should have support for: + Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions (except the late addition CRC instructions). + CodeGen features required for C++03 and C99. + Compilation for the "small" memory model: code+static data < 4GB. + Absolute and position-independent code. + GNU-style (i.e. "__thread") TLS. + Debugging information. The principal omission, currently, is performance tuning. This patch excludes the NEON support also reviewed due to an outbreak of batshit insanity in our legal department. That will be committed soon bringing the changes to precisely what has been approved. Further reviews would be gratefully received. llvm-svn: 174054
2013-01-31 20:12:40 +08:00
case llvm::Triple::aarch64:
Add various coarse bit-width architecture predicates to llvm::Triple. These are very useful for frontends and other utilities reasoning about or selecting between triples. llvm-svn: 149353
2012-01-31 12:52:32 +08:00
case llvm::Triple::mips64:
case llvm::Triple::mips64el:
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case llvm::Triple::nvptx64:
Add various coarse bit-width architecture predicates to llvm::Triple. These are very useful for frontends and other utilities reasoning about or selecting between triples. llvm-svn: 149353
2012-01-31 12:52:32 +08:00
case llvm::Triple::ppc64:
case llvm::Triple::sparcv9:
case llvm::Triple::x86_64:
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
case llvm::Triple::spir64:
Add various coarse bit-width architecture predicates to llvm::Triple. These are very useful for frontends and other utilities reasoning about or selecting between triples. llvm-svn: 149353
2012-01-31 12:52:32 +08:00
return 64;
}
llvm_unreachable("Invalid architecture value");
}
bool Triple::isArch64Bit() const {
return getArchPointerBitWidth(getArch()) == 64;
}
bool Triple::isArch32Bit() const {
return getArchPointerBitWidth(getArch()) == 32;
}
bool Triple::isArch16Bit() const {
return getArchPointerBitWidth(getArch()) == 16;
}
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
Triple Triple::get32BitArchVariant() const {
Triple T(*this);
switch (getArch()) {
case Triple::UnknownArch:
Add AArch64 as an experimental target. This patch adds support for AArch64 (ARM's 64-bit architecture) to LLVM in the "experimental" category. Currently, it won't be built unless requested explicitly. This initial commit should have support for: + Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions (except the late addition CRC instructions). + CodeGen features required for C++03 and C99. + Compilation for the "small" memory model: code+static data < 4GB. + Absolute and position-independent code. + GNU-style (i.e. "__thread") TLS. + Debugging information. The principal omission, currently, is performance tuning. This patch excludes the NEON support also reviewed due to an outbreak of batshit insanity in our legal department. That will be committed soon bringing the changes to precisely what has been approved. Further reviews would be gratefully received. llvm-svn: 174054
2013-01-31 20:12:40 +08:00
case Triple::aarch64:
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::msp430:
T.setArch(UnknownArch);
break;
case Triple::amdil:
Add in support for SPIR to LLVM core. This adds a new target and two new calling conventions. llvm-svn: 164948
2012-10-02 01:01:31 +08:00
case Triple::spir:
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::arm:
case Triple::hexagon:
case Triple::le32:
case Triple::mblaze:
case Triple::mips:
case Triple::mipsel:
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case Triple::nvptx:
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::ppc:
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
case Triple::r600:
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::sparc:
case Triple::tce:
case Triple::thumb:
case Triple::x86:
case Triple::xcore:
// Already 32-bit.
break;
case Triple::mips64: T.setArch(Triple::mips); break;
case Triple::mips64el: T.setArch(Triple::mipsel); break;
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case Triple::nvptx64: T.setArch(Triple::nvptx); break;
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::ppc64: T.setArch(Triple::ppc); break;
case Triple::sparcv9: T.setArch(Triple::sparc); break;
case Triple::x86_64: T.setArch(Triple::x86); break;
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
case Triple::spir64: T.setArch(Triple::spir); break;
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
}
return T;
}
Triple Triple::get64BitArchVariant() const {
Triple T(*this);
switch (getArch()) {
case Triple::UnknownArch:
case Triple::amdil:
case Triple::arm:
case Triple::hexagon:
case Triple::le32:
case Triple::mblaze:
case Triple::msp430:
Add support for r600 (AMD GPUs HD2XXX - HD6XXX) target triplet. Patch by Tom Stellard! llvm-svn: 152400
2012-03-09 18:09:36 +08:00
case Triple::r600:
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::tce:
case Triple::thumb:
case Triple::xcore:
T.setArch(UnknownArch);
break;
Add AArch64 as an experimental target. This patch adds support for AArch64 (ARM's 64-bit architecture) to LLVM in the "experimental" category. Currently, it won't be built unless requested explicitly. This initial commit should have support for: + Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions (except the late addition CRC instructions). + CodeGen features required for C++03 and C99. + Compilation for the "small" memory model: code+static data < 4GB. + Absolute and position-independent code. + GNU-style (i.e. "__thread") TLS. + Debugging information. The principal omission, currently, is performance tuning. This patch excludes the NEON support also reviewed due to an outbreak of batshit insanity in our legal department. That will be committed soon bringing the changes to precisely what has been approved. Further reviews would be gratefully received. llvm-svn: 174054
2013-01-31 20:12:40 +08:00
case Triple::aarch64:
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
case Triple::spir64:
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::mips64:
case Triple::mips64el:
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case Triple::nvptx64:
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::ppc64:
case Triple::sparcv9:
case Triple::x86_64:
// Already 64-bit.
break;
case Triple::mips: T.setArch(Triple::mips64); break;
case Triple::mipsel: T.setArch(Triple::mips64el); break;
This patch adds a new NVPTX back-end to LLVM which supports code generation for NVIDIA PTX 3.0. This back-end will (eventually) replace the current PTX back-end, while maintaining compatibility with it. The new target machines are: nvptx (old ptx32) => 32-bit PTX nvptx64 (old ptx64) => 64-bit PTX The sources are based on the internal NVIDIA NVPTX back-end, and contain more functionality than the current PTX back-end currently provides. NV_CONTRIB llvm-svn: 156196
2012-05-05 04:18:50 +08:00
case Triple::nvptx: T.setArch(Triple::nvptx64); break;
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
case Triple::ppc: T.setArch(Triple::ppc64); break;
case Triple::sparc: T.setArch(Triple::sparcv9); break;
case Triple::x86: T.setArch(Triple::x86_64); break;
Add support for SPIR64 target - the 64bit counterpart of SPIR. The new OpenCL SPIR extension spec will define separate SPIR for 32 and 64 bit architectures. llvm-svn: 168036
2012-11-15 18:35:47 +08:00
case Triple::spir: T.setArch(Triple::spir64); break;
Introduce helpers to compute the 32-bit varaints and 64-bit variants of some architectures. These are useful for interacting with multiarch or bi-arch GCC (or GCC-based) toolchains. llvm-svn: 149895
2012-02-07 04:46:33 +08:00
}
return T;
}