Bug 977338 - Remove AtomicOperations-inl.h, r=lth
authorSteve Fink <sfink@mozilla.com>
Tue, 06 Oct 2015 00:15:02 -0700
changeset 299799 2b20eccdb23e3b1e9308d572327ab5786c1ab8b8
parent 299798 eda99e9e730d3eaf369d918cdc553fc6535736ba
child 299800 f641c7662bddcf35262c483455f45e1f798e1b09
push id5392
push userraliiev@mozilla.com
push dateMon, 14 Dec 2015 20:08:23 +0000
treeherdermozilla-beta@16ce8562a975 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerslth
bugs977338
milestone44.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 977338 - Remove AtomicOperations-inl.h, r=lth
js/src/asmjs/AsmJSSignalHandlers.cpp
js/src/asmjs/AsmJSValidate.cpp
js/src/builtin/AtomicsObject.cpp
js/src/jit/AtomicOperations-inl.h
js/src/jit/AtomicOperations.h
js/src/jit/BaselineIC.cpp
js/src/jit/CodeGenerator.cpp
js/src/jit/MIR.cpp
js/src/jit/RangeAnalysis.cpp
js/src/jit/arm/Assembler-arm.cpp
js/src/jit/arm/AtomicOperations-arm.h
js/src/jit/arm/disasm/Constants-arm.h
js/src/jit/arm/disasm/Disasm-arm.h
js/src/jit/arm64/AtomicOperations-arm64.h
js/src/jit/mips-shared/AtomicOperations-mips-shared.h
js/src/jit/none/AtomicOperations-none.h
js/src/jit/x86-shared/AtomicOperations-x86-shared.h
js/src/jsapi.cpp
js/src/jsarray.cpp
js/src/jsiter.cpp
js/src/jsobj.cpp
js/src/jsobjinlines.h
js/src/vm/Interpreter.cpp
js/src/vm/NativeObject.cpp
js/src/vm/SelfHosting.cpp
js/src/vm/SharedArrayObject.cpp
js/src/vm/SharedTypedArrayObject.cpp
js/src/vm/TypedArrayObject.cpp
--- a/js/src/asmjs/AsmJSSignalHandlers.cpp
+++ b/js/src/asmjs/AsmJSSignalHandlers.cpp
@@ -21,18 +21,16 @@
 #include "mozilla/DebugOnly.h"
 #include "mozilla/PodOperations.h"
 
 #include "asmjs/AsmJSModule.h"
 #include "jit/AtomicOperations.h"
 #include "jit/Disassembler.h"
 #include "vm/Runtime.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 using namespace js;
 using namespace js::jit;
 
 using JS::GenericNaN;
 using mozilla::DebugOnly;
 using mozilla::PodArrayZero;
 
 #if defined(ANDROID)
--- a/js/src/asmjs/AsmJSValidate.cpp
+++ b/js/src/asmjs/AsmJSValidate.cpp
@@ -46,17 +46,16 @@
 #include "vm/HelperThreads.h"
 #include "vm/Interpreter.h"
 #include "vm/Time.h"
 
 #include "jsobjinlines.h"
 
 #include "frontend/ParseNode-inl.h"
 #include "frontend/Parser-inl.h"
-#include "jit/AtomicOperations-inl.h"
 #include "jit/MacroAssembler-inl.h"
 
 using namespace js;
 using namespace js::frontend;
 using namespace js::jit;
 using namespace js::wasm;
 
 using mozilla::AddToHash;
--- a/js/src/builtin/AtomicsObject.cpp
+++ b/js/src/builtin/AtomicsObject.cpp
@@ -58,17 +58,16 @@
 #include "jit/InlinableNatives.h"
 #include "js/Class.h"
 #include "vm/GlobalObject.h"
 #include "vm/SharedTypedArrayObject.h"
 #include "vm/Time.h"
 #include "vm/TypedArrayObject.h"
 
 #include "jsobjinlines.h"
-#include "jit/AtomicOperations-inl.h"
 
 using namespace js;
 
 const Class AtomicsObject::class_ = {
     "Atomics",
     JSCLASS_HAS_CACHED_PROTO(JSProto_Atomics)
 };
 
