1 files changed, 310 insertions, 0 deletions
diff --git a/js/src/jit/CompileWrappers.cpp b/js/src/jit/CompileWrappers.cpp
new file mode 100644
index 000000000..9402efcbd
--- /dev/null
+++ b/js/src/jit/CompileWrappers.cpp
@@ -0,0 +1,310 @@
+/* -*- 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/. */
+
+#include "jit/Ion.h"
+
+#include "jscompartmentinlines.h"
+
+using namespace js;
+using namespace js::jit;
+
+JSRuntime*
+CompileRuntime::runtime()
+{
+    return reinterpret_cast<JSRuntime*>(this);
+}
+
+/* static */ CompileRuntime*
+CompileRuntime::get(JSRuntime* rt)
+{
+    return reinterpret_cast<CompileRuntime*>(rt);
+}
+
+bool
+CompileRuntime::onMainThread()
+{
+    return js::CurrentThreadCanAccessRuntime(runtime());
+}
+
+js::PerThreadData*
+CompileRuntime::mainThread()
+{
+    MOZ_ASSERT(onMainThread());
+    return &runtime()->mainThread;
+}
+
+const void*
+CompileRuntime::addressOfJitTop()
+{
+    return &runtime()->jitTop;
+}
+
+const void*
+CompileRuntime::addressOfJitActivation()
+{
+    return &runtime()->jitActivation;
+}
+
+const void*
+CompileRuntime::addressOfProfilingActivation()
+{
+    return (const void*) &runtime()->profilingActivation_;
+}
+
+const void*
+CompileRuntime::addressOfJitStackLimit()
+{
+    return runtime()->addressOfJitStackLimit();
+}
+
+#ifdef DEBUG
+const void*
+CompileRuntime::addressOfIonBailAfter()
+{
+    return runtime()->addressOfIonBailAfter();
+}
+#endif
+
+const void*
+CompileRuntime::addressOfActivation()
+{
+    return runtime()->addressOfActivation();
+}
+
+#ifdef JS_GC_ZEAL
+const void*
+CompileRuntime::addressOfGCZealModeBits()
+{
+    return runtime()->gc.addressOfZealModeBits();
+}
+#endif
+
+const void*
+CompileRuntime::addressOfInterruptUint32()
+{
+    return runtime()->addressOfInterruptUint32();
+}
+
+const void*
+CompileRuntime::getJSContext()
+{
+    return runtime()->unsafeContextFromAnyThread();
+}
+
+const JitRuntime*
+CompileRuntime::jitRuntime()
+{
+    return runtime()->jitRuntime();
+}
+
+SPSProfiler&
+CompileRuntime::spsProfiler()
+{
+    return runtime()->spsProfiler;
+}
+
+bool
+CompileRuntime::jitSupportsFloatingPoint()
+{
+    return runtime()->jitSupportsFloatingPoint;
+}
+
+bool
+CompileRuntime::hadOutOfMemory()
+{
+    return runtime()->hadOutOfMemory;
+}
+
+bool
+CompileRuntime::profilingScripts()
+{
+    return runtime()->profilingScripts;
+}
+
+const JSAtomState&
+CompileRuntime::names()
+{
+    return *runtime()->commonNames;
+}
+
+const PropertyName*
+CompileRuntime::emptyString()
+{
+    return runtime()->emptyString;
+}
+
+const StaticStrings&
+CompileRuntime::staticStrings()
+{
+    return *runtime()->staticStrings;
+}
+
+const Value&
+CompileRuntime::NaNValue()
+{
+    return runtime()->NaNValue;
+}
+
+const Value&
+CompileRuntime::positiveInfinityValue()
+{
+    return runtime()->positiveInfinityValue;
+}
+
+const WellKnownSymbols&
+CompileRuntime::wellKnownSymbols()
+{
+    MOZ_ASSERT(onMainThread());
+    return *runtime()->wellKnownSymbols;
+}
+
+#ifdef DEBUG
+bool
+CompileRuntime::isInsideNursery(gc::Cell* cell)
+{
+    return UninlinedIsInsideNursery(cell);
+}
+#endif
+
+const DOMCallbacks*
+CompileRuntime::DOMcallbacks()
+{
+    return runtime()->DOMcallbacks;
+}
+
+const Nursery&
+CompileRuntime::gcNursery()
+{
+    return runtime()->gc.nursery;
+}
+
+void
+CompileRuntime::setMinorGCShouldCancelIonCompilations()
+{
+    MOZ_ASSERT(onMainThread());
+    runtime()->gc.storeBuffer.setShouldCancelIonCompilations();
+}
+
+bool
+CompileRuntime::runtimeMatches(JSRuntime* rt)
+{
+    return rt == runtime();
+}
+
+Zone*
+CompileZone::zone()
+{
+    return reinterpret_cast<Zone*>(this);
+}
+
+/* static */ CompileZone*
+CompileZone::get(Zone* zone)
+{
+    return reinterpret_cast<CompileZone*>(zone);
+}
+
+const void*
+CompileZone::addressOfNeedsIncrementalBarrier()
+{
+    return zone()->addressOfNeedsIncrementalBarrier();
+}
+
+const void*
+CompileZone::addressOfFreeList(gc::AllocKind allocKind)
+{
+    return zone()->arenas.addressOfFreeList(allocKind);
+}
+
+JSCompartment*
+CompileCompartment::compartment()
+{
+    return reinterpret_cast<JSCompartment*>(this);
+}
+
+/* static */ CompileCompartment*
+CompileCompartment::get(JSCompartment* comp)
+{
+    return reinterpret_cast<CompileCompartment*>(comp);
+}
+
+CompileZone*
+CompileCompartment::zone()
+{
+    return CompileZone::get(compartment()->zone());
+}
+
+CompileRuntime*
+CompileCompartment::runtime()
+{
+    return CompileRuntime::get(compartment()->runtimeFromAnyThread());
+}
+
+const void*
+CompileCompartment::addressOfEnumerators()
+{
+    return &compartment()->enumerators;
+}
+
+const void*
+CompileCompartment::addressOfLastCachedNativeIterator()
+{
+    return &compartment()->lastCachedNativeIterator;
+}
+
+const void*
+CompileCompartment::addressOfRandomNumberGenerator()
+{
+    return compartment()->randomNumberGenerator.ptr();
+}
+
+const JitCompartment*
+CompileCompartment::jitCompartment()
+{
+    return compartment()->jitCompartment();
+}
+
+const GlobalObject*
+CompileCompartment::maybeGlobal()
+{
+    // This uses unsafeUnbarrieredMaybeGlobal() so as not to trigger the read
+    // barrier on the global from off the main thread.  This is safe because we
+    // abort Ion compilation when we GC.
+    return compartment()->unsafeUnbarrieredMaybeGlobal();
+}
+
+bool
+CompileCompartment::hasAllocationMetadataBuilder()
+{
+    return compartment()->hasAllocationMetadataBuilder();
+}
+
+// Note: This function is thread-safe because setSingletonAsValue sets a boolean
+// variable to false, and this boolean variable has no way to be resetted to
+// true. So even if there is a concurrent write, this concurrent write will
+// always have the same value.  If there is a concurrent read, then we will
+// clone a singleton instead of using the value which is baked in the JSScript,
+// and this would be an unfortunate allocation, but this will not change the
+// semantics of the JavaScript code which is executed.
+void
+CompileCompartment::setSingletonsAsValues()
+{
+    compartment()->behaviors().setSingletonsAsValues();
+}
+
+JitCompileOptions::JitCompileOptions()
+  : cloneSingletons_(false),
+    spsSlowAssertionsEnabled_(false),
+    offThreadCompilationAvailable_(false)
+{
+}
+
+JitCompileOptions::JitCompileOptions(JSContext* cx)
+{
+    cloneSingletons_ = cx->compartment()->creationOptions().cloneSingletons();
+    spsSlowAssertionsEnabled_ = cx->runtime()->spsProfiler.enabled() &&
+                                cx->runtime()->spsProfiler.slowAssertionsEnabled();
+    offThreadCompilationAvailable_ = OffThreadCompilationAvailable(cx);
+}