diff -r 000000000000 -r 6474c204b198 js/src/jit/CompileWrappers.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/js/src/jit/CompileWrappers.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,152 @@
+/* -*- 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_CompileWrappers_h
+#define jit_CompileWrappers_h
+
+#ifdef JS_ION
+
+#include "jscntxt.h"
+
+namespace js {
+namespace jit {
+
+class JitRuntime;
+
+// During Ion compilation we need access to various bits of the current
+// compartment, runtime and so forth. However, since compilation can run off
+// thread while the main thread is actively mutating the VM, this access needs
+// to be restricted. The classes below give the compiler an interface to access
+// all necessary information in a threadsafe fashion.
+
+class CompileRuntime
+{
+    JSRuntime *runtime();
+
+  public:
+    static CompileRuntime *get(JSRuntime *rt);
+
+    bool onMainThread();
+
+    js::PerThreadData *mainThread();
+
+    // &mainThread.ionTop
+    const void *addressOfIonTop();
+
+    // rt->mainThread.jitStackLimit;
+    const void *addressOfJitStackLimit();
+
+    // &mainThread.ionJSContext
+    const void *addressOfJSContext();
+
+    // &mainThread.activation_
+    const void *addressOfActivation();
+
+    // &GetIonContext()->runtime->nativeIterCache.last
+    const void *addressOfLastCachedNativeIterator();
+
+#ifdef JS_GC_ZEAL
+    const void *addressOfGCZeal();
+#endif
+
+    const void *addressOfInterrupt();
+
+#ifdef JS_THREADSAFE
+    const void *addressOfInterruptPar();
+#endif
+
+    const void *addressOfThreadPool();
+
+    const JitRuntime *jitRuntime();
+
+    // Compilation does not occur off thread when the SPS profiler is enabled.
+    SPSProfiler &spsProfiler();
+
+    bool signalHandlersInstalled();
+    bool jitSupportsFloatingPoint();
+    bool hadOutOfMemory();
+
+    const JSAtomState &names();
+    const StaticStrings &staticStrings();
+    const Value &NaNValue();
+    const Value &positiveInfinityValue();
+
+#ifdef DEBUG
+    bool isInsideNursery(gc::Cell *cell);
+#endif
+
+    // DOM callbacks must be threadsafe (and will hopefully be removed soon).
+    const DOMCallbacks *DOMcallbacks();
+
+    const MathCache *maybeGetMathCache();
+
+#ifdef JSGC_GENERATIONAL
+    const Nursery &gcNursery();
+#endif
+};
+
+class CompileZone
+{
+    Zone *zone();
+
+  public:
+    static CompileZone *get(Zone *zone);
+
+    const void *addressOfNeedsBarrier();
+
+    // allocator.arenas.getFreeList(allocKind)
+    const void *addressOfFreeListFirst(gc::AllocKind allocKind);
+    const void *addressOfFreeListLast(gc::AllocKind allocKind);
+};
+
+class CompileCompartment
+{
+    JSCompartment *compartment();
+
+  public:
+    static CompileCompartment *get(JSCompartment *comp);
+
+    CompileZone *zone();
+    CompileRuntime *runtime();
+
+    const void *addressOfEnumerators();
+
+    const CallsiteCloneTable &callsiteClones();
+
+    const JitCompartment *jitCompartment();
+
+    bool hasObjectMetadataCallback();
+
+    // Mirror CompartmentOptions.
+    void setSingletonsAsValues();
+};
+
+class JitCompileOptions
+{
+  public:
+    JitCompileOptions();
+    JitCompileOptions(JSContext *cx);
+
+    bool cloneSingletons() const {
+        return cloneSingletons_;
+    }
+
+    bool spsSlowAssertionsEnabled() const {
+        return spsSlowAssertionsEnabled_;
+    }
+
+  private:
+    bool cloneSingletons_;
+    bool spsSlowAssertionsEnabled_;
+};
+
+
+} // namespace jit
+} // namespace js
+
+#endif // JS_ION
+
+#endif // jit_CompileWrappers_h