deleted file mode 100644
--- a/js/src/jit/AtomicOperations-inl.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef jit_AtomicOperations_inl_h
-#define jit_AtomicOperations_inl_h
-
-#if defined(JS_CODEGEN_ARM)
-# include "jit/arm/AtomicOperations-arm.h"
-#elif defined(JS_CODEGEN_ARM64)
-# include "jit/arm64/AtomicOperations-arm64.h"
-#elif defined(JS_CODEGEN_MIPS32)
-# include "jit/mips-shared/AtomicOperations-mips-shared.h"
-#elif defined(JS_CODEGEN_NONE)
-# include "jit/none/AtomicOperations-none.h"
-#elif defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)
-# include "jit/x86-shared/AtomicOperations-x86-shared.h"
-#else
-# error "Atomic operations must be defined for this platform"
-#endif
-
-inline bool
-js::jit::AtomicOperations::isLockfree(int32_t size)
-{
-    // Keep this in sync with visitAtomicIsLockFree() in jit/CodeGenerator.cpp.
-
-    switch (size) {
-      case 1:
-      case 2:
-      case 4:
-        return true;
-      case 8:
-        return AtomicOperations::isLockfree8();
-      default:
-        return false;
-    }
-}
-
-#endif // jit_AtomicOperations_inl_h
--- a/js/src/jit/AtomicOperations.h
+++ b/js/src/jit/AtomicOperations.h
@@ -2,16 +2,18 @@
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_AtomicOperations_h
 #define jit_AtomicOperations_h
 
+#include "mozilla/Types.h"
+
 #include "vm/SharedMem.h"
 
 namespace js {
 namespace jit {
 
 class RegionLock;
 
 /*
@@ -50,19 +52,16 @@ class RegionLock;
  * and means such a function's operation must have "sequentially
  * consistent" memory ordering.  See mfbt/Atomics.h for an explanation
  * of this memory ordering.
  *
  * Note that a "SafeWhenRacy" access does not provide the atomicity of
  * a "relaxed atomic" access: it can read or write garbage if there's
  * a race.
  *
- * To make use of the functions you generally have to include
- * AtomicOperations-inl.h.
- *
  *
  * Implementation notes.
  *
  * It's not a requirement that these functions be inlined; performance
  * is not a great concern.  On some platforms these functions may call
  * out to code that's generated at run time.
  *
  * In principle these functions will not be written in C++, thus
@@ -270,12 +269,43 @@ class RegionLock
     template<size_t nbytes>
     void release(void* addr);
 
   private:
     /* For now, a simple spinlock that covers the entire buffer. */
     uint32_t spinlock;
 };
 
+inline bool
+AtomicOperations::isLockfree(int32_t size)
+{
+    // Keep this in sync with visitAtomicIsLockFree() in jit/CodeGenerator.cpp.
+
+    switch (size) {
+      case 1:
+      case 2:
+      case 4:
+        return true;
+      case 8:
+        return AtomicOperations::isLockfree8();
+      default:
+        return false;
+    }
+}
+
 } // namespace jit
 } // namespace js
 
+#if defined(JS_CODEGEN_ARM)
+# include "jit/arm/AtomicOperations-arm.h"
+#elif defined(JS_CODEGEN_ARM64)
+# include "jit/arm64/AtomicOperations-arm64.h"
+#elif defined(JS_CODEGEN_MIPS32)
+# include "jit/mips-shared/AtomicOperations-mips-shared.h"
+#elif defined(JS_CODEGEN_NONE)
+# include "jit/none/AtomicOperations-none.h"
+#elif defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)
+# include "jit/x86-shared/AtomicOperations-x86-shared.h"
+#else
+# error "Atomic operations must be defined for this platform"
+#endif
+
 #endif // jit_AtomicOperations_h
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -28,17 +28,16 @@
 #include "js/Conversions.h"
 #include "js/TraceableVector.h"
 #include "vm/Opcodes.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsboolinlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
 #include "jit/JitFrames-inl.h"
 #include "jit/MacroAssembler-inl.h"
 #include "jit/shared/Lowering-shared-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/ScopeObject-inl.h"
 #include "vm/StringObject-inl.h"
 #include "vm/UnboxedObject-inl.h"
 
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -36,17 +36,16 @@
 #include "jit/RangeAnalysis.h"
 #include "jit/SharedICHelpers.h"
 #include "vm/MatchPairs.h"
 #include "vm/RegExpStatics.h"
 #include "vm/TraceLogging.h"
 
 #include "jsboolinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
 #include "jit/MacroAssembler-inl.h"
 #include "jit/shared/CodeGenerator-shared-inl.h"
 #include "jit/shared/Lowering-shared-inl.h"
 #include "vm/Interpreter-inl.h"
 
 using namespace js;
 using namespace js::jit;
 
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -23,18 +23,16 @@
 #include "jit/MIRGraph.h"
 #include "jit/RangeAnalysis.h"
 #include "js/Conversions.h"
 
 #include "jsatominlines.h"
 #include "jsobjinlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 using namespace js;
 using namespace js::jit;
 
 using JS::ToInt32;
 
 using mozilla::NumbersAreIdentical;
 using mozilla::IsFloat32Representable;
 using mozilla::IsNaN;
