Remove NaCl support.

Review-Url: https://codereview.chromium.org/2175193003
Cr-Commit-Position: refs/heads/master@{#38081}

.gn

@@ -42,7 +42,6 @@ exec_script_whitelist = [
   "//build/toolchain/concurrent_links.gni",
   "//build/toolchain/gcc_toolchain.gni",
   "//build/toolchain/mac/BUILD.gn",
-  "//build/toolchain/nacl/BUILD.gn",
   "//build/toolchain/win/BUILD.gn",
   "//build/util/branding.gni",
   "//build/util/version.gni",

BUILD.gn

@@ -2014,7 +2014,6 @@ v8_source_set("v8_libbase") {
     "src/base/atomicops_internals_mac.h",
     "src/base/atomicops_internals_mips64_gcc.h",
     "src/base/atomicops_internals_mips_gcc.h",
-    "src/base/atomicops_internals_portable.h",
     "src/base/atomicops_internals_s390_gcc.h",
     "src/base/atomicops_internals_tsan.h",
     "src/base/atomicops_internals_x86_gcc.cc",

Makefile

@@ -33,7 +33,6 @@ GYPFLAGS ?=
 TESTFLAGS ?=
 ANDROID_NDK_HOST_ARCH ?=
 ANDROID_V8 ?= /data/local/tmp/v8
-NACL_SDK_ROOT ?=
 
 # Special build flags. Use them like this: "make library=shared"
 
@@ -236,7 +235,6 @@ endif
 # - "native": current host's architecture, release mode
 # - any of the above with .check appended, e.g. "ia32.release.check"
 # - "android": cross-compile for Android/ARM
-# - "nacl" : cross-compile for Native Client (ia32 and x64)
 # - default (no target specified): build all DEFAULT_ARCHES and MODES
 # - "check": build all targets and run all tests
 # - "<arch>.clean" for any <arch> in ARCHES
@@ -254,7 +252,6 @@ MODES = release debug optdebug
 DEFAULT_MODES = release debug
 ANDROID_ARCHES = android_ia32 android_x64 android_arm android_arm64 \
 		 android_mipsel android_x87
-NACL_ARCHES = nacl_ia32 nacl_x64
 
 # List of files that trigger Makefile regeneration:
 GYPFILES = third_party/icu/icu.gypi third_party/icu/icu.gyp \
@@ -276,13 +273,10 @@ endif
 BUILDS = $(foreach mode,$(MODES),$(addsuffix .$(mode),$(ARCHES)))
 ANDROID_BUILDS = $(foreach mode,$(MODES), \
                    $(addsuffix .$(mode),$(ANDROID_ARCHES)))
-NACL_BUILDS = $(foreach mode,$(MODES), \
-                   $(addsuffix .$(mode),$(NACL_ARCHES)))
 # Generates corresponding test targets, e.g. "ia32.release.check".
 CHECKS = $(addsuffix .check,$(BUILDS))
 QUICKCHECKS = $(addsuffix .quickcheck,$(BUILDS))
 ANDROID_CHECKS = $(addsuffix .check,$(ANDROID_BUILDS))
-NACL_CHECKS = $(addsuffix .check,$(NACL_BUILDS))
 # File where previously used GYPFLAGS are stored.
 ENVFILE = $(OUTDIR)/environment
 
@@ -291,9 +285,7 @@ ENVFILE = $(OUTDIR)/environment
         $(addsuffix .quickcheck,$(MODES)) $(addsuffix .quickcheck,$(ARCHES)) \
         $(ARCHES) $(MODES) $(BUILDS) $(CHECKS) $(addsuffix .clean,$(ARCHES)) \
         $(addsuffix .check,$(MODES)) $(addsuffix .check,$(ARCHES)) \
-        $(ANDROID_ARCHES) $(ANDROID_BUILDS) $(ANDROID_CHECKS) \
-        $(NACL_ARCHES) $(NACL_BUILDS) $(NACL_CHECKS) \
-        must-set-NACL_SDK_ROOT
+        $(ANDROID_ARCHES) $(ANDROID_BUILDS) $(ANDROID_CHECKS)
 
 # Target definitions. "all" is the default.
 all: $(DEFAULT_MODES)
@@ -332,16 +324,6 @@ $(ANDROID_BUILDS): $(GYPFILES) $(ENVFILE) Makefile.android
 	        OUTDIR="$(OUTDIR)" \
 	        GYPFLAGS="$(GYPFLAGS)"
 
-$(NACL_ARCHES): $(addprefix $$@.,$(MODES))
-
-$(NACL_BUILDS): $(GYPFILES) $(ENVFILE) \
-		   Makefile.nacl must-set-NACL_SDK_ROOT
-	@$(MAKE) -f Makefile.nacl $@ \
-	        ARCH="$(basename $@)" \
-	        MODE="$(subst .,,$(suffix $@))" \
-	        OUTDIR="$(OUTDIR)" \
-	        GYPFLAGS="$(GYPFLAGS)"
-
 # Test targets.
 check: all
 	@tools/run-tests.py $(TESTJOBS) --outdir=$(OUTDIR) \
@@ -385,15 +367,6 @@ $(addsuffix .check, $(ANDROID_BUILDS)): $$(basename $$@).sync
 $(addsuffix .check, $(ANDROID_ARCHES)): \
                 $(addprefix $$(basename $$@).,$(MODES)).check
 
-$(addsuffix .check, $(NACL_BUILDS)): $$(basename $$@)
-	@tools/run-tests.py $(TESTJOBS) --outdir=$(OUTDIR) \
-	     --arch-and-mode=$(basename $@) \
-	     --timeout=600 --noi18n \
-	     --command-prefix="tools/nacl-run.py"
-
-$(addsuffix .check, $(NACL_ARCHES)): \
-                $(addprefix $$(basename $$@).,$(MODES)).check
-
 native.check: native
 	@tools/run-tests.py $(TESTJOBS) --outdir=$(OUTDIR)/native \
 	    --arch-and-mode=. $(TESTFLAGS)
@@ -423,7 +396,7 @@ turbocheck: $(subst $(COMMA),$(SPACE),$(FASTCOMPILEMODES))
 tc: turbocheck
 
 # Clean targets. You can clean each architecture individually, or everything.
-$(addsuffix .clean, $(ARCHES) $(ANDROID_ARCHES) $(NACL_ARCHES)):
+$(addsuffix .clean, $(ARCHES) $(ANDROID_ARCHES)):
 	rm -f $(OUTDIR)/Makefile.$(basename $@)*
 	rm -rf $(OUTDIR)/$(basename $@).release
 	rm -rf $(OUTDIR)/$(basename $@).debug
@@ -435,7 +408,7 @@ native.clean:
 	rm -rf $(OUTDIR)/native
 	find $(OUTDIR) -regex '.*\(host\|target\)\.native\.mk' -delete
 
-clean: $(addsuffix .clean, $(ARCHES) $(ANDROID_ARCHES) $(NACL_ARCHES)) native.clean gtags.clean tags.clean
+clean: $(addsuffix .clean, $(ARCHES) $(ANDROID_ARCHES)) native.clean gtags.clean tags.clean
 
 # GYP file generation targets.
 OUT_MAKEFILES = $(addprefix $(OUTDIR)/Makefile.,$(BUILDS))
@@ -467,18 +440,6 @@ $(OUTDIR)/Makefile.native: $(GYPFILES) $(ENVFILE)
 	tools/gyp/gyp --generator-output="$(OUTDIR)" gypfiles/all.gyp \
 	              -Igypfiles/standalone.gypi --depth=. -S.native $(GYPFLAGS)
 
-# Note that NACL_SDK_ROOT must be set to point to an appropriate
-# Native Client SDK before using this makefile. You can download
-# an SDK here:
-#   https://developers.google.com/native-client/sdk/download
-# The path indicated by NACL_SDK_ROOT will typically end with
-# a folder for a pepper version such as "pepper_25" that should
-# have "tools" and "toolchain" subdirectories.
-must-set-NACL_SDK_ROOT:
-ifndef NACL_SDK_ROOT
-	  $(error NACL_SDK_ROOT must be set)
-endif
-
 # Replaces the old with the new environment file if they're different, which
 # will trigger GYP to regenerate Makefiles.
 $(ENVFILE): $(ENVFILE).new

Makefile.nacl

-#
-# Copyright 2013 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
-#       with the distribution.
-#     * Neither the name of Google Inc. nor the names of its
-#       contributors may be used to endorse or promote products derived
-#       from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# 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.
-
-# Those definitions should be consistent with the main Makefile
-NACL_ARCHES = nacl_ia32 nacl_x64
-MODES = release debug
-
-# Generates all combinations of NACL ARCHES and MODES,
-# e.g. "nacl_ia32.release" or "nacl_x64.release"
-NACL_BUILDS = $(foreach mode,$(MODES), \
-                   $(addsuffix .$(mode),$(NACL_ARCHES)))
-
-HOST_OS = $(shell uname -s | sed -e 's/Linux/linux/;s/Darwin/mac/')
-TOOLCHAIN_PATH = $(realpath ${NACL_SDK_ROOT}/toolchain)
-NACL_TOOLCHAIN ?= ${TOOLCHAIN_PATH}/linux_pnacl
-
-ifeq ($(wildcard $(NACL_TOOLCHAIN)),)
-  $(error Cannot find Native Client toolchain in "${NACL_TOOLCHAIN}")
-endif
-
-ifeq ($(ARCH), nacl_ia32)
-  GYPENV = nacl_target_arch=nacl_ia32 v8_target_arch=arm v8_host_arch=ia32
-  NACL_CC = "$(NACL_TOOLCHAIN)/bin/pnacl-clang"
-  NACL_CXX = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++"
-  NACL_LINK = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++ --pnacl-allow-native -arch x86-32"
-else
-  ifeq ($(ARCH), nacl_x64)
-    GYPENV = nacl_target_arch=nacl_x64 v8_target_arch=arm v8_host_arch=ia32
-    NACL_CC = "$(NACL_TOOLCHAIN)/bin/pnacl-clang"
-    NACL_CXX = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++"
-    NACL_LINK = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++ --pnacl-allow-native -arch x86-64"
-  else
-    $(error Target architecture "${ARCH}" is not supported)
-  endif
-endif
-
-# For mksnapshot host generation.
-GYPENV += host_os=${HOST_OS}
-
-# ICU doesn't support NaCl.
-GYPENV += v8_enable_i18n_support=0
-
-# Disable strict aliasing - v8 code often relies on undefined behavior of C++.
-GYPENV += v8_no_strict_aliasing=1
-
-NACL_MAKEFILES = $(addprefix $(OUTDIR)/Makefile.,$(NACL_BUILDS))
-.SECONDEXPANSION:
-# For some reason the $$(basename $$@) expansion didn't work here...
-$(NACL_BUILDS): $(NACL_MAKEFILES)
-	@$(MAKE) -C "$(OUTDIR)" -f Makefile.$@ \
-	            CC=${NACL_CC} \
-	            CXX=${NACL_CXX} \
-	            AR="$(NACL_TOOLCHAIN)/bin/pnacl-ar" \
-	            RANLIB="$(NACL_TOOLCHAIN)/bin/pnacl-ranlib" \
-	            LD="$(NACL_TOOLCHAIN)/bin/pnacl-ld" \
-	            LINK=${NACL_LINK} \
-	            BUILDTYPE=$(shell echo $(subst .,,$(suffix $@)) | \
-	                        python -c "print raw_input().capitalize()") \
-	            builddir="$(shell pwd)/$(OUTDIR)/$@"
-
-# NACL GYP file generation targets.
-$(NACL_MAKEFILES):
-	GYP_GENERATORS=make \
-	GYP_DEFINES="${GYPENV}" \
-	CC=${NACL_CC} \
-	CXX=${NACL_CXX} \
-	LINK=${NACL_LINK} \
-	PYTHONPATH="$(shell pwd)/tools/generate_shim_headers:$(shell pwd)/build:$(PYTHONPATH)" \
-	tools/gyp/gyp --generator-output="${OUTDIR}" gypfiles/all.gyp \
-	              -Igypfiles/standalone.gypi --depth=. \
-	              -S$(suffix $(basename $@))$(suffix $@) $(GYPFLAGS) \
-                      -Dwno_array_bounds=-Wno-array-bounds

gni/v8.gni

@@ -63,7 +63,7 @@ if (is_debug && !v8_optimized_debug) {
 
   # TODO(crbug.com/621335) Rework this so that we don't have the confusion
   # between "optimize_speed" and "optimize_max".
-  if (is_posix && !is_android && !is_nacl && !using_sanitizer) {
+  if (is_posix && !is_android && !using_sanitizer) {
     v8_add_configs += [ "//build/config/compiler:optimize_speed" ]
   } else {
     v8_add_configs += [ "//build/config/compiler:optimize_max" ]

gypfiles/toolchain.gypi

@@ -42,13 +42,6 @@
     'v8_target_arch%': '<(target_arch)',
     'v8_host_byteorder%': '<!(python -c "import sys; print sys.byteorder")',
     'force_dynamic_crt%': 0,
-    # Native Client builds currently use the V8 ARM JIT and
-    # arm/simulator-arm.cc to defer the significant effort required
-    # for NaCl JIT support. The nacl_target_arch variable provides
-    # the 'true' target arch for places in this file that need it.
-    # TODO(bradchen): get rid of nacl_target_arch when someday
-    # NaCl V8 builds stop using the ARM simulator
-    'nacl_target_arch%': 'none',     # must be set externally
 
     # Setting 'v8_can_use_vfp32dregs' to 'true' will cause V8 to use the VFP
     # registers d16-d31 in the generated code, both in the snapshot and for the
@@ -1029,7 +1022,7 @@
           }],
           ['_toolset=="target"', {
             'conditions': [
-              ['target_cxx_is_biarch==1 and nacl_target_arch!="nacl_x64"', {
+              ['target_cxx_is_biarch==1', {
                 'conditions': [
                   ['host_arch=="s390" or host_arch=="s390x"', {
                     'cflags': [ '-m31' ],
@@ -1192,9 +1185,8 @@
               '-ffunction-sections',
             ],
             'conditions': [
-              # TODO(crbug.com/272548): Avoid -O3 in NaCl
               # Don't use -O3 with sanitizers.
-              ['nacl_target_arch=="none" and asan==0 and msan==0 and lsan==0 \
+              ['asan==0 and msan==0 and lsan==0 \
                 and tsan==0 and ubsan==0 and ubsan_vptr==0', {
                 'cflags': ['-O3'],
                 'cflags!': ['-O2'],
@@ -1311,9 +1303,8 @@
               '<(wno_array_bounds)',
             ],
             'conditions': [
-              # TODO(crbug.com/272548): Avoid -O3 in NaCl
               # Don't use -O3 with sanitizers.
-              ['nacl_target_arch=="none" and asan==0 and msan==0 and lsan==0 \
+              ['asan==0 and msan==0 and lsan==0 \
                 and tsan==0 and ubsan==0 and ubsan_vptr==0', {
                 'cflags': ['-O3'],
                 'cflags!': ['-O2'],

gypfiles/vs_toolchain.py

@@ -236,22 +236,14 @@ def CopyVsRuntimeDlls(output_dir, runtime_dirs):
   """
   x86, x64 = runtime_dirs
   out_debug = os.path.join(output_dir, 'Debug')
-  out_debug_nacl64 = os.path.join(output_dir, 'Debug', 'x64')
   out_release = os.path.join(output_dir, 'Release')
-  out_release_nacl64 = os.path.join(output_dir, 'Release', 'x64')
   out_debug_x64 = os.path.join(output_dir, 'Debug_x64')
   out_release_x64 = os.path.join(output_dir, 'Release_x64')
 
-  if os.path.exists(out_debug) and not os.path.exists(out_debug_nacl64):
-    os.makedirs(out_debug_nacl64)
-  if os.path.exists(out_release) and not os.path.exists(out_release_nacl64):
-    os.makedirs(out_release_nacl64)
   _CopyRuntime(out_debug,          x86, "x86", debug=True)
   _CopyRuntime(out_release,        x86, "x86", debug=False)
   _CopyRuntime(out_debug_x64,      x64, "x64", debug=True)
   _CopyRuntime(out_release_x64,    x64, "x64", debug=False)
-  _CopyRuntime(out_debug_nacl64,   x64, "x64", debug=True)
-  _CopyRuntime(out_release_nacl64, x64, "x64", debug=False)
 
 
 def CopyDlls(target_dir, configuration, target_cpu):

include/v8config.h

@@ -63,7 +63,6 @@
 //  V8_OS_FREEBSD       - FreeBSD
 //  V8_OS_LINUX         - Linux
 //  V8_OS_MACOSX        - Mac OS X
-//  V8_OS_NACL          - Native Client
 //  V8_OS_NETBSD        - NetBSD
 //  V8_OS_OPENBSD       - OpenBSD
 //  V8_OS_POSIX         - POSIX compatible (mostly everything except Windows)
@@ -80,9 +79,6 @@
 # define V8_OS_BSD 1
 # define V8_OS_MACOSX 1
 # define V8_OS_POSIX 1
-#elif defined(__native_client__)
-# define V8_OS_NACL 1
-# define V8_OS_POSIX 1
 #elif defined(__CYGWIN__)
 # define V8_OS_CYGWIN 1
 # define V8_OS_POSIX 1

src/base/atomicops.h

@@ -42,17 +42,15 @@ namespace base {
 
 typedef char Atomic8;
 typedef int32_t Atomic32;
-#if defined(__native_client__)
-typedef int64_t Atomic64;
-#elif defined(V8_HOST_ARCH_64_BIT)
+#if defined(V8_HOST_ARCH_64_BIT)
 // We need to be able to go between Atomic64 and AtomicWord implicitly.  This
 // means Atomic64 and AtomicWord should be the same type on 64-bit.
 #if defined(__ILP32__)
 typedef int64_t Atomic64;
 #else
 typedef intptr_t Atomic64;
+#endif  // defined(__ILP32__)
 #endif  // defined(V8_HOST_ARCH_64_BIT)
-#endif  // defined(__native_client__)
 
 // Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
 // Atomic64 routines below, depending on your architecture.
@@ -143,8 +141,6 @@ Atomic64 Release_Load(volatile const Atomic64* ptr);
 #include "src/base/atomicops_internals_x86_msvc.h"
 #elif defined(__APPLE__)
 #include "src/base/atomicops_internals_mac.h"
-#elif defined(__native_client__)
-#include "src/base/atomicops_internals_portable.h"
 #elif defined(__GNUC__) && V8_HOST_ARCH_ARM64
 #include "src/base/atomicops_internals_arm64_gcc.h"
 #elif defined(__GNUC__) && V8_HOST_ARCH_ARM

src/base/atomicops_internals_portable.h

-// 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.
-
-// This file is an internal atomic implementation, use atomicops.h instead.
-
-#ifndef V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
-#define V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
-
-namespace v8 {
-namespace base {
-
-inline void MemoryBarrier() { __sync_synchronize(); }
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  return __sync_lock_test_and_set(ptr, new_value);
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  return __sync_add_and_fetch(ptr, increment);
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  return __sync_add_and_fetch(ptr, increment);
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value, Atomic32 new_value) {
-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value, Atomic32 new_value) {
-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile Atomic8* ptr, Atomic8 value) {
-  __sync_lock_test_and_set(ptr, value);
-}
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  __sync_lock_test_and_set(ptr, value);
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  __sync_lock_test_and_set(ptr, value);
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  __sync_lock_test_and_set(ptr, value);
-}
-
-inline Atomic8 NoBarrier_Load(volatile const Atomic8* ptr) {
-  return __sync_add_and_fetch(ptr, 0);
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return __sync_add_and_fetch(ptr, 0);
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  return __sync_add_and_fetch(ptr, 0);
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  return __sync_add_and_fetch(ptr, 0);
-}
-
-// 64-bit versions of the operations.
-// See the 32-bit versions for comments.
-
-inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                         Atomic64 old_value,
-                                         Atomic64 new_value) {
-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
-}
-
-inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
-                                         Atomic64 new_value) {
-  return __sync_lock_test_and_set(ptr, new_value);
-}
-
-inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
-                                          Atomic64 increment) {
-  return __sync_add_and_fetch(ptr, increment);
-}
-
-inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  return __sync_add_and_fetch(ptr, increment);
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value, Atomic64 new_value) {
-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value, Atomic64 new_value) {
-  return __sync_val_compare_and_swap(ptr, old_value, new_value);
-}
-
-inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
-  __sync_lock_test_and_set(ptr, value);
-}
-
-inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
-  __sync_lock_test_and_set(ptr, value);
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  __sync_lock_test_and_set(ptr, value);
-}
-
-inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
-  return __sync_add_and_fetch(ptr, 0);
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  return __sync_add_and_fetch(ptr, 0);
-}
-
-inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
-  return __sync_add_and_fetch(ptr, 0);
-}
-}  // namespace base
-}  // namespace v8
-
-#endif  // V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_

src/base/build_config.h

@@ -12,27 +12,12 @@
 //   http://www.agner.org/optimize/calling_conventions.pdf
 //   or with gcc, run: "echo | gcc -E -dM -"
 #if defined(_M_X64) || defined(__x86_64__)
-#if defined(__native_client__)
-// For Native Client builds of V8, use V8_TARGET_ARCH_ARM, so that V8
-// generates ARM machine code, together with a portable ARM simulator
-// compiled for the host architecture in question.
-//
-// Since Native Client is ILP-32 on all architectures we use
-// V8_HOST_ARCH_IA32 on both 32- and 64-bit x86.
-#define V8_HOST_ARCH_IA32 1
-#define V8_HOST_ARCH_32_BIT 1
-#else
 #define V8_HOST_ARCH_X64 1
 #if defined(__x86_64__) && __SIZEOF_POINTER__ == 4  // Check for x32.
 #define V8_HOST_ARCH_32_BIT 1
 #else
 #define V8_HOST_ARCH_64_BIT 1
 #endif
-#endif  // __native_client__
-#elif defined(__pnacl__)
-// PNaCl is also ILP-32.
-#define V8_HOST_ARCH_IA32 1
-#define V8_HOST_ARCH_32_BIT 1
 #elif defined(_M_IX86) || defined(__i386__)
 #define V8_HOST_ARCH_IA32 1
 #define V8_HOST_ARCH_32_BIT 1

src/base/cpu.cc

@@ -44,9 +44,7 @@
 namespace v8 {
 namespace base {
 
-#if defined(__pnacl__)
-// Portable host shouldn't do feature detection.
-#elif V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
+#if V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
 
 // Define __cpuid() for non-MSVC libraries.
 #if !V8_LIBC_MSVCRT
@@ -341,11 +339,7 @@ CPU::CPU()
       is_fp64_mode_(false),
       has_non_stop_time_stamp_counter_(false) {
   memcpy(vendor_, "Unknown", 8);
-#if V8_OS_NACL
-// Portable host shouldn't do feature detection.
-// TODO(jfb): Remove the hardcoded ARM simulator flags in the build, and
-// hardcode them here instead.
-#elif V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
+#if V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
   int cpu_info[4];
 
   // __cpuid with an InfoType argument of 0 returns the number of

src/base/macros.h

@@ -17,55 +17,6 @@
   (reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(16)->field)) - 16)
 
 
-#if V8_OS_NACL
-
-// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize,
-// but can be used on anonymous types or types defined inside
-// functions.  It's less safe than arraysize as it accepts some
-// (although not all) pointers.  Therefore, you should use arraysize
-// whenever possible.
-//
-// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type
-// size_t.
-//
-// ARRAYSIZE_UNSAFE catches a few type errors.  If you see a compiler error
-//
-//   "warning: division by zero in ..."
-//
-// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer.
-// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays.
-//
-// The following comments are on the implementation details, and can
-// be ignored by the users.
-//
-// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in
-// the array) and sizeof(*(arr)) (the # of bytes in one array
-// element).  If the former is divisible by the latter, perhaps arr is
-// indeed an array, in which case the division result is the # of
-// elements in the array.  Otherwise, arr cannot possibly be an array,
-// and we generate a compiler error to prevent the code from
-// compiling.
-//
-// Since the size of bool is implementation-defined, we need to cast
-// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
-// result has type size_t.
-//
-// This macro is not perfect as it wrongfully accepts certain
-// pointers, namely where the pointer size is divisible by the pointee
-// size.  Since all our code has to go through a 32-bit compiler,
-// where a pointer is 4 bytes, this means all pointers to a type whose
-// size is 3 or greater than 4 will be (righteously) rejected.
-#define ARRAYSIZE_UNSAFE(a)     \
-  ((sizeof(a) / sizeof(*(a))) / \
-   static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))  // NOLINT
-
-// TODO(bmeurer): For some reason, the NaCl toolchain cannot handle the correct
-// definition of arraysize() below, so we have to use the unsafe version for
-// now.
-#define arraysize ARRAYSIZE_UNSAFE
-
-#else  // V8_OS_NACL
-
 // The arraysize(arr) macro returns the # of elements in an array arr.
 // The expression is a compile-time constant, and therefore can be
 // used in defining new arrays, for example.  If you use arraysize on
@@ -94,8 +45,6 @@ template <typename T, size_t N>
 char (&ArraySizeHelper(const T (&array)[N]))[N];
 #endif
 
-#endif  // V8_OS_NACL
-
 
 // bit_cast<Dest,Source> is a template function that implements the
 // equivalent of "*reinterpret_cast<Dest*>(&source)".  We need this in

src/base/platform/platform-aix.cc

@@ -215,13 +215,8 @@ void* VirtualMemory::ReserveRegion(size_t size) {
 
 
 bool VirtualMemory::CommitRegion(void* base, size_t size, bool is_executable) {
-#if defined(__native_client__)
-  // 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 (mprotect(base, size, prot) == -1) return false;
 
   return true;

src/base/platform/platform-linux.cc

@@ -10,7 +10,9 @@
 #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
@@ -44,16 +46,6 @@
 #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 {
 
@@ -102,30 +94,20 @@ bool OS::ArmUsingHardFloat() {
 
 
 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
 }
 
 
@@ -220,13 +202,7 @@ void OS::SignalCodeMovingGC() {
     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);
@@ -346,13 +322,7 @@ void* VirtualMemory::ReserveRegion(size_t size) {
 
 
 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,

src/base/platform/platform-posix.cc

@@ -55,7 +55,7 @@
 #include <sys/prctl.h>  // NOLINT, for prctl
 #endif
 
-#if !defined(V8_OS_NACL) && !defined(_AIX)
+#ifndef _AIX
 #include <sys/syscall.h>
 #endif
 
@@ -113,10 +113,6 @@ void OS::ProtectCode(void* address, const size_t size) {
 #if V8_OS_CYGWIN
   DWORD old_protect;
   VirtualProtect(address, size, PAGE_EXECUTE_READ, &old_protect);
-#elif V8_OS_NACL
-  // The Native Client port of V8 uses an interpreter, so
-  // code pages don't need PROT_EXEC.
-  mprotect(address, size, PROT_READ);
 #else
   mprotect(address, size, PROT_READ | PROT_EXEC);
 #endif
@@ -154,12 +150,6 @@ const char* OS::GetGCFakeMMapFile() {
 
 
 void* OS::GetRandomMmapAddr() {
-#if V8_OS_NACL
-  // TODO(bradchen): restore randomization once Native Client gets
-  // smarter about using mmap address hints.
-  // See http://code.google.com/p/nativeclient/issues/3341
-  return NULL;
-#endif
 #if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || \
     defined(THREAD_SANITIZER)
   // Dynamic tools do not support custom mmap addresses.
@@ -256,11 +246,7 @@ void OS::DebugBreak() {
 #elif V8_HOST_ARCH_PPC
   asm("twge 2,2");
 #elif V8_HOST_ARCH_IA32
-#if V8_OS_NACL
-  asm("hlt");
-#else
   asm("int $3");
-#endif  // V8_OS_NACL
 #elif V8_HOST_ARCH_X64
   asm("int $3");
 #elif V8_HOST_ARCH_S390
@@ -358,17 +344,12 @@ int OS::GetCurrentThreadId() {
 //
 
 int OS::GetUserTime(uint32_t* secs, uint32_t* usecs) {
-#if V8_OS_NACL
-  // Optionally used in Logger::ResourceEvent.
-  return -1;
-#else
   struct rusage usage;
 
   if (getrusage(RUSAGE_SELF, &usage) < 0) return -1;
   *secs = static_cast<uint32_t>(usage.ru_utime.tv_sec);
   *usecs = static_cast<uint32_t>(usage.ru_utime.tv_usec);
   return 0;
-#endif
 }
 
 
@@ -614,8 +595,6 @@ void Thread::Start() {
   memset(&attr, 0, sizeof(attr));
   result = pthread_attr_init(&attr);
   DCHECK_EQ(0, result);
-  // Native client uses default stack size.
-#if !V8_OS_NACL
   size_t stack_size = stack_size_;
 #if V8_OS_AIX
   if (stack_size == 0) {
@@ -627,7 +606,6 @@ void Thread::Start() {
     result = pthread_attr_setstacksize(&attr, stack_size);
     DCHECK_EQ(0, result);
   }
-#endif
   {
     LockGuard<Mutex> lock_guard(&data_->thread_creation_mutex_);
     result = pthread_create(&data_->thread_, &attr, ThreadEntry, this);

src/base/platform/semaphore.cc

@@ -120,17 +120,6 @@ void Semaphore::Wait() {
 
 
 bool Semaphore::WaitFor(const TimeDelta& rel_time) {
-#if V8_OS_NACL
-  // PNaCL doesn't support sem_timedwait, do ugly busy waiting.
-  ElapsedTimer timer;
-  timer.Start();
-  do {
-    int result = sem_trywait(&native_handle_);
-    if (result == 0) return true;
-    DCHECK(errno == EAGAIN || errno == EINTR);
-  } while (!timer.HasExpired(rel_time));
-  return false;
-#else
   // Compute the time for end of timeout.
   const Time time = Time::NowFromSystemTime() + rel_time;
   const struct timespec ts = time.ToTimespec();
@@ -154,7 +143,6 @@ bool Semaphore::WaitFor(const TimeDelta& rel_time) {
     DCHECK_EQ(-1, result);
     DCHECK_EQ(EINTR, errno);
   }
-#endif
 }
 
 #elif V8_OS_WIN

src/base/sys-info.cc

@@ -85,9 +85,6 @@ int64_t SysInfo::AmountOfPhysicalMemory() {
     return 0;
   }
   return static_cast<int64_t>(stat_buf.st_size);
-#elif V8_OS_NACL
-  // No support for _SC_PHYS_PAGES, assume 2GB.
-  return static_cast<int64_t>(1) << 31;
 #elif V8_OS_AIX
   int64_t result = sysconf(_SC_AIX_REALMEM);
   return static_cast<int64_t>(result) * 1024L;
@@ -104,7 +101,7 @@ int64_t SysInfo::AmountOfPhysicalMemory() {
 
 // static
 int64_t SysInfo::AmountOfVirtualMemory() {
-#if V8_OS_NACL || V8_OS_WIN
+#if V8_OS_WIN
   return 0;
 #elif V8_OS_POSIX
   struct rlimit rlim;

src/d8-posix.cc

@@ -7,6 +7,7 @@
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/select.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ -15,10 +16,6 @@
 
 #include "src/d8.h"
 
-#if !V8_OS_NACL
-#include <sys/select.h>
-#endif
-
 namespace v8 {
 
 
@@ -105,16 +102,11 @@ static bool WaitOnFD(int fd,
   }
   timeout.tv_usec = (read_timeout % 1000) * 1000;
   timeout.tv_sec = read_timeout / 1000;
-#if V8_OS_NACL
-  // PNaCL has no support for select.
-  int number_of_fds_ready = -1;
-#else
   int number_of_fds_ready = select(fd + 1,
                                    &readfds,
                                    &writefds,
                                    &exceptfds,
                                    read_timeout != -1 ? &timeout : NULL);
-#endif
   return number_of_fds_ready == 1;
 }
 
@@ -585,13 +577,8 @@ void Shell::SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args) {
     return;
   }
   if (args[0]->IsNumber()) {
-#if V8_OS_NACL
-    // PNaCL has no support for umask.
-    int previous = 0;
-#else
     int previous = umask(
         args[0]->Int32Value(args.GetIsolate()->GetCurrentContext()).FromJust());
-#endif
     args.GetReturnValue().Set(previous);
     return;
   } else {

src/d8.cc

@@ -1484,11 +1484,6 @@ void Shell::RunShell(Isolate* isolate) {
   while (true) {
     HandleScope inner_scope(isolate);
     printf("d8> ");
-#if defined(__native_client__)
-    // Native Client libc is used to being embedded in Chrome and
-    // has trouble recognizing when to flush.
-    fflush(stdout);
-#endif
     Local<String> input = Shell::ReadFromStdin(isolate);
     if (input.IsEmpty()) break;
     ExecuteString(isolate, input, name, true, true);

src/deoptimizer.cc

@@ -25,13 +25,7 @@ namespace internal {
 static MemoryChunk* AllocateCodeChunk(MemoryAllocator* allocator) {
   return allocator->AllocateChunk(Deoptimizer::GetMaxDeoptTableSize(),
                                   base::OS::CommitPageSize(),
-#if defined(__native_client__)
-  // The Native Client port of V8 uses an interpreter,
-  // so code pages don't need PROT_EXEC.
-                                  NOT_EXECUTABLE,
-#else
                                   EXECUTABLE,
-#endif
                                   NULL);
 }
 

src/libsampler/sampler.cc

@@ -13,7 +13,7 @@
 #include <signal.h>
 #include <sys/time.h>
 
-#if !V8_OS_QNX && !V8_OS_NACL && !V8_OS_AIX
+#if !V8_OS_QNX && !V8_OS_AIX
 #include <sys/syscall.h>  // NOLINT
 #endif
 
@@ -21,8 +21,7 @@
 #include <mach/mach.h>
 // OpenBSD doesn't have <ucontext.h>. ucontext_t lives in <signal.h>
 // and is a typedef for struct sigcontext. There is no uc_mcontext.
-#elif(!V8_OS_ANDROID || defined(__BIONIC_HAVE_UCONTEXT_T)) && \
-    !V8_OS_OPENBSD && !V8_OS_NACL
+#elif(!V8_OS_ANDROID || defined(__BIONIC_HAVE_UCONTEXT_T)) && !V8_OS_OPENBSD
 #include <ucontext.h>
 #endif
 
@@ -366,7 +365,6 @@ class SignalHandler {
 
  private:
   static void Install() {
-#if !V8_OS_NACL
     struct sigaction sa;
     sa.sa_sigaction = &HandleProfilerSignal;
     sigemptyset(&sa.sa_mask);
@@ -377,22 +375,18 @@ class SignalHandler {
 #endif
     signal_handler_installed_ =
         (sigaction(SIGPROF, &sa, &old_signal_handler_) == 0);
-#endif  // !V8_OS_NACL
   }
 
   static void Restore() {
-#if !V8_OS_NACL
     if (signal_handler_installed_) {
       sigaction(SIGPROF, &old_signal_handler_, 0);
       signal_handler_installed_ = false;
     }
-#endif
   }
 
-#if !V8_OS_NACL
   static void FillRegisterState(void* context, RegisterState* regs);
   static void HandleProfilerSignal(int signal, siginfo_t* info, void* context);
-#endif
+
   // Protects the process wide state below.
   static base::Mutex* mutex_;
   static int client_count_;
@@ -406,8 +400,6 @@ struct sigaction SignalHandler::old_signal_handler_;
 bool SignalHandler::signal_handler_installed_ = false;
 
 
-// As Native Client does not support signal handling, profiling is disabled.
-#if !V8_OS_NACL
 void SignalHandler::HandleProfilerSignal(int signal, siginfo_t* info,
                                          void* context) {
   USE(info);
@@ -552,8 +544,6 @@ void SignalHandler::FillRegisterState(void* context, RegisterState* state) {
 #endif  // V8_OS_AIX
 }
 
-#endif  // !V8_OS_NACL
-
 #endif  // USE_SIGNALS
 
 

src/utils.h

@@ -1099,13 +1099,6 @@ inline void MemsetPointer(T** dest, U* value, int counter) {
 #define STOS "stosq"
 #endif
 #endif
-#if defined(__native_client__)
-  // This STOS sequence does not validate for x86_64 Native Client.
-  // Here we #undef STOS to force use of the slower C version.
-  // TODO(bradchen): Profile V8 and implement a faster REP STOS
-  // here if the profile indicates it matters.
-#undef STOS
-#endif
 
 #if defined(MEMORY_SANITIZER)
   // MemorySanitizer does not understand inline assembly.

src/v8.gyp

@@ -1744,7 +1744,6 @@
         'base/atomicops_internals_mac.h',
         'base/atomicops_internals_mips_gcc.h',
         'base/atomicops_internals_mips64_gcc.h',
-        'base/atomicops_internals_portable.h',
         'base/atomicops_internals_ppc_gcc.h',
         'base/atomicops_internals_s390_gcc.h',
         'base/atomicops_internals_tsan.h',
@@ -1801,20 +1800,12 @@
           'toolsets': ['target'],
         }],
         ['OS=="linux"', {
-            'conditions': [
-              ['nacl_target_arch=="none"', {
-                'link_settings': {
-                  'libraries': [
-                    '-ldl',
-                    '-lrt'
-                  ],
-                },
-              }, {
-                'defines': [
-                  'V8_LIBRT_NOT_AVAILABLE=1',
-                ],
-              }],
-            ],
+            'link_settings': {
+              'libraries': [
+                '-ldl',
+                '-lrt'
+              ],
+            },
             'sources': [
               'base/platform/platform-linux.cc',
               'base/platform/platform-posix.cc'

test/cctest/test-api.cc

@@ -22176,7 +22176,7 @@ THREADED_TEST(JSONStringifyObjectWithGap) {
   ExpectString("JSON.stringify(obj, null,  '*')", *utf8);
 }
 
-#if V8_OS_POSIX && !V8_OS_NACL
+#if V8_OS_POSIX
 class ThreadInterruptTest {
  public:
   ThreadInterruptTest() : sem_(0), sem_value_(0) { }

test/unittests/base/sys-info-unittest.cc

@@ -5,12 +5,6 @@
 #include "src/base/sys-info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if V8_OS_NACL
-#define DISABLE_ON_NACL(Name) DISABLED_##Name
-#else
-#define DISABLE_ON_NACL(Name) Name
-#endif
-
 namespace v8 {
 namespace base {
 
@@ -18,8 +12,7 @@ TEST(SysInfoTest, NumberOfProcessors) {
   EXPECT_LT(0, SysInfo::NumberOfProcessors());
 }
 
-
-TEST(SysInfoTest, DISABLE_ON_NACL(AmountOfPhysicalMemory)) {
+TEST(SysInfoTest, AmountOfPhysicalMemory) {
   EXPECT_LT(0, SysInfo::AmountOfPhysicalMemory());
 }
 

tools/nacl-run.py

-#!/usr/bin/env python
-#
-# Copyright 2013 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
-#       with the distribution.
-#     * Neither the name of Google Inc. nor the names of its
-#       contributors may be used to endorse or promote products derived
-#       from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# 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.
-
-# This script executes the passed command line using the Native Client
-# 'sel_ldr' container. It is derived from android-run.py.
-
-import os
-from os.path import join, dirname, abspath
-import re
-import subprocess
-import sys
-import tempfile
-
-def Check(output, errors):
-  failed = any([s.startswith('/system/bin/sh:') or s.startswith('ANDROID')
-                for s in output.split('\n')])
-  return 1 if failed else 0
-
-def Execute(cmdline):
-  (fd_out, outname) = tempfile.mkstemp()
-  (fd_err, errname) = tempfile.mkstemp()
-  process = subprocess.Popen(
-    args=cmdline,
-    shell=True,
-    stdout=fd_out,
-    stderr=fd_err,
-  )
-  exit_code = process.wait()
-  os.close(fd_out)
-  os.close(fd_err)
-  output = file(outname).read()
-  errors = file(errname).read()
-  os.unlink(outname)
-  os.unlink(errname)
-  sys.stdout.write(output)
-  sys.stderr.write(errors)
-  return exit_code or Check(output, errors)
-
-def Escape(arg):
-  def ShouldEscape():
-    for x in arg:
-      if not x.isalnum() and x != '-' and x != '_':
-        return True
-    return False
-
-  return arg if not ShouldEscape() else '"%s"' % (arg.replace('"', '\\"'))
-
-def WriteToTemporaryFile(data):
-  (fd, fname) = tempfile.mkstemp()
-  os.close(fd)
-  tmp_file = open(fname, "w")
-  tmp_file.write(data)
-  tmp_file.close()
-  return fname
-
-def GetNaClArchFromNexe(nexe):
-  try:
-    p = subprocess.Popen(['file', nexe], stdout=subprocess.PIPE)
-    out, err = p.communicate()
-    lines = [re.sub("\s+", " " , line) for line in out.split('\n')]
-    if lines[0].find(": ELF 32-bit LSB executable, Intel 80386") > 0:
-      return "x86_32"
-    if lines[0].find(": ELF 64-bit LSB executable, x86-64") > 0:
-      return "x86_64"
-  except:
-    print 'file ' + sys.argv[1] + ' failed'
-  return None
-
-def GetNaClResources(nexe):
-  nacl_sdk_dir = os.environ["NACL_SDK_ROOT"]
-  nacl_arch = GetNaClArchFromNexe(nexe)
-  if sys.platform.startswith("linux"):
-    platform = "linux"
-  elif sys.platform == "darwin":
-    platform = "mac"
-  else:
-    print("NaCl V8 testing is supported on Linux and MacOS only.")
-    sys.exit(1)
-
-  if nacl_arch is "x86_64":
-    toolchain = platform + "_x86_glibc"
-    sel_ldr = "sel_ldr_x86_64"
-    irt = "irt_core_x86_64.nexe"
-    libdir = "lib64"
-  elif nacl_arch is "x86_32":
-    toolchain = platform + "_x86_glibc"
-    sel_ldr = "sel_ldr_x86_32"
-    irt = "irt_core_x86_32.nexe"
-    libdir = "lib32"
-  elif nacl_arch is "arm":
-    print("NaCl V8 ARM support is not ready yet.")
-    sys.exit(1)
-  else:
-    print("Invalid nexe %s with NaCl arch %s" % (nexe, nacl_arch))
-    sys.exit(1)
-
-  nacl_sel_ldr = os.path.join(nacl_sdk_dir, "tools", sel_ldr)
-  nacl_irt = os.path.join(nacl_sdk_dir, "tools", irt)
-
-  return (nacl_sdk_dir, nacl_sel_ldr, nacl_irt)
-
-def Main():
-  if (len(sys.argv) == 1):
-    print("Usage: %s <command-to-run-on-device>" % sys.argv[0])
-    return 1
-
-  args = [Escape(arg) for arg in sys.argv[1:]]
-
-  (nacl_sdk_dir, nacl_sel_ldr, nacl_irt) = GetNaClResources(sys.argv[1])
-
-  # sel_ldr Options:
-  # -c -c: disable validation (for performance)
-  # -a: allow file access
-  # -B <irt>: load the IRT
-  command = ' '.join([nacl_sel_ldr, '-c', '-c', '-a', '-B', nacl_irt, '--'] +
-                     args)
-  error_code = Execute(command)
-  return error_code
-
-if __name__ == '__main__':
-  sys.exit(Main())