Remove NaCl support.

src/base/platform/platform-linux.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Platform-specific code for Linux goes here. For the POSIX-compatible
 // parts, the implementation is in platform-posix.cc.
 
 #include <pthread.h>
 #include <semaphore.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/prctl.h>
 #include <sys/resource.h>
+#include <sys/syscall.h>
 #include <sys/time.h>
 
 // Ubuntu Dapper requires memory pages to be marked as
 // executable. Otherwise, OS raises an exception when executing code
 // in that page.
 #include <errno.h>
 #include <fcntl.h>      // open
 #include <stdarg.h>
 #include <strings.h>    // index
 #include <sys/mman.h>   // mmap & munmap
@@ skipping 13 matching lines @@
 #include <sanitizer/lsan_interface.h>
 #endif
 
 #include <cmath>
 
 #undef MAP_TYPE
 
 #include "src/base/macros.h"
 #include "src/base/platform/platform.h"
 
-#if V8_OS_NACL
-#if !defined(MAP_NORESERVE)
-// PNaCL doesn't have this, so we always grab all of the memory, which is bad.
-#define MAP_NORESERVE 0
-#endif
-#else
-#include <sys/prctl.h>
-#include <sys/syscall.h>
-#endif
-
 namespace v8 {
 namespace base {
 
 
 #ifdef __arm__
 
 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
@@ skipping 28 matching lines @@
 
 #endif
 #endif
 #undef GCC_VERSION
 }
 
 #endif  // def __arm__
 
 
 const char* OS::LocalTimezone(double time, TimezoneCache* cache) {
-#if V8_OS_NACL
-  // Missing support for tm_zone field.
-  return "";
-#else
   if (std::isnan(time)) return "";
   time_t tv = static_cast<time_t>(std::floor(time/msPerSecond));
   struct tm* t = localtime(&tv);  // NOLINT(runtime/threadsafe_fn)
   if (!t || !t->tm_zone) return "";
   return t->tm_zone;
-#endif
 }
 
 
 double OS::LocalTimeOffset(TimezoneCache* cache) {
-#if V8_OS_NACL
-  // Missing support for tm_zone field.
-  return 0;
-#else
   time_t tv = time(NULL);
   struct tm* t = localtime(&tv);  // NOLINT(runtime/threadsafe_fn)
   // tm_gmtoff includes any daylight savings offset, so subtract it.
   return static_cast<double>(t->tm_gmtoff * msPerSecond -
                              (t->tm_isdst > 0 ? 3600 * msPerSecond : 0));
-#endif
 }
 
 
 void* OS::Allocate(const size_t requested,
                    size_t* allocated,
                    bool is_executable) {
   const size_t msize = RoundUp(requested, AllocateAlignment());
   int prot = PROT_READ | PROT_WRITE | (is_executable ? PROT_EXEC : 0);
   void* addr = OS::GetRandomMmapAddr();
   void* mbase = mmap(addr, msize, prot, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
@@ skipping 74 matching lines @@
   // it. This injects a GC marker into the stream of events generated
   // by the kernel and allows us to synchronize V8 code log and the
   // kernel log.
   long size = sysconf(_SC_PAGESIZE);  // NOLINT(runtime/int)
   FILE* f = fopen(OS::GetGCFakeMMapFile(), "w+");
   if (f == NULL) {
     OS::PrintError("Failed to open %s\n", OS::GetGCFakeMMapFile());
     OS::Abort();
   }
   void* addr = mmap(OS::GetRandomMmapAddr(), size,
-#if V8_OS_NACL
-                    // The Native Client port of V8 uses an interpreter,
-                    // so code pages don't need PROT_EXEC.
-                    PROT_READ,
-#else
                     PROT_READ | PROT_EXEC,
-#endif
                     MAP_PRIVATE, fileno(f), 0);
   DCHECK_NE(MAP_FAILED, addr);
   OS::Free(addr, size);
   fclose(f);
 }
 
 
 // Constants used for mmap.
 static const int kMmapFd = -1;
 static const int kMmapFdOffset = 0;
@@ skipping 99 matching lines @@
   if (result == MAP_FAILED) return NULL;
 
 #if defined(LEAK_SANITIZER)
   __lsan_register_root_region(result, size);
 #endif
   return result;
 }
 
 
 bool VirtualMemory::CommitRegion(void* base, size_t size, bool is_executable) {
-#if V8_OS_NACL
-  // The Native Client port of V8 uses an interpreter,
-  // so code pages don't need PROT_EXEC.
-  int prot = PROT_READ | PROT_WRITE;
-#else
   int prot = PROT_READ | PROT_WRITE | (is_executable ? PROT_EXEC : 0);
-#endif
   if (MAP_FAILED == mmap(base,
                          size,
                          prot,
                          MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
                          kMmapFd,
                          kMmapFdOffset)) {
     return false;
   }
 
   return true;
@@ skipping 25 matching lines @@
   return munmap(base, size) == 0;
 }
 
 
 bool VirtualMemory::HasLazyCommits() {
   return true;
 }
 
 }  // namespace base
 }  // namespace v8