--- a/js/src/jit/RangeAnalysis.cpp
+++ b/js/src/jit/RangeAnalysis.cpp
@@ -14,18 +14,16 @@
 #include "jit/MIR.h"
 #include "jit/MIRGenerator.h"
 #include "jit/MIRGraph.h"
 #include "js/Conversions.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsopcodeinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 using namespace js;
 using namespace js::jit;
 
 using mozilla::Abs;
 using mozilla::CountLeadingZeroes32;
 using mozilla::NumberEqualsInt32;
 using mozilla::ExponentComponent;
 using mozilla::FloorLog2;
--- a/js/src/jit/arm/Assembler-arm.cpp
+++ b/js/src/jit/arm/Assembler-arm.cpp
@@ -15,16 +15,17 @@
 #endif
 #include "jsutil.h"
 
 #include "gc/Marking.h"
 #include "jit/arm/disasm/Disasm-arm.h"
 #include "jit/arm/MacroAssembler-arm.h"
 #include "jit/ExecutableAllocator.h"
 #include "jit/JitCompartment.h"
+#include "jit/MacroAssembler.h"
 
 using namespace js;
 using namespace js::jit;
 
 using mozilla::CountLeadingZeroes32;
 
 void dbg_break() {}
 
--- a/js/src/jit/arm/AtomicOperations-arm.h
+++ b/js/src/jit/arm/AtomicOperations-arm.h
@@ -5,17 +5,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* For documentation, see jit/AtomicOperations.h */
 
 #ifndef jit_arm_AtomicOperations_arm_h
 #define jit_arm_AtomicOperations_arm_h
 
 #include "jit/arm/Architecture-arm.h"
-#include "jit/AtomicOperations.h"
 
 #if defined(__clang__) || defined(__GNUC__)
 
 // The default implementation tactic for gcc/clang is to use the newer
 // __atomic intrinsics added for use in C++11 <atomic>.  Where that
 // isn't available, we use GCC's older __sync functions instead.
 //
 // ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS is kept as a backward
--- a/js/src/jit/arm/disasm/Constants-arm.h
+++ b/js/src/jit/arm/disasm/Constants-arm.h
@@ -5,16 +5,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef jit_arm_disasm_Constants_arm_h
 #define jit_arm_disasm_Constants_arm_h
 
 #ifdef JS_DISASM_ARM
 
