add llvm configure flags to enable/disable target OSes/Envs

include/llvm/ADT/Triple.h

 //===-- llvm/ADT/Triple.h - Target triple helper class ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_TRIPLE_H
@@ skipping 236 matching lines @@
       return LHS[1] < Minor;
     if (LHS[2] != Micro)
       return LHS[1] < Micro;
 
     return false;
   }
 
   /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
   /// "darwin" and "osx" as OS X triples.
   bool isMacOSX() const {
+#if defined(LLVM_ENABLED_TARGET_OS_MACOSX) ||   \
+  defined(LLVM_ENABLED_TARGET_OS_DARWIN)
     return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
+#else
+    return false;
+#endif
   }
 
   /// isOSDarwin - Is this a "Darwin" OS (OS X or iOS).
   bool isOSDarwin() const {
+#if defined(LLVM_ENABLED_TARGET_OS_MACOSX) ||                           \
+  defined(LLVM_ENABLED_TARGET_OS_DARWIN) ||                             \
+  defined(LLVM_ENABLED_TARGET_OS_IOS)
     return isMacOSX() || getOS() == Triple::IOS;
+#else
+    return false;
+#endif
   }
 
   /// isOSWindows - Is this a "Windows" OS.
   bool isOSWindows() const {
+#if defined(LLVM_ENABLED_TARGET_OS_WIN32) ||                            \
+  defined(LLVM_ENABLED_TARGET_OS_CYGWIN) ||                             \
+  defined(LLVM_ENABLED_TARGET_OS_MINGW32)
     return getOS() == Triple::Win32 || getOS() == Triple::Cygwin ||
       getOS() == Triple::MinGW32;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSAuroraUX - Is getOS() == AuroraUX.
+  bool isOSAuroraUX() const {
+#if defined(LLVM_ENABLED_TARGET_OS_AURORAUX)
+    return getOS() == Triple::AuroraUX;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSCygwin - Is getOS() == Cygwin.
+  bool isOSCygwin() const {
+#if defined(LLVM_ENABLED_TARGET_OS_CYGWIN)
+    return getOS() == Triple::Cygwin;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSDragonFly - Is getOS() == DragonFly.
+  bool isOSDragonFly() const {
+#if defined(LLVM_ENABLED_TARGET_OS_DRAGONFLY)
+    return getOS() == Triple::DragonFly;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSFreeBSD - Is getOS() == FreeBSD.
+  bool isOSFreeBSD() const {
+#if defined(LLVM_ENABLED_TARGET_OS_FREEBSD)
+    return getOS() == Triple::FreeBSD;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSIOS - Is getOS() == IOS
+  bool isOSIOS() const {
+#if defined(LLVM_ENABLED_TARGET_OS_IOS)
+    return getOS() == Triple::IOS;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSLinux - Is getOS() == Linux.
+  bool isOSLinux() const {
+#if defined(LLVM_ENABLED_TARGET_OS_LINUX)
+    return getOS() == Triple::Linux;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSLv2 - Is getOS() == Lv2.
+  bool isOSLv2() const {
+#if defined(LLVM_ENABLED_TARGET_OS_LV2)
+    return getOS() == Triple::Lv2;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSMinGW32 - Is getOS() == MinGW32.
+  bool isOSMinGW32() const {
+#if defined(LLVM_ENABLED_TARGET_OS_MINGW32)
+    return getOS() == Triple::MinGW32;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSNetBSD - Is getOS() == NetBSD.
+  bool isOSNetBSD() const {
+#if defined(LLVM_ENABLED_TARGET_OS_NETBSD)
+    return getOS() == Triple::NetBSD;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSOpenBSD - Is getOS() == OpenBSD.
+  bool isOSOpenBSD() const {
+#if defined(LLVM_ENABLED_TARGET_OS_OPENBSD)
+    return getOS() == Triple::OpenBSD;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSPsp - Is getOS() == Psp.
+  bool isOSPsp() const {
+#if defined(LLVM_ENABLED_TARGET_OS_PSP)
+    return getOS() == Triple::Psp;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSSolaris - Is getOS() == Solaris.
+  bool isOSSolaris() const {
+#if defined(LLVM_ENABLED_TARGET_OS_SOLARIS)
+    return getOS() == Triple::Solaris;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSWin32 - Is getOS() == Win32.
+  bool isOSWin32() const {
+#if defined(LLVM_ENABLED_TARGET_OS_WIN32)
+    return getOS() == Triple::Win32;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSHaiku - Is getOS() == Haiku.
+  bool isOSHaiku() const {
+#if defined(LLVM_ENABLED_TARGET_OS_HAIKU)
+    return getOS() == Triple::Haiku;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSMinix - Is getOS() == Minix.
+  bool isOSMinix() const {
+#if defined(LLVM_ENABLED_TARGET_OS_MINIX)
+    return getOS() == Triple::Minix;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSRTEMS - Is getOS() == RTEMS.
+  bool isOSRTEMS() const {
+#if defined(LLVM_ENABLED_TARGET_OS_RTEMS)
+    return getOS() == Triple::RTEMS;
+#else
+    return false;
+#endif
+  }
+
+  /// isOSNativeClient - Is getOS() == NativeClient.
+  bool isOSNativeClient() const {
+#if defined(LLVM_ENABLED_TARGET_OS_NATIVECLIENT)
+    return getOS() == Triple::NativeClient;
+#else
+    return false;
+#endif
   }
 
   /// isMacOSXVersionLT - Comparison function for checking OS X version
   /// compatibility, which handles supporting skewed version numbering schemes
   /// used by the "darwin" triples.
   unsigned isMacOSXVersionLT(unsigned Major, unsigned Minor = 0,
                              unsigned Micro = 0) const {
     assert(isMacOSX() && "Not an OS X triple!");
 
     // If this is OS X, expect a sane version number.
     if (getOS() == Triple::MacOSX)
       return isOSVersionLT(Major, Minor, Micro);
 
     // Otherwise, compare to the "Darwin" number.
     assert(Major == 10 && "Unexpected major version");
     return isOSVersionLT(Minor + 4, Micro, 0);
   }
 
+  /// isEnvironmentEABI - Is getEnvironment() == EABI.
+  bool isEnvironmentEABI() const {
+#if defined(LLVM_ENABLED_TARGET_ENV_EABI)
+    return getEnvironment() == Triple::EABI;
+#else
+    return false;
+#endif
+  }
+
+  /// isEnvironmentGNUEABI - Is getEnvironment() == GNUEABI.
+  bool isEnvironmentGNUEABI() const {
+#if defined(LLVM_ENABLED_TARGET_ENV_GNUEABI)
+    return getEnvironment() == Triple::GNUEABI;
+#else
+    return false;
+#endif
+  }
+
+  /// isEnvironmentGNU - Is getEnvironment() == GNU.
+  bool isEnvironmentGNU() const {
+#if defined(LLVM_ENABLED_TARGET_ENV_GNU)
+    return getEnvironment() == Triple::GNU;
+#else
+    return false;
+#endif
+  }
+
+  /// isEnvironmentMachO - Is getEnvironment() == MachO.
+  bool isEnvironmentMachO() const {
+#if defined(LLVM_ENABLED_TARGET_ENV_MACHO)
+    return getEnvironment() == Triple::MachO;
+#else
+    return false;
+#endif
+  }
+
   /// @}
   /// @name Mutators
   /// @{
 
   /// setArch - Set the architecture (first) component of the triple
   /// to a known type.
   void setArch(ArchType Kind);
 
   /// setVendor - Set the vendor (second) component of the triple to a
   /// known type.
@@ skipping 75 matching lines @@
   /// arch(3)).
   static ArchType getArchTypeForDarwinArchName(StringRef Str);
 
   /// @}
 };
 
 } // End llvm namespace
 
 
 #endif