Rebased PNaCl localmods in LLVM to 223109

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 203 matching lines @@
 
   /// getArch - Get the parsed architecture type of this triple.
   ArchType getArch() const { return Arch; }
 
   /// getSubArch - get the parsed subarchitecture type for this triple.
   SubArchType getSubArch() const { return SubArch; }
 
   /// getVendor - Get the parsed vendor type of this triple.
   VendorType getVendor() const { return Vendor; }
 
+  // @LOCALMOD-BEGIN -- hardcode NaCl for NaCl builds, to help
+  // prune OS-specific code that is litered all over and not
+  // cleanly separated.
+#if defined(__native_client__)
+  OSType getOS() const { return NaCl; }
+  ObjectFormatType getObjectFormat() const { return ELF; }
+#else
   /// getOS - Get the parsed operating system type of this triple.
   OSType getOS() const { return OS; }
 
+  /// getFormat - Get the object format for this triple.
+  ObjectFormatType getObjectFormat() const { return ObjectFormat; }
+#endif
+  // @LOCALMOD-END
+
   /// hasEnvironment - Does this triple have the optional environment
   /// (fourth) component?
   bool hasEnvironment() const {
     return getEnvironmentName() != "";
   }
 
   /// getEnvironment - Get the parsed environment type of this triple.
   EnvironmentType getEnvironment() const { return Environment; }
 
-  /// getFormat - Get the object format for this triple.
-  ObjectFormatType getObjectFormat() const { return ObjectFormat; }
-
   /// getOSVersion - Parse the version number from the OS name component of the
   /// triple, if present.
   ///
   /// For example, "fooos1.2.3" would return (1, 2, 3).
   ///
   /// If an entry is not defined, it will be returned as 0.
   void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const;
 
   /// getOSMajorVersion - Return just the major version number, this is
   /// specialized because it is a common query.
@@ skipping 92 matching lines @@
 
     // 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);
   }
 
+  // @LOCALMOD-BEGIN: Hardcode OS predicates to help prune code
+  // that is OS-specific, but not cleanly separated.
+  // Perhaps this would be cleaner if Triple.h was partly Table-gen'ed.
+#if defined(__native_client__)
+  bool isMacOSX() const { return false; }
+  bool isiOS() const { return false; }
+  bool isOSDarwin() const { return false; }
+  bool isOSNetBSD() const { return false; }
+  bool isOSOpenBSD() const { return false; }
+  bool isOSFreeBSD() const { return false; }
+  bool isOSSolaris() const { return false; }
+  bool isOSBitrig() const { return false; }
+  bool isWindowsMSVCEnvironment() const { return false; }
+  bool isKnownWindowsMSVCEnvironment() const { return false; }
+  bool isWindowsItaniumEnvironment() const { return false; }
+  bool isWindowsCygwinEnvironment() const { return false; }
+  bool isWindowsGNUEnvironment() const { return false; }
+  bool isOSCygMing() const { return false; }
+  bool isOSMSVCRT() const { return false; }
+  bool isOSWindows() const { return false; }
+  bool isOSNaCl() const { return true; }
+  bool isOSLinux() const { return false; }
+  bool isOSBinFormatELF() const { return true; }
+  bool isOSBinFormatCOFF() const { return false; }
+  bool isOSBinFormatMachO() const { return false; }
+#else
   /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
   /// "darwin" and "osx" as OS X triples.
   bool isMacOSX() const {
     return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
   }
 
   /// Is this an iOS triple.
   bool isiOS() const {
     return getOS() == Triple::IOS;
   }
@@ skipping 78 matching lines @@
 
   /// \brief Tests whether the OS uses the COFF binary format.
   bool isOSBinFormatCOFF() const {
     return getObjectFormat() == Triple::COFF;
   }
 
   /// \brief Tests whether the environment is MachO.
   bool isOSBinFormatMachO() const {
     return getObjectFormat() == Triple::MachO;
   }
+#endif
+  // @LOCALMOD-END
 
   /// @}
   /// @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
@@ skipping 93 matching lines @@
   /// architecture name (e.g., "x86").
   static ArchType getArchTypeForLLVMName(StringRef Str);
 
   /// @}
 };
 
 } // End llvm namespace
 
 
 #endif