+#include "mozilla/Assertions.h"
+#include "mozilla/Types.h"
+
+#include <string.h>
+
 namespace js {
 namespace jit {
 namespace disasm {
 
 // Constant pool marker.
 // Use UDF, the permanently undefined instruction.
 const int kConstantPoolMarkerMask = 0xfff000f0;
 const int kConstantPoolMarker = 0xe7f000f0;
--- a/js/src/jit/arm/disasm/Disasm-arm.h
+++ b/js/src/jit/arm/disasm/Disasm-arm.h
@@ -5,16 +5,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef jit_arm_disasm_Disasm_arm_h
 #define jit_arm_disasm_Disasm_arm_h
 
 #ifdef JS_DISASM_ARM
 
+#include "mozilla/Assertions.h"
+#include "mozilla/Types.h"
+
+#include <stdio.h>
+
 namespace js {
 namespace jit {
 namespace disasm {
 
 typedef unsigned char byte;
 
 // A reasonable (ie, safe) buffer size for the disassembly of a single instruction.
 const int ReasonableBufferSize = 256;
--- a/js/src/jit/arm64/AtomicOperations-arm64.h
+++ b/js/src/jit/arm64/AtomicOperations-arm64.h
@@ -4,18 +4,20 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* For documentation, see jit/AtomicOperations.h */
 
 #ifndef jit_arm64_AtomicOperations_arm64_h
 #define jit_arm64_AtomicOperations_arm64_h
 
+#include "mozilla/Assertions.h"
+#include "mozilla/Types.h"
+
 #include "jit/arm64/Architecture-arm64.h"
-#include "jit/AtomicOperations.h"
 
 inline bool
 js::jit::AtomicOperations::isLockfree8()
 {
     MOZ_ASSERT(__atomic_always_lock_free(sizeof(int8_t), 0));
     MOZ_ASSERT(__atomic_always_lock_free(sizeof(int16_t), 0));
     MOZ_ASSERT(__atomic_always_lock_free(sizeof(int32_t), 0));
     return true;
--- a/js/src/jit/mips-shared/AtomicOperations-mips-shared.h
+++ b/js/src/jit/mips-shared/AtomicOperations-mips-shared.h
@@ -4,17 +4,18 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* For documentation, see jit/AtomicOperations.h */
 
 #ifndef jit_mips_shared_AtomicOperations_mips_shared_h
 #define jit_mips_shared_AtomicOperations_mips_shared_h
 
-#include "jit/AtomicOperations.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Types.h"
 
 #if defined(__clang__) || defined(__GNUC__)
 
 // The default implementation tactic for gcc/clang is to use the newer
 // __atomic intrinsics added for use in C++11 <atomic>.  Where that
 // isn't available, we use GCC's older __sync functions instead.
 //
 // ATOMICS_IMPLEMENTED_WITH_SYNC_INTRINSICS is kept as a backward
--- a/js/src/jit/none/AtomicOperations-none.h
+++ b/js/src/jit/none/AtomicOperations-none.h
@@ -4,17 +4,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* For documentation, see jit/AtomicOperations.h */
 
 #ifndef jit_none_AtomicOperations_none_h
 #define jit_none_AtomicOperations_none_h
 
-#include "jit/AtomicOperations.h"
+#include "mozilla/Assertions.h"
 
 // A "none" build is never run (ref IRC discussion with h4writer) and
 // all functions here can therefore MOZ_CRASH, even if they are
 // referenced from other than jitted code.
 
 inline bool
 js::jit::AtomicOperations::isLockfree8()
 {
--- a/js/src/jit/x86-shared/AtomicOperations-x86-shared.h
+++ b/js/src/jit/x86-shared/AtomicOperations-x86-shared.h
@@ -4,17 +4,18 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* For overall documentation, see jit/AtomicOperations.h */
 
 #ifndef jit_shared_AtomicOperations_x86_shared_h
 #define jit_shared_AtomicOperations_x86_shared_h
 
-#include "jit/AtomicOperations.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Types.h"
 
 // Lock-freedom on x86 and x64:
 //
 // On x86 and x64 there are atomic instructions for 8-byte accesses:
 //
 // Load and stores:
 // - Loads and stores are single-copy atomic for up to 8 bytes
 //   starting with the Pentium; the store requires a post-fence for
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -86,18 +86,16 @@
 #include "vm/TypedArrayCommon.h"
 #include "vm/WrapperObject.h"
 #include "vm/Xdr.h"
 
 #include "jsatominlines.h"
 #include "jsfuninlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 #include "vm/Interpreter-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/String-inl.h"
 
 using namespace js;
 using namespace js::gc;
 
 using mozilla::Maybe;
--- a/js/src/jsarray.cpp
+++ b/js/src/jsarray.cpp
@@ -33,18 +33,16 @@
 #include "vm/ArgumentsObject.h"
 #include "vm/Interpreter.h"
 #include "vm/Shape.h"
 #include "vm/StringBuffer.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsatominlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 #include "vm/ArgumentsObject-inl.h"
 #include "vm/ArrayObject-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/Runtime-inl.h"
 #include "vm/UnboxedObject-inl.h"
 
 using namespace js;
--- a/js/src/jsiter.cpp
+++ b/js/src/jsiter.cpp
@@ -30,18 +30,16 @@
 #include "vm/GlobalObject.h"
 #include "vm/Interpreter.h"
 #include "vm/Shape.h"
 #include "vm/StopIterationObject.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsscriptinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 #include "vm/NativeObject-inl.h"
 #include "vm/Stack-inl.h"
 #include "vm/String-inl.h"
 
 using namespace js;
 using namespace js::gc;
 using JS::ForOfIterator;
 
--- a/js/src/jsobj.cpp
+++ b/js/src/jsobj.cpp
@@ -54,18 +54,16 @@
 #include "vm/Shape.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsatominlines.h"
 #include "jsboolinlines.h"
 #include "jscntxtinlines.h"
 #include "jscompartmentinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 #include "vm/ArrayObject-inl.h"
 #include "vm/BooleanObject-inl.h"
 #include "vm/Interpreter-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/NumberObject-inl.h"
 #include "vm/Runtime-inl.h"
 #include "vm/Shape-inl.h"
 #include "vm/StringObject-inl.h"
--- a/js/src/jsobjinlines.h
+++ b/js/src/jsobjinlines.h
@@ -24,17 +24,16 @@
 #include "vm/ScopeObject.h"
 #include "vm/StringObject.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsatominlines.h"
 #include "jscompartmentinlines.h"
 #include "jsgcinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
 #include "vm/TypeInference-inl.h"
 
 namespace js {
 
 // This is needed here for ensureShape() below.
 inline bool
 MaybeConvertUnboxedObjectToNative(ExclusiveContext* cx, JSObject* obj)
 {
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -43,17 +43,16 @@
 #include "vm/Shape.h"
 #include "vm/TraceLogging.h"
 
 #include "jsatominlines.h"
 #include "jsboolinlines.h"
 #include "jsfuninlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
 #include "jit/JitFrames-inl.h"
 #include "vm/Debugger-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/Probes-inl.h"
 #include "vm/ScopeObject-inl.h"
 #include "vm/Stack-inl.h"
 
 #if defined(XP_WIN)
--- a/js/src/vm/NativeObject.cpp
+++ b/js/src/vm/NativeObject.cpp
@@ -14,17 +14,16 @@
 #include "gc/Marking.h"
 #include "js/Value.h"
 #include "vm/Debugger.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsobjinlines.h"
 
 #include "gc/Nursery-inl.h"
-#include "jit/AtomicOperations-inl.h"
 #include "vm/ArrayObject-inl.h"
 #include "vm/ScopeObject-inl.h"
 #include "vm/Shape-inl.h"
 
 using namespace js;
 
 using JS::GenericNaN;
 using mozilla::ArrayLength;
--- a/js/src/vm/SelfHosting.cpp
+++ b/js/src/vm/SelfHosting.cpp
@@ -35,18 +35,16 @@
 #include "vm/GeneratorObject.h"
 #include "vm/Interpreter.h"
 #include "vm/String.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsfuninlines.h"
 #include "jsscriptinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 #include "vm/BooleanObject-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/NumberObject-inl.h"
 #include "vm/StringObject-inl.h"
 
 using namespace js;
 using namespace js::selfhosted;
 
--- a/js/src/vm/SharedArrayObject.cpp
+++ b/js/src/vm/SharedArrayObject.cpp
@@ -23,18 +23,16 @@
 #endif
 
 #include "asmjs/AsmJSValidate.h"
 #include "vm/SharedMem.h"
 #include "vm/TypedArrayCommon.h"
 
 #include "jsobjinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
-
 using namespace js;
 
 static inline void*
 MapMemory(size_t length, bool commit)
 {
 #ifdef XP_WIN
     int prot = (commit ? MEM_COMMIT : MEM_RESERVE);
     int flags = (commit ? PAGE_READWRITE : PAGE_NOACCESS);
--- a/js/src/vm/SharedTypedArrayObject.cpp
+++ b/js/src/vm/SharedTypedArrayObject.cpp
@@ -40,17 +40,16 @@
 #include "vm/SharedArrayObject.h"
 #include "vm/SharedMem.h"
 #include "vm/TypedArrayCommon.h"
 #include "vm/WrapperObject.h"
 
 #include "jsatominlines.h"
 #include "jsobjinlines.h"
 
-#include "jit/AtomicOperations-inl.h"
 #include "vm/Shape-inl.h"
 
 using namespace js;
 using namespace js::gc;
 
 using mozilla::IsNaN;
 using mozilla::NegativeInfinity;
 using mozilla::PodCopy;
--- a/js/src/vm/TypedArrayObject.cpp
+++ b/js/src/vm/TypedArrayObject.cpp
@@ -35,17 +35,16 @@
 #include "vm/ArrayBufferObject.h"
 #include "vm/GlobalObject.h"
 #include "vm/Interpreter.h"
 #include "vm/TypedArrayCommon.h"
 #include "vm/WrapperObject.h"
 
 #include "jsatominlines.h"
 
-#include "jit/AtomicOperations-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/Shape-inl.h"
 
 using namespace js;
 using namespace js::gc;
 
 using mozilla::IsNaN;
 using mozilla::NegativeInfinity;