LCOV - code coverage report
Current view: top level - include/llvm/ADT - Triple.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 79 85 92.9 %
Date: 2018-10-20 13:21:21 Functions: 4 10 40.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     1038344 : 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, mipsr6
      59             :     mipsel,         // MIPSEL: mipsel, mipsallegrexe, mipsr6el
      60             :     mips64,         // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
      61             :     mips64el,       // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
      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_5a,
     105             :     ARMSubArch_v8_4a,
     106             :     ARMSubArch_v8_3a,
     107             :     ARMSubArch_v8_2a,
     108             :     ARMSubArch_v8_1a,
     109             :     ARMSubArch_v8,
     110             :     ARMSubArch_v8r,
     111             :     ARMSubArch_v8m_baseline,
     112             :     ARMSubArch_v8m_mainline,
     113             :     ARMSubArch_v7,
     114             :     ARMSubArch_v7em,
     115             :     ARMSubArch_v7m,
     116             :     ARMSubArch_v7s,
     117             :     ARMSubArch_v7k,
     118             :     ARMSubArch_v7ve,
     119             :     ARMSubArch_v6,
     120             :     ARMSubArch_v6m,
     121             :     ARMSubArch_v6k,
     122             :     ARMSubArch_v6t2,
     123             :     ARMSubArch_v5,
     124             :     ARMSubArch_v5te,
     125             :     ARMSubArch_v4t,
     126             : 
     127             :     KalimbaSubArch_v3,
     128             :     KalimbaSubArch_v4,
     129             :     KalimbaSubArch_v5,
     130             : 
     131             :     MipsSubArch_r6
     132             :   };
     133             :   enum VendorType {
     134             :     UnknownVendor,
     135             : 
     136             :     Apple,
     137             :     PC,
     138             :     SCEI,
     139             :     BGP,
     140             :     BGQ,
     141             :     Freescale,
     142             :     IBM,
     143             :     ImaginationTechnologies,
     144             :     MipsTechnologies,
     145             :     NVIDIA,
     146             :     CSR,
     147             :     Myriad,
     148             :     AMD,
     149             :     Mesa,
     150             :     SUSE,
     151             :     OpenEmbedded,
     152             :     LastVendorType = OpenEmbedded
     153             :   };
     154             :   enum OSType {
     155             :     UnknownOS,
     156             : 
     157             :     Ananas,
     158             :     CloudABI,
     159             :     Darwin,
     160             :     DragonFly,
     161             :     FreeBSD,
     162             :     Fuchsia,
     163             :     IOS,
     164             :     KFreeBSD,
     165             :     Linux,
     166             :     Lv2,        // PS3
     167             :     MacOSX,
     168             :     NetBSD,
     169             :     OpenBSD,
     170             :     Solaris,
     171             :     Win32,
     172             :     Haiku,
     173             :     Minix,
     174             :     RTEMS,
     175             :     NaCl,       // Native Client
     176             :     CNK,        // BG/P Compute-Node Kernel
     177             :     AIX,
     178             :     CUDA,       // NVIDIA CUDA
     179             :     NVCL,       // NVIDIA OpenCL
     180             :     AMDHSA,     // AMD HSA Runtime
     181             :     PS4,
     182             :     ELFIAMCU,
     183             :     TvOS,       // Apple tvOS
     184             :     WatchOS,    // Apple watchOS
     185             :     Mesa3D,
     186             :     Contiki,
     187             :     AMDPAL,     // AMD PAL Runtime
     188             :     HermitCore, // HermitCore Unikernel/Multikernel
     189             :     LastOSType = HermitCore
     190             :   };
     191             :   enum EnvironmentType {
     192             :     UnknownEnvironment,
     193             : 
     194             :     GNU,
     195             :     GNUABIN32,
     196             :     GNUABI64,
     197             :     GNUEABI,
     198             :     GNUEABIHF,
     199             :     GNUX32,
     200             :     CODE16,
     201             :     EABI,
     202             :     EABIHF,
     203             :     Android,
     204             :     Musl,
     205             :     MuslEABI,
     206             :     MuslEABIHF,
     207             : 
     208             :     MSVC,
     209             :     Itanium,
     210             :     Cygnus,
     211             :     CoreCLR,
     212             :     Simulator,  // Simulator variants of other systems, e.g., Apple's iOS
     213             :     LastEnvironmentType = Simulator
     214             :   };
     215             :   enum ObjectFormatType {
     216             :     UnknownObjectFormat,
     217             : 
     218             :     COFF,
     219             :     ELF,
     220             :     MachO,
     221             :     Wasm,
     222             :   };
     223             : 
     224             : private:
     225             :   std::string Data;
     226             : 
     227             :   /// The parsed arch type.
     228             :   ArchType Arch;
     229             : 
     230             :   /// The parsed subarchitecture type.
     231             :   SubArchType SubArch;
     232             : 
     233             :   /// The parsed vendor type.
     234             :   VendorType Vendor;
     235             : 
     236             :   /// The parsed OS type.
     237             :   OSType OS;
     238             : 
     239             :   /// The parsed Environment type.
     240             :   EnvironmentType Environment;
     241             : 
     242             :   /// The object format type.
     243             :   ObjectFormatType ObjectFormat;
     244             : 
     245             : public:
     246             :   /// @name Constructors
     247             :   /// @{
     248             : 
     249             :   /// Default constructor is the same as an empty string and leaves all
     250             :   /// triple fields unknown.
     251             :   Triple()
     252      227843 :       : Data(), Arch(), SubArch(), Vendor(), OS(), Environment(),
     253      229251 :         ObjectFormat() {}
     254             : 
     255             :   explicit Triple(const Twine &Str);
     256             :   Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr);
     257             :   Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
     258             :          const Twine &EnvironmentStr);
     259             : 
     260             :   bool operator==(const Triple &Other) const {
     261         760 :     return Arch == Other.Arch && SubArch == Other.SubArch &&
     262         686 :            Vendor == Other.Vendor && OS == Other.OS &&
     263        1432 :            Environment == Other.Environment &&
     264             :            ObjectFormat == Other.ObjectFormat;
     265             :   }
     266             : 
     267             :   bool operator!=(const Triple &Other) const {
     268             :     return !(*this == Other);
     269             :   }
     270             : 
     271             :   /// @}
     272             :   /// @name Normalization
     273             :   /// @{
     274             : 
     275             :   /// normalize - Turn an arbitrary machine specification into the canonical
     276             :   /// triple form (or something sensible that the Triple class understands if
     277             :   /// nothing better can reasonably be done).  In particular, it handles the
     278             :   /// common case in which otherwise valid components are in the wrong order.
     279             :   static std::string normalize(StringRef Str);
     280             : 
     281             :   /// Return the normalized form of this triple's string.
     282      158222 :   std::string normalize() const { return normalize(Data); }
     283             : 
     284             :   /// @}
     285             :   /// @name Typed Component Access
     286             :   /// @{
     287             : 
     288             :   /// getArch - Get the parsed architecture type of this triple.
     289           0 :   ArchType getArch() const { return Arch; }
     290             : 
     291             :   /// getSubArch - get the parsed subarchitecture type for this triple.
     292           0 :   SubArchType getSubArch() const { return SubArch; }
     293             : 
     294             :   /// getVendor - Get the parsed vendor type of this triple.
     295           0 :   VendorType getVendor() const { return Vendor; }
     296             : 
     297             :   /// getOS - Get the parsed operating system type of this triple.
     298           0 :   OSType getOS() const { return OS; }
     299             : 
     300             :   /// hasEnvironment - Does this triple have the optional environment
     301             :   /// (fourth) component?
     302             :   bool hasEnvironment() const {
     303        9927 :     return getEnvironmentName() != "";
     304             :   }
     305             : 
     306             :   /// getEnvironment - Get the parsed environment type of this triple.
     307           0 :   EnvironmentType getEnvironment() const { return Environment; }
     308             : 
     309             :   /// Parse the version number from the OS name component of the
     310             :   /// triple, if present.
     311             :   ///
     312             :   /// For example, "fooos1.2.3" would return (1, 2, 3).
     313             :   ///
     314             :   /// If an entry is not defined, it will be returned as 0.
     315             :   void getEnvironmentVersion(unsigned &Major, unsigned &Minor,
     316             :                              unsigned &Micro) const;
     317             : 
     318             :   /// getFormat - Get the object format for this triple.
     319           0 :   ObjectFormatType getObjectFormat() const { return ObjectFormat; }
     320             : 
     321             :   /// getOSVersion - Parse the version number from the OS name component of the
     322             :   /// triple, if present.
     323             :   ///
     324             :   /// For example, "fooos1.2.3" would return (1, 2, 3).
     325             :   ///
     326             :   /// If an entry is not defined, it will be returned as 0.
     327             :   void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const;
     328             : 
     329             :   /// getOSMajorVersion - Return just the major version number, this is
     330             :   /// specialized because it is a common query.
     331             :   unsigned getOSMajorVersion() const {
     332             :     unsigned Maj, Min, Micro;
     333        3066 :     getOSVersion(Maj, Min, Micro);
     334        3066 :     return Maj;
     335             :   }
     336             : 
     337             :   /// getMacOSXVersion - Parse the version number as with getOSVersion and then
     338             :   /// translate generic "darwin" versions to the corresponding OS X versions.
     339             :   /// This may also be called with IOS triples but the OS X version number is
     340             :   /// just set to a constant 10.4.0 in that case.  Returns true if successful.
     341             :   bool getMacOSXVersion(unsigned &Major, unsigned &Minor,
     342             :                         unsigned &Micro) const;
     343             : 
     344             :   /// getiOSVersion - Parse the version number as with getOSVersion.  This should
     345             :   /// only be called with IOS or generic triples.
     346             :   void getiOSVersion(unsigned &Major, unsigned &Minor,
     347             :                      unsigned &Micro) const;
     348             : 
     349             :   /// getWatchOSVersion - Parse the version number as with getOSVersion.  This
     350             :   /// should only be called with WatchOS or generic triples.
     351             :   void getWatchOSVersion(unsigned &Major, unsigned &Minor,
     352             :                          unsigned &Micro) const;
     353             : 
     354             :   /// @}
     355             :   /// @name Direct Component Access
     356             :   /// @{
     357             : 
     358       78001 :   const std::string &str() const { return Data; }
     359             : 
     360       51092 :   const std::string &getTriple() const { return Data; }
     361             : 
     362             :   /// getArchName - Get the architecture (first) component of the
     363             :   /// triple.
     364             :   StringRef getArchName() const;
     365             : 
     366             :   /// getVendorName - Get the vendor (second) component of the triple.
     367             :   StringRef getVendorName() const;
     368             : 
     369             :   /// getOSName - Get the operating system (third) component of the
     370             :   /// triple.
     371             :   StringRef getOSName() const;
     372             : 
     373             :   /// getEnvironmentName - Get the optional environment (fourth)
     374             :   /// component of the triple, or "" if empty.
     375             :   StringRef getEnvironmentName() const;
     376             : 
     377             :   /// getOSAndEnvironmentName - Get the operating system and optional
     378             :   /// environment components as a single string (separated by a '-'
     379             :   /// if the environment component is present).
     380             :   StringRef getOSAndEnvironmentName() const;
     381             : 
     382             :   /// @}
     383             :   /// @name Convenience Predicates
     384             :   /// @{
     385             : 
     386             :   /// Test whether the architecture is 64-bit
     387             :   ///
     388             :   /// Note that this tests for 64-bit pointer width, and nothing else. Note
     389             :   /// that we intentionally expose only three predicates, 64-bit, 32-bit, and
     390             :   /// 16-bit. The inner details of pointer width for particular architectures
     391             :   /// is not summed up in the triple, and so only a coarse grained predicate
     392             :   /// system is provided.
     393             :   bool isArch64Bit() const;
     394             : 
     395             :   /// Test whether the architecture is 32-bit
     396             :   ///
     397             :   /// Note that this tests for 32-bit pointer width, and nothing else.
     398             :   bool isArch32Bit() const;
     399             : 
     400             :   /// Test whether the architecture is 16-bit
     401             :   ///
     402             :   /// Note that this tests for 16-bit pointer width, and nothing else.
     403             :   bool isArch16Bit() const;
     404             : 
     405             :   /// isOSVersionLT - Helper function for doing comparisons against version
     406             :   /// numbers included in the target triple.
     407       30112 :   bool isOSVersionLT(unsigned Major, unsigned Minor = 0,
     408             :                      unsigned Micro = 0) const {
     409             :     unsigned LHS[3];
     410       30112 :     getOSVersion(LHS[0], LHS[1], LHS[2]);
     411             : 
     412       30112 :     if (LHS[0] != Major)
     413       21193 :       return LHS[0] < Major;
     414        8919 :     if (LHS[1] != Minor)
     415        5470 :       return LHS[1] < Minor;
     416        3449 :     if (LHS[2] != Micro)
     417          48 :       return LHS[1] < Micro;
     418             : 
     419             :     return false;
     420             :   }
     421             : 
     422          68 :   bool isOSVersionLT(const Triple &Other) const {
     423             :     unsigned RHS[3];
     424          68 :     Other.getOSVersion(RHS[0], RHS[1], RHS[2]);
     425          68 :     return isOSVersionLT(RHS[0], RHS[1], RHS[2]);
     426             :   }
     427             : 
     428             :   /// isMacOSXVersionLT - Comparison function for checking OS X version
     429             :   /// compatibility, which handles supporting skewed version numbering schemes
     430             :   /// used by the "darwin" triples.
     431       25313 :   bool isMacOSXVersionLT(unsigned Major, unsigned Minor = 0,
     432             :                          unsigned Micro = 0) const {
     433             :     assert(isMacOSX() && "Not an OS X triple!");
     434             : 
     435             :     // If this is OS X, expect a sane version number.
     436       25313 :     if (getOS() == Triple::MacOSX)
     437        6297 :       return isOSVersionLT(Major, Minor, Micro);
     438             : 
     439             :     // Otherwise, compare to the "Darwin" number.
     440             :     assert(Major == 10 && "Unexpected major version");
     441       19016 :     return isOSVersionLT(Minor + 4, Micro, 0);
     442             :   }
     443             : 
     444             :   /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
     445             :   /// "darwin" and "osx" as OS X triples.
     446             :   bool isMacOSX() const {
     447     5431943 :     return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
     448             :   }
     449             : 
     450             :   /// Is this an iOS triple.
     451             :   /// Note: This identifies tvOS as a variant of iOS. If that ever
     452             :   /// changes, i.e., if the two operating systems diverge or their version
     453             :   /// numbers get out of sync, that will need to be changed.
     454             :   /// watchOS has completely different version numbers so it is not included.
     455             :   bool isiOS() const {
     456     4783661 :     return getOS() == Triple::IOS || isTvOS();
     457             :   }
     458             : 
     459             :   /// Is this an Apple tvOS triple.
     460             :   bool isTvOS() const {
     461         217 :     return getOS() == Triple::TvOS;
     462             :   }
     463             : 
     464             :   /// Is this an Apple watchOS triple.
     465             :   bool isWatchOS() const {
     466        2270 :     return getOS() == Triple::WatchOS;
     467             :   }
     468             : 
     469             :   bool isWatchABI() const {
     470       18247 :     return getSubArch() == Triple::ARMSubArch_v7k;
     471             :   }
     472             : 
     473             :   /// isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
     474             :   bool isOSDarwin() const {
     475     4557097 :     return isMacOSX() || isiOS() || isWatchOS();
     476             :   }
     477             : 
     478             :   bool isSimulatorEnvironment() const {
     479         837 :     return getEnvironment() == Triple::Simulator;
     480             :   }
     481             : 
     482             :   bool isOSNetBSD() const {
     483             :     return getOS() == Triple::NetBSD;
     484             :   }
     485             : 
     486             :   bool isOSOpenBSD() const {
     487      360843 :     return getOS() == Triple::OpenBSD;
     488             :   }
     489             : 
     490             :   bool isOSFreeBSD() const {
     491       28361 :     return getOS() == Triple::FreeBSD;
     492             :   }
     493             : 
     494             :   bool isOSFuchsia() const {
     495       64324 :     return getOS() == Triple::Fuchsia;
     496             :   }
     497             : 
     498             :   bool isOSDragonFly() const { return getOS() == Triple::DragonFly; }
     499             : 
     500             :   bool isOSSolaris() const {
     501       33169 :     return getOS() == Triple::Solaris;
     502             :   }
     503             : 
     504             :   bool isOSIAMCU() const {
     505     1211713 :     return getOS() == Triple::ELFIAMCU;
     506             :   }
     507             : 
     508       38347 :   bool isOSUnknown() const { return getOS() == Triple::UnknownOS; }
     509             : 
     510             :   bool isGNUEnvironment() const {
     511     1101168 :     EnvironmentType Env = getEnvironment();
     512             :     return Env == Triple::GNU || Env == Triple::GNUABIN32 ||
     513             :            Env == Triple::GNUABI64 || Env == Triple::GNUEABI ||
     514     1101306 :            Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
     515             :   }
     516             : 
     517             :   bool isOSContiki() const {
     518         151 :     return getOS() == Triple::Contiki;
     519             :   }
     520             : 
     521             :   /// Tests whether the OS is Haiku.
     522             :   bool isOSHaiku() const {
     523             :     return getOS() == Triple::Haiku;
     524             :   }
     525             : 
     526             :   /// Checks if the environment could be MSVC.
     527             :   bool isWindowsMSVCEnvironment() const {
     528    14209912 :     return getOS() == Triple::Win32 &&
     529       89344 :            (getEnvironment() == Triple::UnknownEnvironment ||
     530             :             getEnvironment() == Triple::MSVC);
     531             :   }
     532             : 
     533             :   /// Checks if the environment is MSVC.
     534             :   bool isKnownWindowsMSVCEnvironment() const {
     535      148471 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::MSVC;
     536             :   }
     537             : 
     538             :   bool isWindowsCoreCLREnvironment() const {
     539         422 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::CoreCLR;
     540             :   }
     541             : 
     542             :   bool isWindowsItaniumEnvironment() const {
     543    12908615 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::Itanium;
     544             :   }
     545             : 
     546             :   bool isWindowsCygwinEnvironment() const {
     547      441186 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::Cygnus;
     548             :   }
     549             : 
     550             :   bool isWindowsGNUEnvironment() const {
     551    35210854 :     return getOS() == Triple::Win32 && getEnvironment() == Triple::GNU;
     552             :   }
     553             : 
     554             :   /// Tests for either Cygwin or MinGW OS
     555             :   bool isOSCygMing() const {
     556             :     return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment();
     557             :   }
     558             : 
     559             :   /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment.
     560             :   bool isOSMSVCRT() const {
     561             :     return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() ||
     562             :            isWindowsItaniumEnvironment();
     563             :   }
     564             : 
     565             :   /// Tests whether the OS is Windows.
     566             :   bool isOSWindows() const {
     567    28488759 :     return getOS() == Triple::Win32;
     568             :   }
     569             : 
     570             :   /// Tests whether the OS is NaCl (Native Client)
     571             :   bool isOSNaCl() const {
     572    11257009 :     return getOS() == Triple::NaCl;
     573             :   }
     574             : 
     575             :   /// Tests whether the OS is Linux.
     576             :   bool isOSLinux() const {
     577       40983 :     return getOS() == Triple::Linux;
     578             :   }
     579             : 
     580             :   /// Tests whether the OS is kFreeBSD.
     581             :   bool isOSKFreeBSD() const {
     582             :     return getOS() == Triple::KFreeBSD;
     583             :   }
     584             : 
     585             :   /// Tests whether the OS uses glibc.
     586             :   bool isOSGlibc() const {
     587        2483 :     return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD) &&
     588             :            !isAndroid();
     589             :   }
     590             : 
     591             :   /// Tests whether the OS uses the ELF binary format.
     592             :   bool isOSBinFormatELF() const {
     593     1242212 :     return getObjectFormat() == Triple::ELF;
     594             :   }
     595             : 
     596             :   /// Tests whether the OS uses the COFF binary format.
     597             :   bool isOSBinFormatCOFF() const {
     598     5050116 :     return getObjectFormat() == Triple::COFF;
     599             :   }
     600             : 
     601             :   /// Tests whether the environment is MachO.
     602             :   bool isOSBinFormatMachO() const {
     603     2062562 :     return getObjectFormat() == Triple::MachO;
     604             :   }
     605             : 
     606             :   /// Tests whether the OS uses the Wasm binary format.
     607             :   bool isOSBinFormatWasm() const {
     608         278 :     return getObjectFormat() == Triple::Wasm;
     609             :   }
     610             : 
     611             :   /// Tests whether the target is the PS4 CPU
     612             :   bool isPS4CPU() const {
     613      126562 :     return getArch() == Triple::x86_64 &&
     614       94311 :            getVendor() == Triple::SCEI &&
     615         420 :            getOS() == Triple::PS4;
     616             :   }
     617             : 
     618             :   /// Tests whether the target is the PS4 platform
     619             :   bool isPS4() const {
     620       71648 :     return getVendor() == Triple::SCEI &&
     621         255 :            getOS() == Triple::PS4;
     622             :   }
     623             : 
     624             :   /// Tests whether the target is Android
     625      641888 :   bool isAndroid() const { return getEnvironment() == Triple::Android; }
     626             : 
     627        1102 :   bool isAndroidVersionLT(unsigned Major) const {
     628             :     assert(isAndroid() && "Not an Android triple!");
     629             : 
     630             :     unsigned Env[3];
     631        1102 :     getEnvironmentVersion(Env[0], Env[1], Env[2]);
     632             : 
     633             :     // 64-bit targets did not exist before API level 21 (Lollipop).
     634        1102 :     if (isArch64Bit() && Env[0] < 21)
     635         378 :       Env[0] = 21;
     636             : 
     637        1102 :     return Env[0] < Major;
     638             :   }
     639             : 
     640             :   /// Tests whether the environment is musl-libc
     641             :   bool isMusl() const {
     642       30273 :     return getEnvironment() == Triple::Musl ||
     643       60556 :            getEnvironment() == Triple::MuslEABI ||
     644             :            getEnvironment() == Triple::MuslEABIHF;
     645             :   }
     646             : 
     647             :   /// Tests whether the target is NVPTX (32- or 64-bit).
     648             :   bool isNVPTX() const {
     649      414877 :     return getArch() == Triple::nvptx || getArch() == Triple::nvptx64;
     650             :   }
     651             : 
     652             :   /// Tests whether the target is Thumb (little and big endian).
     653             :   bool isThumb() const {
     654       57650 :     return getArch() == Triple::thumb || getArch() == Triple::thumbeb;
     655             :   }
     656             : 
     657             :   /// Tests whether the target is ARM (little and big endian).
     658             :   bool isARM() const {
     659     2856156 :     return getArch() == Triple::arm || getArch() == Triple::armeb;
     660             :   }
     661             : 
     662             :   /// Tests whether the target is AArch64 (little and big endian).
     663             :   bool isAArch64() const {
     664     2816239 :     return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be;
     665             :   }
     666             : 
     667             :   /// Tests whether the target is MIPS 32-bit (little and big endian).
     668             :   bool isMIPS32() const {
     669     2997356 :     return getArch() == Triple::mips || getArch() == Triple::mipsel;
     670             :   }
     671             : 
     672             :   /// Tests whether the target is MIPS 64-bit (little and big endian).
     673             :   bool isMIPS64() const {
     674     2990189 :     return getArch() == Triple::mips64 || getArch() == Triple::mips64el;
     675             :   }
     676             : 
     677             :   /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit).
     678             :   bool isMIPS() const {
     679             :     return isMIPS32() || isMIPS64();
     680             :   }
     681             : 
     682             :   /// Tests whether the target supports comdat
     683             :   bool supportsCOMDAT() const {
     684      881145 :     return !isOSBinFormatMachO();
     685             :   }
     686             : 
     687             :   /// Tests whether the target uses emulated TLS as default.
     688             :   bool hasDefaultEmulatedTLS() const {
     689      318683 :     return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment();
     690             :   }
     691             : 
     692             :   /// @}
     693             :   /// @name Mutators
     694             :   /// @{
     695             : 
     696             :   /// setArch - Set the architecture (first) component of the triple
     697             :   /// to a known type.
     698             :   void setArch(ArchType Kind);
     699             : 
     700             :   /// setVendor - Set the vendor (second) component of the triple to a
     701             :   /// known type.
     702             :   void setVendor(VendorType Kind);
     703             : 
     704             :   /// setOS - Set the operating system (third) component of the triple
     705             :   /// to a known type.
     706             :   void setOS(OSType Kind);
     707             : 
     708             :   /// setEnvironment - Set the environment (fourth) component of the triple
     709             :   /// to a known type.
     710             :   void setEnvironment(EnvironmentType Kind);
     711             : 
     712             :   /// setObjectFormat - Set the object file format
     713             :   void setObjectFormat(ObjectFormatType Kind);
     714             : 
     715             :   /// setTriple - Set all components to the new triple \p Str.
     716             :   void setTriple(const Twine &Str);
     717             : 
     718             :   /// setArchName - Set the architecture (first) component of the
     719             :   /// triple by name.
     720             :   void setArchName(StringRef Str);
     721             : 
     722             :   /// setVendorName - Set the vendor (second) component of the triple
     723             :   /// by name.
     724             :   void setVendorName(StringRef Str);
     725             : 
     726             :   /// setOSName - Set the operating system (third) component of the
     727             :   /// triple by name.
     728             :   void setOSName(StringRef Str);
     729             : 
     730             :   /// setEnvironmentName - Set the optional environment (fourth)
     731             :   /// component of the triple by name.
     732             :   void setEnvironmentName(StringRef Str);
     733             : 
     734             :   /// setOSAndEnvironmentName - Set the operating system and optional
     735             :   /// environment components with a single string.
     736             :   void setOSAndEnvironmentName(StringRef Str);
     737             : 
     738             :   /// @}
     739             :   /// @name Helpers to build variants of a particular triple.
     740             :   /// @{
     741             : 
     742             :   /// Form a triple with a 32-bit variant of the current architecture.
     743             :   ///
     744             :   /// This can be used to move across "families" of architectures where useful.
     745             :   ///
     746             :   /// \returns A new triple with a 32-bit architecture or an unknown
     747             :   ///          architecture if no such variant can be found.
     748             :   llvm::Triple get32BitArchVariant() const;
     749             : 
     750             :   /// Form a triple with a 64-bit variant of the current architecture.
     751             :   ///
     752             :   /// This can be used to move across "families" of architectures where useful.
     753             :   ///
     754             :   /// \returns A new triple with a 64-bit architecture or an unknown
     755             :   ///          architecture if no such variant can be found.
     756             :   llvm::Triple get64BitArchVariant() const;
     757             : 
     758             :   /// Form a triple with a big endian variant of the current architecture.
     759             :   ///
     760             :   /// This can be used to move across "families" of architectures where useful.
     761             :   ///
     762             :   /// \returns A new triple with a big endian architecture or an unknown
     763             :   ///          architecture if no such variant can be found.
     764             :   llvm::Triple getBigEndianArchVariant() const;
     765             : 
     766             :   /// Form a triple with a little endian variant of the current architecture.
     767             :   ///
     768             :   /// This can be used to move across "families" of architectures where useful.
     769             :   ///
     770             :   /// \returns A new triple with a little endian architecture or an unknown
     771             :   ///          architecture if no such variant can be found.
     772             :   llvm::Triple getLittleEndianArchVariant() const;
     773             : 
     774             :   /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
     775             :   ///
     776             :   /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
     777             :   /// string then the triple's arch name is used.
     778             :   StringRef getARMCPUForArch(StringRef Arch = StringRef()) const;
     779             : 
     780             :   /// Tests whether the target triple is little endian.
     781             :   ///
     782             :   /// \returns true if the triple is little endian, false otherwise.
     783             :   bool isLittleEndian() const;
     784             : 
     785             :   /// Test whether target triples are compatible.
     786             :   bool isCompatibleWith(const Triple &Other) const;
     787             : 
     788             :   /// Merge target triples.
     789             :   std::string merge(const Triple &Other) const;
     790             : 
     791             :   /// @}
     792             :   /// @name Static helpers for IDs.
     793             :   /// @{
     794             : 
     795             :   /// getArchTypeName - Get the canonical name for the \p Kind architecture.
     796             :   static StringRef getArchTypeName(ArchType Kind);
     797             : 
     798             :   /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind
     799             :   /// architecture. This is the prefix used by the architecture specific
     800             :   /// builtins, and is suitable for passing to \see
     801             :   /// Intrinsic::getIntrinsicForGCCBuiltin().
     802             :   ///
     803             :   /// \return - The architecture prefix, or 0 if none is defined.
     804             :   static StringRef getArchTypePrefix(ArchType Kind);
     805             : 
     806             :   /// getVendorTypeName - Get the canonical name for the \p Kind vendor.
     807             :   static StringRef getVendorTypeName(VendorType Kind);
     808             : 
     809             :   /// getOSTypeName - Get the canonical name for the \p Kind operating system.
     810             :   static StringRef getOSTypeName(OSType Kind);
     811             : 
     812             :   /// getEnvironmentTypeName - Get the canonical name for the \p Kind
     813             :   /// environment.
     814             :   static StringRef getEnvironmentTypeName(EnvironmentType Kind);
     815             : 
     816             :   /// @}
     817             :   /// @name Static helpers for converting alternate architecture names.
     818             :   /// @{
     819             : 
     820             :   /// getArchTypeForLLVMName - The canonical type for the given LLVM
     821             :   /// architecture name (e.g., "x86").
     822             :   static ArchType getArchTypeForLLVMName(StringRef Str);
     823             : 
     824             :   /// @}
     825             : };
     826             : 
     827             : } // End llvm namespace
     828             : 
     829             : 
     830             : #endif

Generated by: LCOV version 1.13