LCOV - code coverage report
Current view: top level - include/llvm/ADT - Triple.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 79 80 98.8 %
Date: 2018-07-13 00:08:38 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/ADT/Triple.h - Target triple helper class ----------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #ifndef LLVM_ADT_TRIPLE_H
      11             : #define LLVM_ADT_TRIPLE_H
      12             : 
      13             : #include "llvm/ADT/Twine.h"
      14             : 
      15             : // Some system headers or GCC predefined macros conflict with identifiers in
      16             : // this file.  Undefine them here.
      17             : #undef NetBSD
      18             : #undef mips
      19             : #undef sparc
      20             : 
      21             : namespace llvm {
      22             : 
      23             : /// Triple - Helper class for working with autoconf configuration names. For
      24             : /// historical reasons, we also call these 'triples' (they used to contain
      25             : /// exactly three fields).
      26             : ///
      27             : /// Configuration names are strings in the canonical form:
      28             : ///   ARCHITECTURE-VENDOR-OPERATING_SYSTEM
      29             : /// or
      30             : ///   ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT
      31             : ///
      32             : /// This class is used for clients which want to support arbitrary
      33             : /// configuration names, but also want to implement certain special
      34             : /// behavior for particular configurations. This class isolates the mapping
      35             : /// from the components of the configuration name to well known IDs.
      36             : ///
      37             : /// At its core the Triple class is designed to be a wrapper for a triple
      38             : /// string; the constructor does not change or normalize the triple string.
      39             : /// Clients that need to handle the non-canonical triples that users often
      40             : /// specify should use the normalize method.
      41             : ///
      42             : /// See autoconf/config.guess for a glimpse into what configuration names
      43             : /// look like in practice.
      44     4143531 : class Triple {
      45             : public:
      46             :   enum ArchType {
      47             :     UnknownArch,
      48             : 
      49             :     arm,            // ARM (little endian): arm, armv.*, xscale
      50             :     armeb,          // ARM (big endian): armeb
      51             :     aarch64,        // AArch64 (little endian): aarch64
      52             :     aarch64_be,     // AArch64 (big endian): aarch64_be
      53             :     arc,            // ARC: Synopsys ARC
      54             :     avr,            // AVR: Atmel AVR microcontroller
      55             :     bpfel,          // eBPF or extended BPF or 64-bit BPF (little endian)
      56             :     bpfeb,          // eBPF or extended BPF or 64-bit BPF (big endian)
      57             :     hexagon,        // Hexagon: hexagon
      58             :     mips,           // MIPS: mips, mipsallegrex
      59             :     mipsel,         // MIPSEL: mipsel, mipsallegrexel
      60             :     mips64,         // MIPS64: mips64
      61             :     mips64el,       // MIPS64EL: mips64el
      62             :     msp430,         // MSP430: msp430
      63             :     nios2,          // NIOSII: nios2
      64             :     ppc,            // PPC: powerpc
      65             :     ppc64,          // PPC64: powerpc64, ppu
      66             :     ppc64le,        // PPC64LE: powerpc64le
      67             :     r600,           // R600: AMD GPUs HD2XXX - HD6XXX
      68             :     amdgcn,         // AMDGCN: AMD GCN GPUs
      69             :     riscv32,        // RISC-V (32-bit): riscv32
      70             :     riscv64,        // RISC-V (64-bit): riscv64
      71             :     sparc,          // Sparc: sparc
      72             :     sparcv9,        // Sparcv9: Sparcv9
      73             :     sparcel,        // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
      74             :     systemz,        // SystemZ: s390x
      75             :     tce,            // TCE (http://tce.cs.tut.fi/): tce
      76             :     tcele,          // TCE little endian (http://tce.cs.tut.fi/): tcele
      77             :     thumb,          // Thumb (little endian): thumb, thumbv.*
      78             :     thumbeb,        // Thumb (big endian): thumbeb
      79             :     x86,            // X86: i[3-9]86
      80             :     x86_64,         // X86-64: amd64, x86_64
      81             :     xcore,          // XCore: xcore
      82             :     nvptx,          // NVPTX: 32-bit
      83             :     nvptx64,        // NVPTX: 64-bit
      84             :     le32,           // le32: generic little-endian 32-bit CPU (PNaCl)
      85             :     le64,           // le64: generic little-endian 64-bit CPU (PNaCl)
      86             :     amdil,          // AMDIL
      87             :     amdil64,        // AMDIL with 64-bit pointers
      88             :     hsail,          // AMD HSAIL
      89             :     hsail64,        // AMD HSAIL with 64-bit pointers
      90             :     spir,           // SPIR: standard portable IR for OpenCL 32-bit version
      91             :     spir64,         // SPIR: standard portable IR for OpenCL 64-bit version
      92             :     kalimba,        // Kalimba: generic kalimba
      93             :     shave,          // SHAVE: Movidius vector VLIW processors
      94             :     lanai,          // Lanai: Lanai 32-bit
      95             :     wasm32,         // WebAssembly with 32-bit pointers
      96             :     wasm64,         // WebAssembly with 64-bit pointers
      97             :     renderscript32, // 32-bit RenderScript
      98             :     renderscript64, // 64-bit RenderScript
      99             :     LastArchType = renderscript64
     100             :   };
     101             :   enum SubArchType {
     102             :     NoSubArch,
     103             : 
     104             :     ARMSubArch_v8_4a,
     105             :     ARMSubArch_v8_3a,
     106             :     ARMSubArch_v8_2a,
     107             :     ARMSubArch_v8_1a,
     108             :     ARMSubArch_v8,
     109             :     ARMSubArch_v8r,
     110             :     ARMSubArch_v8m_baseline,
     111             :     ARMSubArch_v8m_mainline,
     112             :     ARMSubArch_v7,
     113             :     ARMSubArch_v7em,
     114             :     ARMSubArch_v7m,
     115             :     ARMSubArch_v7s,
     116             :     ARMSubArch_v7k,
     117             :     ARMSubArch_v7ve,
     118             :     ARMSubArch_v6,
     119             :     ARMSubArch_v6m,
     120             :     ARMSubArch_v6k,
     121             :     ARMSubArch_v6t2,
     122             :     ARMSubArch_v5,
     123             :     ARMSubArch_v5te,
     124             :     ARMSubArch_v4t,
     125             : 
     126             :     KalimbaSubArch_v3,
     127             :     KalimbaSubArch_v4,
     128             :     KalimbaSubArch_v5
     129             :   };
     130             :   enum VendorType {
     131             :     UnknownVendor,
     132             : 
     133             :     Apple,
     134             :     PC,
     135             :     SCEI,
     136             :     BGP,
     137             :     BGQ,
     138             :     Freescale,
     139             :     IBM,
     140             :     ImaginationTechnologies,
     141             :     MipsTechnologies,
     142             :     NVIDIA,
     143             :     CSR,
     144             :     Myriad,
     145             :     AMD,
     146             :     Mesa,
     147             :     SUSE,
     148             :     OpenEmbedded,
     149             :     LastVendorType = OpenEmbedded
     150             :   };
     151             :   enum OSType {
     152             :     UnknownOS,
     153             : 
     154             :     Ananas,
     155             :     CloudABI,
     156             :     Darwin,
     157             :     DragonFly,
     158             :     FreeBSD,
     159             :     Fuchsia,
     160             :     IOS,
     161             :     KFreeBSD,
     162             :     Linux,
     163             :     Lv2,        // PS3
     164             :     MacOSX,
     165             :     NetBSD,
     166             :     OpenBSD,
     167             :     Solaris,
     168             :     Win32,
     169             :     Haiku,
     170             :     Minix,
     171             :     RTEMS,
     172             :     NaCl,       // Native Client
     173             :     CNK,        // BG/P Compute-Node Kernel
     174             :     AIX,
     175             :     CUDA,       // NVIDIA CUDA
     176             :     NVCL,       // NVIDIA OpenCL
     177             :     AMDHSA,     // AMD HSA Runtime
     178             :     PS4,
     179             :     ELFIAMCU,
     180             :     TvOS,       // Apple tvOS
     181             :     WatchOS,    // Apple watchOS
     182             :     Mesa3D,
     183             :     Contiki,
     184             :     AMDPAL,     // AMD PAL Runtime
     185             :     LastOSType = AMDPAL
     186             :   };
     187             :   enum EnvironmentType {
     188             :     UnknownEnvironment,
     189             : 
     190             :     GNU,
     191             :     GNUABIN32,
     192             :     GNUABI64,
     193             :     GNUEABI,
     194             :     GNUEABIHF,
     195             :     GNUX32,
     196             :     CODE16,
     197             :     EABI,
     198             :     EABIHF,
     199             :     Android,
     200             :     Musl,
     201             :     MuslEABI,
     202             :     MuslEABIHF,
     203             : 
     204             :     MSVC,
     205             :     Itanium,
     206             :     Cygnus,
     207             :     CoreCLR,
     208             :     Simulator,  // Simulator variants of other systems, e.g., Apple's iOS
     209             :     LastEnvironmentType = Simulator
     210             :   };
     211             :   enum ObjectFormatType {
     212             :     UnknownObjectFormat,
     213             : 
     214             :     COFF,
     215             :     ELF,
     216             :     MachO,
     217             :     Wasm,
     218             :   };
     219             : 
     220             : private:
     221             :   std::string Data;
     222             : 
     223             :   /// The parsed arch type.
     224             :   ArchType Arch;
     225             : 
     226             :   /// The parsed subarchitecture type.
     227             :   SubArchType SubArch;
     228             : 
     229             :   /// The parsed vendor type.
     230             :   VendorType Vendor;
     231             : 
     232             :   /// The parsed OS type.
     233             :   OSType OS;
     234             : 
     235             :   /// The parsed Environment type.
     236             :   EnvironmentType Environment;
     237             : 
     238             :   /// The object format type.
     239             :   ObjectFormatType ObjectFormat;
     240             : 
     241             : public:
     242             :   /// @name Constructors
     243             :   /// @{
     244             : 
     245             :   /// Default constructor is the same as an empty string and leaves all
     246             :   /// triple fields unknown.
     247             :   Triple()
     248      271048 :       : Data(), Arch(), SubArch(), Vendor(), OS(), Environment(),
     249      272092 :         ObjectFormat() {}
     250             : 
     251             :   explicit Triple(const Twine &Str);
     252             :   Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr);
     253             :   Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
     254             :          const Twine &EnvironmentStr);
     255             : 
     256             :   bool operator==(const Triple &Other) const {
     257         700 :     return Arch == Other.Arch && SubArch == Other.SubArch &&
     258         648 :            Vendor == Other.Vendor && OS == Other.OS &&
     259        1335 :            Environment == Other.Environment &&
     260             :            ObjectFormat == Other.ObjectFormat;
     261             :   }
     262             : 
     263             :   bool operator!=(const Triple &Other) const {
     264             :     return !(*this == Other);
     265             :   }
     266             : 
     267             :   /// @}
     268             :   /// @name Normalization
     269             :   /// @{
     270             : 
     271             :   /// normalize - Turn an arbitrary machine specification into the canonical
     272             :   /// triple form (or something sensible that the Triple class understands if
     273             :   /// nothing better can reasonably be done).  In particular, it handles the
     274             :   /// common case in which otherwise valid components are in the wrong order.
     275             :   static std::string normalize(StringRef Str);
     276             : 
     277             :   /// Return the normalized form of this triple's string.
     278       58837 :   std::string normalize() const { return normalize(Data); }
     279             : 
     280             :   /// @}
     281             :   /// @name Typed Component Access
     282             :   /// @{
     283             : 
     284             :   /// getArch - Get the parsed architecture type of this triple.
     285             :   ArchType getArch() const { return Arch; }
     286             : 
     287             :   /// getSubArch - get the parsed subarchitecture type for this triple.
     288             :   SubArchType getSubArch() const { return SubArch; }
     289             : 
     290             :   /// getVendor - Get the parsed vendor type of this triple.
     291             :   VendorType getVendor() const { return Vendor; }
     292             : 
     293             :   /// getOS - Get the parsed operating system type of this triple.
     294             :   OSType getOS() const { return OS; }
     295             : 
     296             :   /// hasEnvironment - Does this triple have the optional environment
     297             :   /// (fourth) component?
     298             :   bool hasEnvironment() const {
     299       10326 :     return getEnvironmentName() != "";
     300             :   }
     301             : 
     302             :   /// getEnvironment - Get the parsed environment type of this triple.
     303             :   EnvironmentType getEnvironment() const { return Environment; }
     304             : 
     305             :   /// Parse the version number from the OS name component of the
     306             :   /// triple, if present.
     307             :   ///
     308             :   /// For example, "fooos1.2.3" would return (1, 2, 3).
     309             :   ///
     310             :   /// If an entry is not defined, it will be returned as 0.
     311             :   void getEnvironmentVersion(unsigned &Major, unsigned &Minor,
     312             :                              unsigned &Micro) const;
     313             : 
     314             :   /// getFormat - Get the object format for this triple.
     315             :   ObjectFormatType getObjectFormat() const { return ObjectFormat; }
     316             : 
     317             :   /// getOSVersion - Parse the version number from the OS name component of the
     318             :   /// triple, if present.
     319             :   ///
     320             :   /// For example, "fooos1.2.3" would return (1, 2, 3).
     321             :   ///
     322             :   /// If an entry is not defined, it will be returned as 0.
     323             :   void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const;
     324             : 
     325             :   /// getOSMajorVersion - Return just the major version number, this is
     326             :   /// specialized because it is a common query.
     327             :   unsigned getOSMajorVersion() const {
     328             :     unsigned Maj, Min, Micro;
     329        3227 :     getOSVersion(Maj, Min, Micro);
     330        3227 :     return Maj;
     331             :   }
     332             : 
     333             :   /// getMacOSXVersion - Parse the version number as with getOSVersion and then
     334             :   /// translate generic "darwin" versions to the corresponding OS X versions.
     335             :   /// This may also be called with IOS triples but the OS X version number is
     336             :   /// just set to a constant 10.4.0 in that case.  Returns true if successful.
     337             :   bool getMacOSXVersion(unsigned &Major, unsigned &Minor,
     338             :                         unsigned &Micro) const;
     339             : 
     340             :   /// getiOSVersion - Parse the version number as with getOSVersion.  This should
     341             :   /// only be called with IOS or generic triples.
     342             :   void getiOSVersion(unsigned &Major, unsigned &Minor,
     343             :                      unsigned &Micro) const;
     344             : 
     345             :   /// getWatchOSVersion - Parse the version number as with getOSVersion.  This
     346             :   /// should only be called with WatchOS or generic triples.
     347             :   void getWatchOSVersion(unsigned &Major, unsigned &Minor,
     348             :                          unsigned &Micro) const;
     349             : 
     350             :   /// @}
     351             :   /// @name Direct Component Access
     352             :   /// @{
     353             : 
     354       28829 :   const std::string &str() const { return Data; }
     355             : 
     356       43969 :   const std::string &getTriple() const { return Data; }
     357             : 
     358             :   /// getArchName - Get the architecture (first) component of the
     359             :   /// triple.
     360             :   StringRef getArchName() const;
     361             : 
     362             :   /// getVendorName - Get the vendor (second) component of the triple.
     363             :   StringRef getVendorName() const;
     364             : 
     365             :   /// getOSName - Get the operating system (third) component of the
     366             :   /// triple.
     367             :   StringRef getOSName() const;
     368             : 
     369             :   /// getEnvironmentName - Get the optional environment (fourth)
     370             :   /// component of the triple, or "" if empty.
     371             :   StringRef getEnvironmentName() const;
     372             : 
     373             :   /// getOSAndEnvironmentName - Get the operating system and optional
     374             :   /// environment components as a single string (separated by a '-'
     375             :   /// if the environment component is present).
     376             :   StringRef getOSAndEnvironmentName() const;
     377             : 
     378             :   /// @}
     379             :   /// @name Convenience Predicates
     380             :   /// @{
     381             : 
     382             :   /// Test whether the architecture is 64-bit
     383             :   ///
     384             :   /// Note that this tests for 64-bit pointer width, and nothing else. Note
     385             :   /// that we intentionally expose only three predicates, 64-bit, 32-bit, and
     386             :   /// 16-bit. The inner details of pointer width for particular architectures
     387             :   /// is not summed up in the triple, and so only a coarse grained predicate
     388             :   /// system is provided.
     389             :   bool isArch64Bit() const;
     390             : 
     391             :   /// Test whether the architecture is 32-bit
     392             :   ///
     393             :   /// Note that this tests for 32-bit pointer width, and nothing else.
     394             :   bool isArch32Bit() const;
     395             : 
     396             :   /// Test whether the architecture is 16-bit
     397             :   ///
     398             :   /// Note that this tests for 16-bit pointer width, and nothing else.
     399             :   bool isArch16Bit() const;
     400             : 
     401             :   /// isOSVersionLT - Helper function for doing comparisons against version
     402             :   /// numbers included in the target triple.
     403       30887 :   bool isOSVersionLT(unsigned Major, unsigned Minor = 0,
     404             :                      unsigned Micro = 0) const {
     405             :     unsigned LHS[3];
     406       30887 :     getOSVersion(LHS[0], LHS[1], LHS[2]);
     407             : 
     408       30888 :     if (LHS[0] != Major)
     409       21914 :       return LHS[0] < Major;
     410        8974 :     if (LHS[1] != Minor)
     411        5494 :       return LHS[1] < Minor;
     412        3480 :     if (LHS[2] != Micro)
     413          48 :       return LHS[1] < Micro;
     414             : 
     415             :     return false;
     416             :   }
     417             : 
     418          68 :   bool isOSVersionLT(const Triple &Other) const {
     419             :     unsigned RHS[3];
     420          68 :     Other.getOSVersion(RHS[0], RHS[1], RHS[2]);
     421          68 :     return isOSVersionLT(RHS[0], RHS[1], RHS[2]);
     422             :   }
     423             : 
     424             :   /// isMacOSXVersionLT - Comparison function for checking OS X version
     425             :   /// compatibility, which handles supporting skewed version numbering schemes
     426             :   /// used by the "darwin" triples.
     427       26110 :   bool isMacOSXVersionLT(unsigned Major, unsigned Minor = 0,
     428             :                          unsigned Micro = 0) const {
     429             :     assert(isMacOSX() && "Not an OS X triple!");
     430             : 
     431             :     // If this is OS X, expect a sane version number.
     432       26110 :     if (getOS() == Triple::MacOSX)
     433        6341 :       return isOSVersionLT(Major, Minor, Micro);
     434             : 
     435             :     // Otherwise, compare to the "Darwin" number.
     436             :     assert(Major == 10 && "Unexpected major version");
     437       19769 :     return isOSVersionLT(Minor + 4, Micro, 0);
     438             :   }
     439             : 
     440             :   /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
     441             :   /// "darwin" and "osx" as OS X triples.
     442             :   bool isMacOSX() const {
     443     4783659 :     return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
     444             :   }
     445             : 
     446             :   /// Is this an iOS triple.
     447             :   /// Note: This identifies tvOS as a variant of iOS. If that ever
     448             :   /// changes, i.e., if the two operating systems diverge or their version
     449             :   /// numbers get out of sync, that will need to be changed.
     450             :   /// watchOS has completely different version numbers so it is not included.
     451             :   bool isiOS() const {
     452     3901327 :     return getOS() == Triple::IOS || isTvOS();
     453             :   }
     454             : 
     455             :   /// Is this an Apple tvOS triple.
     456             :   bool isTvOS() const {
     457         209 :     return getOS() == Triple::TvOS;
     458             :   }
     459             : 
     460             :   /// Is this an Apple watchOS triple.
     461             :   bool isWatchOS() const {
     462        3128 :     return getOS() == Triple::WatchOS;
     463             :   }
     464             : 
     465             :   bool isWatchABI() const {
     466       19002 :     return getSubArch() == Triple::ARMSubArch_v7k;
     467             :   }
     468             : 
     469             :   /// isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
     470             :   bool isOSDarwin() const {
     471     3604952 :     return isMacOSX() || isiOS() || isWatchOS();
     472             :   }
     473             : 
     474             :   bool isSimulatorEnvironment() const {
     475        3510 :     return getEnvironment() == Triple::Simulator;
     476             :   }
     477             : 
     478             :   bool isOSNetBSD() const {
     479           0 :     return getOS() == Triple::NetBSD;
     480             :   }
     481             : 
     482             :   bool isOSOpenBSD() const {
     483      150290 :     return getOS() == Triple::OpenBSD;
     484             :   }
     485             : 
     486             :   bool isOSFreeBSD() const {
     487       71467 :     return getOS() == Triple::FreeBSD;
     488             :   }
     489             : 
     490             :   bool isOSFuchsia() const {
     491       48673 :     return getOS() == Triple::Fuchsia;
     492             :   }
     493             : 
     494             :   bool isOSDragonFly() const { return getOS() == Triple::DragonFly; }
     495             : 
     496             :   bool isOSSolaris() const {
     497       26702 :     return getOS() == Triple::Solaris;
     498             :   }
     499             : 
     500             :   bool isOSIAMCU() const {
     501      434090 :     return getOS() == Triple::ELFIAMCU;
     502             :   }
     503             : 
     504       15220 :   bool isOSUnknown() const { return getOS() == Triple::UnknownOS; }
     505             : 
     506             :   bool isGNUEnvironment() const {
     507      339382 :     EnvironmentType Env = getEnvironment();
     508             :     return Env == Triple::GNU || Env == Triple::GNUABIN32 ||
     509             :            Env == Triple::GNUABI64 || Env == Triple::GNUEABI ||
     510      339520 :            Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
     511             :   }
     512             : 
     513             :   bool isOSContiki() const {
     514         149 :     return getOS() == Triple::Contiki;
     515             :   }
     516             : 
     517             :   /// Tests whether the OS is Haiku.
     518             :   bool isOSHaiku() const {
     519             :     return getOS() == Triple::Haiku;
     520             :   }
     521             : 
     522             :   /// Checks if the environment could be MSVC.
     523             :   bool isWindowsMSVCEnvironment() const {
     524     5552676 :     return getOS() == Triple::Win32 &&
     525      146283 :            (getEnvironment() == Triple::UnknownEnvironment ||
     526             :             getEnvironment() == Triple::MSVC);
     527             :   }
     528             : 
     529             :   /// Checks if the environment is MSVC.
     530             :   bool isKnownWindowsMSVCEnvironment() const {
     531      105360 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::MSVC;
     532             :   }
     533             : 
     534             :   bool isWindowsCoreCLREnvironment() const {
     535         380 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::CoreCLR;
     536             :   }
     537             : 
     538             :   bool isWindowsItaniumEnvironment() const {
     539     5250345 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::Itanium;
     540             :   }
     541             : 
     542             :   bool isWindowsCygwinEnvironment() const {
     543      239511 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::Cygnus;
     544             :   }
     545             : 
     546             :   bool isWindowsGNUEnvironment() const {
     547     7126593 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::GNU;
     548             :   }
     549             : 
     550             :   /// Tests for either Cygwin or MinGW OS
     551             :   bool isOSCygMing() const {
     552             :     return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment();
     553             :   }
     554             : 
     555             :   /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment.
     556             :   bool isOSMSVCRT() const {
     557             :     return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() ||
     558             :            isWindowsItaniumEnvironment();
     559             :   }
     560             : 
     561             :   /// Tests whether the OS is Windows.
     562             :   bool isOSWindows() const {
     563     5217976 :     return getOS() == Triple::Win32;
     564             :   }
     565             : 
     566             :   /// Tests whether the OS is NaCl (Native Client)
     567             :   bool isOSNaCl() const {
     568     1571445 :     return getOS() == Triple::NaCl;
     569             :   }
     570             : 
     571             :   /// Tests whether the OS is Linux.
     572             :   bool isOSLinux() const {
     573      166484 :     return getOS() == Triple::Linux;
     574             :   }
     575             : 
     576             :   /// Tests whether the OS is kFreeBSD.
     577             :   bool isOSKFreeBSD() const {
     578             :     return getOS() == Triple::KFreeBSD;
     579             :   }
     580             : 
     581             :   /// Tests whether the OS uses glibc.
     582             :   bool isOSGlibc() const {
     583        2404 :     return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD) &&
     584             :            !isAndroid();
     585             :   }
     586             : 
     587             :   /// Tests whether the OS uses the ELF binary format.
     588             :   bool isOSBinFormatELF() const {
     589      174280 :     return getObjectFormat() == Triple::ELF;
     590             :   }
     591             : 
     592             :   /// Tests whether the OS uses the COFF binary format.
     593             :   bool isOSBinFormatCOFF() const {
     594     1908418 :     return getObjectFormat() == Triple::COFF;
     595             :   }
     596             : 
     597             :   /// Tests whether the environment is MachO.
     598             :   bool isOSBinFormatMachO() const {
     599     1422632 :     return getObjectFormat() == Triple::MachO;
     600             :   }
     601             : 
     602             :   /// Tests whether the OS uses the Wasm binary format.
     603             :   bool isOSBinFormatWasm() const {
     604         234 :     return getObjectFormat() == Triple::Wasm;
     605             :   }
     606             : 
     607             :   /// Tests whether the target is the PS4 CPU
     608             :   bool isPS4CPU() const {
     609      151919 :     return getArch() == Triple::x86_64 &&
     610      122481 :            getVendor() == Triple::SCEI &&
     611         602 :            getOS() == Triple::PS4;
     612             :   }
     613             : 
     614             :   /// Tests whether the target is the PS4 platform
     615             :   bool isPS4() const {
     616       57696 :     return getVendor() == Triple::SCEI &&
     617         258 :            getOS() == Triple::PS4;
     618             :   }
     619             : 
     620             :   /// Tests whether the target is Android
     621      392039 :   bool isAndroid() const { return getEnvironment() == Triple::Android; }
     622             : 
     623         553 :   bool isAndroidVersionLT(unsigned Major) const {
     624             :     assert(isAndroid() && "Not an Android triple!");
     625             : 
     626             :     unsigned Env[3];
     627         553 :     getEnvironmentVersion(Env[0], Env[1], Env[2]);
     628             : 
     629             :     // 64-bit targets did not exist before API level 21 (Lollipop).
     630         553 :     if (isArch64Bit() && Env[0] < 21)
     631         211 :       Env[0] = 21;
     632             : 
     633         553 :     return Env[0] < Major;
     634             :   }
     635             : 
     636             :   /// Tests whether the environment is musl-libc
     637             :   bool isMusl() const {
     638       30772 :     return getEnvironment() == Triple::Musl ||
     639       33162 :            getEnvironment() == Triple::MuslEABI ||
     640             :            getEnvironment() == Triple::MuslEABIHF;
     641             :   }
     642             : 
     643             :   /// Tests whether the target is NVPTX (32- or 64-bit).
     644             :   bool isNVPTX() const {
     645      312696 :     return getArch() == Triple::nvptx || getArch() == Triple::nvptx64;
     646             :   }
     647             : 
     648             :   /// Tests whether the target is Thumb (little and big endian).
     649             :   bool isThumb() const {
     650       51487 :     return getArch() == Triple::thumb || getArch() == Triple::thumbeb;
     651             :   }
     652             : 
     653             :   /// Tests whether the target is ARM (little and big endian).
     654             :   bool isARM() const {
     655       37665 :     return getArch() == Triple::arm || getArch() == Triple::armeb;
     656             :   }
     657             : 
     658             :   /// Tests whether the target is AArch64 (little and big endian).
     659             :   bool isAArch64() const {
     660         130 :     return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be;
     661             :   }
     662             : 
     663             :   /// Tests whether the target is MIPS 32-bit (little and big endian).
     664             :   bool isMIPS32() const {
     665      210020 :     return getArch() == Triple::mips || getArch() == Triple::mipsel;
     666             :   }
     667             : 
     668             :   /// Tests whether the target is MIPS 64-bit (little and big endian).
     669             :   bool isMIPS64() const {
     670      198907 :     return getArch() == Triple::mips64 || getArch() == Triple::mips64el;
     671             :   }
     672             : 
     673             :   /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit).
     674             :   bool isMIPS() const {
     675             :     return isMIPS32() || isMIPS64();
     676             :   }
     677             : 
     678             :   /// Tests whether the target supports comdat
     679             :   bool supportsCOMDAT() const {
     680      179649 :     return !isOSBinFormatMachO();
     681             :   }
     682             : 
     683             :   /// Tests whether the target uses emulated TLS as default.
     684             :   bool hasDefaultEmulatedTLS() const {
     685      228612 :     return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment();
     686             :   }
     687             : 
     688             :   /// @}
     689             :   /// @name Mutators
     690             :   /// @{
     691             : 
     692             :   /// setArch - Set the architecture (first) component of the triple
     693             :   /// to a known type.
     694             :   void setArch(ArchType Kind);
     695             : 
     696             :   /// setVendor - Set the vendor (second) component of the triple to a
     697             :   /// known type.
     698             :   void setVendor(VendorType Kind);
     699             : 
     700             :   /// setOS - Set the operating system (third) component of the triple
     701             :   /// to a known type.
     702             :   void setOS(OSType Kind);
     703             : 
     704             :   /// setEnvironment - Set the environment (fourth) component of the triple
     705             :   /// to a known type.
     706             :   void setEnvironment(EnvironmentType Kind);
     707             : 
     708             :   /// setObjectFormat - Set the object file format
     709             :   void setObjectFormat(ObjectFormatType Kind);
     710             : 
     711             :   /// setTriple - Set all components to the new triple \p Str.
     712             :   void setTriple(const Twine &Str);
     713             : 
     714             :   /// setArchName - Set the architecture (first) component of the
     715             :   /// triple by name.
     716             :   void setArchName(StringRef Str);
     717             : 
     718             :   /// setVendorName - Set the vendor (second) component of the triple
     719             :   /// by name.
     720             :   void setVendorName(StringRef Str);
     721             : 
     722             :   /// setOSName - Set the operating system (third) component of the
     723             :   /// triple by name.
     724             :   void setOSName(StringRef Str);
     725             : 
     726             :   /// setEnvironmentName - Set the optional environment (fourth)
     727             :   /// component of the triple by name.
     728             :   void setEnvironmentName(StringRef Str);
     729             : 
     730             :   /// setOSAndEnvironmentName - Set the operating system and optional
     731             :   /// environment components with a single string.
     732             :   void setOSAndEnvironmentName(StringRef Str);
     733             : 
     734             :   /// @}
     735             :   /// @name Helpers to build variants of a particular triple.
     736             :   /// @{
     737             : 
     738             :   /// Form a triple with a 32-bit variant of the current architecture.
     739             :   ///
     740             :   /// This can be used to move across "families" of architectures where useful.
     741             :   ///
     742             :   /// \returns A new triple with a 32-bit architecture or an unknown
     743             :   ///          architecture if no such variant can be found.
     744             :   llvm::Triple get32BitArchVariant() const;
     745             : 
     746             :   /// Form a triple with a 64-bit variant of the current architecture.
     747             :   ///
     748             :   /// This can be used to move across "families" of architectures where useful.
     749             :   ///
     750             :   /// \returns A new triple with a 64-bit architecture or an unknown
     751             :   ///          architecture if no such variant can be found.
     752             :   llvm::Triple get64BitArchVariant() const;
     753             : 
     754             :   /// Form a triple with a big endian variant of the current architecture.
     755             :   ///
     756             :   /// This can be used to move across "families" of architectures where useful.
     757             :   ///
     758             :   /// \returns A new triple with a big endian architecture or an unknown
     759             :   ///          architecture if no such variant can be found.
     760             :   llvm::Triple getBigEndianArchVariant() const;
     761             : 
     762             :   /// Form a triple with a little endian variant of the current architecture.
     763             :   ///
     764             :   /// This can be used to move across "families" of architectures where useful.
     765             :   ///
     766             :   /// \returns A new triple with a little endian architecture or an unknown
     767             :   ///          architecture if no such variant can be found.
     768             :   llvm::Triple getLittleEndianArchVariant() const;
     769             : 
     770             :   /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
     771             :   ///
     772             :   /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
     773             :   /// string then the triple's arch name is used.
     774             :   StringRef getARMCPUForArch(StringRef Arch = StringRef()) const;
     775             : 
     776             :   /// Tests whether the target triple is little endian.
     777             :   ///
     778             :   /// \returns true if the triple is little endian, false otherwise.
     779             :   bool isLittleEndian() const;
     780             : 
     781             :   /// Test whether target triples are compatible.
     782             :   bool isCompatibleWith(const Triple &Other) const;
     783             : 
     784             :   /// Merge target triples.
     785             :   std::string merge(const Triple &Other) const;
     786             : 
     787             :   /// @}
     788             :   /// @name Static helpers for IDs.
     789             :   /// @{
     790             : 
     791             :   /// getArchTypeName - Get the canonical name for the \p Kind architecture.
     792             :   static StringRef getArchTypeName(ArchType Kind);
     793             : 
     794             :   /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind
     795             :   /// architecture. This is the prefix used by the architecture specific
     796             :   /// builtins, and is suitable for passing to \see
     797             :   /// Intrinsic::getIntrinsicForGCCBuiltin().
     798             :   ///
     799             :   /// \return - The architecture prefix, or 0 if none is defined.
     800             :   static StringRef getArchTypePrefix(ArchType Kind);
     801             : 
     802             :   /// getVendorTypeName - Get the canonical name for the \p Kind vendor.
     803             :   static StringRef getVendorTypeName(VendorType Kind);
     804             : 
     805             :   /// getOSTypeName - Get the canonical name for the \p Kind operating system.
     806             :   static StringRef getOSTypeName(OSType Kind);
     807             : 
     808             :   /// getEnvironmentTypeName - Get the canonical name for the \p Kind
     809             :   /// environment.
     810             :   static StringRef getEnvironmentTypeName(EnvironmentType Kind);
     811             : 
     812             :   /// @}
     813             :   /// @name Static helpers for converting alternate architecture names.
     814             :   /// @{
     815             : 
     816             :   /// getArchTypeForLLVMName - The canonical type for the given LLVM
     817             :   /// architecture name (e.g., "x86").
     818             :   static ArchType getArchTypeForLLVMName(StringRef Str);
     819             : 
     820             :   /// @}
     821             : };
     822             : 
     823             : } // End llvm namespace
     824             : 
     825             : 
     826             : #endif

Generated by: LCOV version 1.13