Revert new OS and CC detection and related changes since r15923.

src/platform-linux.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Platform specific code for Linux goes here. For the POSIX comaptible parts
 // the implementation is in platform-posix.cc.
 
-#include "platform.h"
-
 #include <pthread.h>
 #include <semaphore.h>
 #include <signal.h>
 #include <sys/prctl.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <stdlib.h>
 
 #if defined(__GLIBC__) && !defined(__UCLIBC__)
 #include <execinfo.h>
 #include <cxxabi.h>
 #endif
 
 // Ubuntu Dapper requires memory pages to be marked as
 // executable. Otherwise, OS raises an exception when executing code
 // in that page.
 #include <sys/types.h>  // mmap & munmap
 #include <sys/mman.h>   // mmap & munmap
 #include <sys/stat.h>   // open
 #include <fcntl.h>      // open
 #include <unistd.h>     // sysconf
 #include <strings.h>    // index
 #include <errno.h>
 #include <stdarg.h>
 
 // GLibc on ARM defines mcontext_t has a typedef for 'struct sigcontext'.
 // Old versions of the C library <signal.h> didn't define the type.
-#if V8_OS_ANDROID && !defined(__BIONIC_HAVE_UCONTEXT_T) && \
-    V8_HOST_ARCH_ARM && !defined(__BIONIC_HAVE_STRUCT_SIGCONTEXT)
+#if defined(__ANDROID__) && !defined(__BIONIC_HAVE_UCONTEXT_T) && \
+    defined(__arm__) && !defined(__BIONIC_HAVE_STRUCT_SIGCONTEXT)
 #include <asm/sigcontext.h>
 #endif
 
 #undef MAP_TYPE
 
 #include "v8.h"
 
 #include "platform-posix.h"
+#include "platform.h"
 #include "v8threads.h"
 #include "vm-state-inl.h"
 
 
 namespace v8 {
 namespace internal {
 
 
 static Mutex* limit_mutex = NULL;
 
 
-#if V8_HOST_ARCH_ARM
+#ifdef __arm__
 static bool CPUInfoContainsString(const char * search_string) {
   const char* file_name = "/proc/cpuinfo";
   // This is written as a straight shot one pass parser
   // and not using STL string and ifstream because,
   // on Linux, it's reading from a (non-mmap-able)
   // character special device.
   FILE* f = NULL;
   const char* what = search_string;
 
   if (NULL == (f = fopen(file_name, "r"))) {
@@ skipping 122 matching lines @@
 
 
 bool OS::ArmUsingHardFloat() {
   // GCC versions 4.6 and above define __ARM_PCS or __ARM_PCS_VFP to specify
   // the Floating Point ABI used (PCS stands for Procedure Call Standard).
   // We use these as well as a couple of other defines to statically determine
   // what FP ABI used.
   // GCC versions 4.4 and below don't support hard-fp.
   // GCC versions 4.5 may support hard-fp without defining __ARM_PCS or
   // __ARM_PCS_VFP.
+
+#define GCC_VERSION (__GNUC__ * 10000                                          \
+                     + __GNUC_MINOR__ * 100                                    \
+                     + __GNUC_PATCHLEVEL__)
+#if GCC_VERSION >= 40600
 #if defined(__ARM_PCS_VFP)
   return true;
-#elif V8_CC_GNU && (V8_GNUC_PREREQ(4, 6) || !V8_GNUC_PREREQ(4, 5))
+#else
   return false;
+#endif
+
+#elif GCC_VERSION < 40500
+  return false;
+
+#else
+#if defined(__ARM_PCS_VFP)
+  return true;
 #elif defined(__ARM_PCS) || defined(__SOFTFP) || !defined(__VFP_FP__)
   return false;
 #else
 #error "Your version of GCC does not report the FP ABI compiled for."          \
        "Please report it on this issue"                                        \
        "http://code.google.com/p/v8/issues/detail?id=2140"
+
 #endif
+#endif
+#undef GCC_VERSION
 }
 
-#endif  // V8_HOST_ARCH_ARM
+#endif  // def __arm__
 
 
-#if V8_HOST_ARCH_MIPS
+#ifdef __mips__
 bool OS::MipsCpuHasFeature(CpuFeature feature) {
   const char* search_string = NULL;
   const char* file_name = "/proc/cpuinfo";
   // Simple detection of FPU at runtime for Linux.
   // It is based on /proc/cpuinfo, which reveals hardware configuration
   // to user-space applications.  According to MIPS (early 2010), no similar
   // facility is universally available on the MIPS architectures,
   // so it's up to individual OSes to provide such.
   //
   // This is written as a straight shot one pass parser
@@ skipping 30 matching lines @@
       } else {
         what = search_string;
       }
     }
   }
   fclose(f);
 
   // Did not find string in the proc file.
   return false;
 }
-#endif  // V8_HOST_ARCH_MIPS
+#endif  // def __mips__
 
 
 const char* OS::LocalTimezone(double time) {
   if (std::isnan(time)) return "";
   time_t tv = static_cast<time_t>(floor(time/msPerSecond));
   struct tm* t = localtime(&tv);
   if (NULL == t) return "";
   return t->tm_zone;
 }
 
@@ skipping 441 matching lines @@
   limit_mutex = CreateMutex();
 }
 
 
 void OS::TearDown() {
   delete limit_mutex;
 }
 
 
 } }  // namespace v8::internal