js/src/jit/CompileWrappers.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "jit/CompileWrappers.h"
   8
   9 #include "gc/Heap.h"
  10 #include "gc/Zone.h"
  11 #include "jit/Ion.h"
  12 #include "jit/JitRuntime.h"
  13 #include "vm/Realm.h"
  14
  15 using namespace js;
  16 using namespace js::jit;
  17
  18 JSRuntime* CompileRuntime::runtime() {
  19   return reinterpret_cast<JSRuntime*>(this);
  20 }
  21
  22 /* static */
  23 CompileRuntime* CompileRuntime::get(JSRuntime* rt) {
  24   return reinterpret_cast<CompileRuntime*>(rt);
  25 }
  26
  27 #ifdef JS_GC_ZEAL
  28 const uint32_t* CompileRuntime::addressOfGCZealModeBits() {
  29   return runtime()->gc.addressOfZealModeBits();
  30 }
  31 #endif
  32
  33 const JitRuntime* CompileRuntime::jitRuntime() {
  34   return runtime()->jitRuntime();
  35 }
  36
  37 GeckoProfilerRuntime& CompileRuntime::geckoProfiler() {
  38   return runtime()->geckoProfiler();
  39 }
  40
  41 bool CompileRuntime::hadOutOfMemory() { return runtime()->hadOutOfMemory; }
  42
  43 bool CompileRuntime::profilingScripts() { return runtime()->profilingScripts; }
  44
  45 const JSAtomState& CompileRuntime::names() { return *runtime()->commonNames; }
  46
  47 const PropertyName* CompileRuntime::emptyString() {
  48   return runtime()->emptyString;
  49 }
  50
  51 const StaticStrings& CompileRuntime::staticStrings() {
  52   return *runtime()->staticStrings;
  53 }
  54
  55 const WellKnownSymbols& CompileRuntime::wellKnownSymbols() {
  56   return *runtime()->wellKnownSymbols;
  57 }
  58
  59 const JSClass* CompileRuntime::maybeWindowProxyClass() {
  60   return runtime()->maybeWindowProxyClass();
  61 }
  62
  63 const void* CompileRuntime::mainContextPtr() {
  64   return runtime()->mainContextFromAnyThread();
  65 }
  66
  67 const void* CompileRuntime::addressOfJitStackLimit() {
  68   return runtime()->mainContextFromAnyThread()->addressOfJitStackLimit();
  69 }
  70
  71 const void* CompileRuntime::addressOfInterruptBits() {
  72   return runtime()->mainContextFromAnyThread()->addressOfInterruptBits();
  73 }
  74
  75 const void* CompileRuntime::addressOfZone() {
  76   return runtime()->mainContextFromAnyThread()->addressOfZone();
  77 }
  78
  79 const void* CompileRuntime::addressOfMegamorphicCache() {
  80   return &runtime()->caches().megamorphicCache;
  81 }
  82
  83 const void* CompileRuntime::addressOfMegamorphicSetPropCache() {
  84   return runtime()->caches().megamorphicSetPropCache.get();
  85 }
  86
  87 const void* CompileRuntime::addressOfStringToAtomCache() {
  88   return &runtime()->caches().stringToAtomCache;
  89 }
  90
  91 const void* CompileRuntime::addressOfLastBufferedWholeCell() {
  92   return runtime()->gc.addressOfLastBufferedWholeCell();
  93 }
  94
  95 const DOMCallbacks* CompileRuntime::DOMcallbacks() {
  96   return runtime()->DOMcallbacks;
  97 }
  98
  99 bool CompileRuntime::runtimeMatches(JSRuntime* rt) { return rt == runtime(); }
 100
 101 Zone* CompileZone::zone() { return reinterpret_cast<Zone*>(this); }
 102
 103 /* static */
 104 CompileZone* CompileZone::get(Zone* zone) {
 105   return reinterpret_cast<CompileZone*>(zone);
 106 }
 107
 108 CompileRuntime* CompileZone::runtime() {
 109   return CompileRuntime::get(zone()->runtimeFromAnyThread());
 110 }
 111
 112 bool CompileZone::isAtomsZone() { return zone()->isAtomsZone(); }
 113
 114 #ifdef DEBUG
 115 const void* CompileRuntime::addressOfIonBailAfterCounter() {
 116   return runtime()->jitRuntime()->addressOfIonBailAfterCounter();
 117 }
 118 #endif
 119
 120 const uint32_t* CompileZone::addressOfNeedsIncrementalBarrier() {
 121   // Cast away relaxed atomic wrapper for JIT access to barrier state.
 122   const mozilla::Atomic<uint32_t, mozilla::Relaxed>* ptr =
 123       zone()->addressOfNeedsIncrementalBarrier();
 124   return reinterpret_cast<const uint32_t*>(ptr);
 125 }
 126
 127 uint32_t* CompileZone::addressOfTenuredAllocCount() {
 128   return zone()->addressOfTenuredAllocCount();
 129 }
 130
 131 gc::FreeSpan** CompileZone::addressOfFreeList(gc::AllocKind allocKind) {
 132   return zone()->arenas.addressOfFreeList(allocKind);
 133 }
 134
 135 bool CompileZone::allocNurseryObjects() {
 136   return zone()->allocNurseryObjects();
 137 }
 138
 139 bool CompileZone::allocNurseryStrings() {
 140   return zone()->allocNurseryStrings();
 141 }
 142
 143 bool CompileZone::allocNurseryBigInts() {
 144   return zone()->allocNurseryBigInts();
 145 }
 146
 147 void* CompileZone::addressOfNurseryPosition() {
 148   return zone()->runtimeFromAnyThread()->gc.addressOfNurseryPosition();
 149 }
 150
 151 void* CompileZone::addressOfNurseryAllocatedSites() {
 152   JSRuntime* rt = zone()->runtimeFromAnyThread();
 153   return rt->gc.nursery().addressOfNurseryAllocatedSites();
 154 }
 155
 156 bool CompileZone::canNurseryAllocateStrings() {
 157   return zone()->allocNurseryStrings();
 158 }
 159
 160 bool CompileZone::canNurseryAllocateBigInts() {
 161   return zone()->allocNurseryBigInts();
 162 }
 163
 164 gc::AllocSite* CompileZone::catchAllAllocSite(JS::TraceKind traceKind,
 165                                               gc::CatchAllAllocSite siteKind) {
 166   if (siteKind == gc::CatchAllAllocSite::Optimized) {
 167     return zone()->optimizedAllocSite();
 168   }
 169   return zone()->unknownAllocSite(traceKind);
 170 }
 171
 172 JS::Realm* CompileRealm::realm() { return reinterpret_cast<JS::Realm*>(this); }
 173
 174 /* static */
 175 CompileRealm* CompileRealm::get(JS::Realm* realm) {
 176   return reinterpret_cast<CompileRealm*>(realm);
 177 }
 178
 179 CompileZone* CompileRealm::zone() { return CompileZone::get(realm()->zone()); }
 180
 181 CompileRuntime* CompileRealm::runtime() {
 182   return CompileRuntime::get(realm()->runtimeFromAnyThread());
 183 }
 184
 185 const mozilla::non_crypto::XorShift128PlusRNG*
 186 CompileRealm::addressOfRandomNumberGenerator() {
 187   return realm()->addressOfRandomNumberGenerator();
 188 }
 189
 190 const JitZone* CompileZone::jitZone() { return zone()->jitZone(); }
 191
 192 const GlobalObject* CompileRealm::maybeGlobal() {
 193   // This uses unsafeUnbarrieredMaybeGlobal() so as not to trigger the read
 194   // barrier on the global from off thread.  This is safe because we
 195   // abort Ion compilation when we GC.
 196   return realm()->unsafeUnbarrieredMaybeGlobal();
 197 }
 198
 199 const uint32_t* CompileRealm::addressOfGlobalWriteBarriered() {
 200   return &realm()->globalWriteBarriered;
 201 }
 202
 203 bool CompileZone::hasRealmWithAllocMetadataBuilder() {
 204   return zone()->hasRealmWithAllocMetadataBuilder();
 205 }
 206
 207 JitCompileOptions::JitCompileOptions()
 208     : profilerSlowAssertionsEnabled_(false),
 209       offThreadCompilationAvailable_(false) {}
 210
 211 JitCompileOptions::JitCompileOptions(JSContext* cx) {
 212   profilerSlowAssertionsEnabled_ =
 213       cx->runtime()->geckoProfiler().enabled() &&
 214       cx->runtime()->geckoProfiler().slowAssertionsEnabled();
 215   offThreadCompilationAvailable_ = OffThreadCompilationAvailable(cx);
 216 #ifdef DEBUG
 217   ionBailAfterEnabled_ = cx->runtime()->jitRuntime()->ionBailAfterEnabled();
 218 #endif
 219 }