author Jan de Mooij <jdemooij@mozilla.com>
Wed, 02 Dec 2015 13:56:00 +0100
changeset 309394 c511942454b6b48093d50e0f90085dd6dd638006
parent 295663 f3b279e0309573e39f44a8285fad5e7b6d6fe002
child 319587 e2fa804302c9a34576754dd73cab80b7c718701d
permissions -rw-r--r--
Bug 322529 part 3 - Fix LRandom JIT code to use the new algorithm. r=arai,jwalden

/* -*- 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

#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();

    static CompileRuntime* get(JSRuntime* rt);

    bool onMainThread();

    js::PerThreadData* mainThread();

    // &runtime()->jitTop
    const void* addressOfJitTop();

    // &runtime()->jitActivation
    const void* addressOfJitActivation();

    // &runtime()->profilingActivation
    const void* addressOfProfilingActivation();

    // rt->runtime()->jitStackLimit;
    const void* addressOfJitStackLimit();

    // &runtime()->jitJSContext
    const void* addressOfJSContext();

    // &runtime()->activation_
    const void* addressOfActivation();

    // &GetJitContext()->runtime->nativeIterCache.last
    const void* addressOfLastCachedNativeIterator();

#ifdef JS_GC_ZEAL
    const void* addressOfGCZeal();

    const void* addressOfInterruptUint32();

    const JitRuntime* jitRuntime();

    // Compilation does not occur off thread when the SPS profiler is enabled.
    SPSProfiler& spsProfiler();

    bool canUseSignalHandlers();
    bool jitSupportsFloatingPoint();
    bool hadOutOfMemory();
    bool profilingScripts();

    const JSAtomState& names();
    const PropertyName* emptyString();
    const StaticStrings& staticStrings();
    const Value& NaNValue();
    const Value& positiveInfinityValue();
    const WellKnownSymbols& wellKnownSymbols();

#ifdef DEBUG
    bool isInsideNursery(gc::Cell* cell);

    // DOM callbacks must be threadsafe (and will hopefully be removed soon).
    const DOMCallbacks* DOMcallbacks();

    const MathCache* maybeGetMathCache();

    const Nursery& gcNursery();
    void setMinorGCShouldCancelIonCompilations();

class CompileZone
    Zone* zone();

    static CompileZone* get(Zone* zone);

    const void* addressOfNeedsIncrementalBarrier();

    // arenas.getFreeList(allocKind)
    const void* addressOfFreeListFirst(gc::AllocKind allocKind);
    const void* addressOfFreeListLast(gc::AllocKind allocKind);

class JitCompartment;

class CompileCompartment
    JSCompartment* compartment();

    static CompileCompartment* get(JSCompartment* comp);

    CompileZone* zone();
    CompileRuntime* runtime();

    const void* addressOfEnumerators();
    const void* addressOfRandomNumberGenerator();

    const JitCompartment* jitCompartment();

    bool hasObjectMetadataCallback();

    // Mirror CompartmentOptions.
    void setSingletonsAsValues();

class JitCompileOptions
    explicit JitCompileOptions(JSContext* cx);

    bool cloneSingletons() const {
        return cloneSingletons_;

    bool spsSlowAssertionsEnabled() const {
        return spsSlowAssertionsEnabled_;

    bool offThreadCompilationAvailable() const {
        return offThreadCompilationAvailable_;

    bool cloneSingletons_;
    bool spsSlowAssertionsEnabled_;
    bool offThreadCompilationAvailable_;

} // namespace jit
} // namespace js

#endif // jit_CompileWrappers_h