js/src/jit/CompileWrappers.h

   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 #ifndef jit_CompileWrappers_h
   8 #define jit_CompileWrappers_h
   9
  10 #include <stdint.h>
  11
  12 #include "gc/Pretenuring.h"
  13 #include "js/TypeDecls.h"
  14 #include "vm/Realm.h"
  15 #include "vm/RealmFuses.h"
  16
  17 struct JSAtomState;
  18
  19 namespace mozilla::non_crypto {
  20 class XorShift128PlusRNG;
  21 }
  22
  23 namespace JS {
  24 enum class TraceKind;
  25 }
  26
  27 namespace js {
  28
  29 class GeckoProfilerRuntime;
  30 class GlobalObject;
  31 struct JSDOMCallbacks;
  32 class PropertyName;
  33 class StaticStrings;
  34 struct WellKnownSymbols;
  35
  36 using DOMCallbacks = struct JSDOMCallbacks;
  37
  38 namespace gc {
  39
  40 enum class AllocKind : uint8_t;
  41
  42 class FreeSpan;
  43
  44 }  // namespace gc
  45
  46 namespace jit {
  47
  48 class JitRuntime;
  49
  50 // During Ion compilation we need access to various bits of the current
  51 // compartment, runtime and so forth. However, since compilation can run off
  52 // thread while the main thread is mutating the VM, this access needs
  53 // to be restricted. The classes below give the compiler an interface to access
  54 // all necessary information in a threadsafe fashion.
  55
  56 class CompileRuntime {
  57   JSRuntime* runtime();
  58
  59  public:
  60   static CompileRuntime* get(JSRuntime* rt);
  61
  62 #ifdef JS_GC_ZEAL
  63   const uint32_t* addressOfGCZealModeBits();
  64 #endif
  65
  66   const JitRuntime* jitRuntime();
  67
  68   // Compilation does not occur off thread when the Gecko Profiler is enabled.
  69   GeckoProfilerRuntime& geckoProfiler();
  70
  71   bool hadOutOfMemory();
  72   bool profilingScripts();
  73
  74   const JSAtomState& names();
  75   const PropertyName* emptyString();
  76   const StaticStrings& staticStrings();
  77   const WellKnownSymbols& wellKnownSymbols();
  78   const JSClass* maybeWindowProxyClass();
  79
  80   const void* mainContextPtr();
  81   const void* addressOfJitStackLimit();
  82   const void* addressOfInterruptBits();
  83   const void* addressOfZone();
  84   const void* addressOfMegamorphicCache();
  85   const void* addressOfMegamorphicSetPropCache();
  86   const void* addressOfStringToAtomCache();
  87   const void* addressOfLastBufferedWholeCell();
  88
  89   bool hasSeenObjectEmulateUndefinedFuseIntact();
  90   const void* addressOfHasSeenObjectEmulateUndefinedFuse();
  91
  92 #ifdef DEBUG
  93   const void* addressOfIonBailAfterCounter();
  94 #endif
  95
  96   // DOM callbacks must be threadsafe (and will hopefully be removed soon).
  97   const DOMCallbacks* DOMcallbacks();
  98
  99   bool runtimeMatches(JSRuntime* rt);
 100 };
 101
 102 class JitZone;
 103
 104 class CompileZone {
 105   friend class MacroAssembler;
 106   JS::Zone* zone();
 107
 108  public:
 109   static CompileZone* get(JS::Zone* zone);
 110
 111   const JitZone* jitZone();
 112
 113   CompileRuntime* runtime();
 114   bool isAtomsZone();
 115
 116   const uint32_t* addressOfNeedsIncrementalBarrier();
 117   uint32_t* addressOfTenuredAllocCount();
 118   gc::FreeSpan** addressOfFreeList(gc::AllocKind allocKind);
 119   bool allocNurseryObjects();
 120   bool allocNurseryStrings();
 121   bool allocNurseryBigInts();
 122   void* addressOfNurseryPosition();
 123
 124   void* addressOfNurseryAllocatedSites();
 125
 126   bool canNurseryAllocateStrings();
 127   bool canNurseryAllocateBigInts();
 128
 129   gc::AllocSite* catchAllAllocSite(JS::TraceKind traceKind,
 130                                    gc::CatchAllAllocSite siteKind);
 131
 132   bool hasRealmWithAllocMetadataBuilder();
 133 };
 134
 135 class CompileRealm {
 136   JS::Realm* realm();
 137
 138  public:
 139   static CompileRealm* get(JS::Realm* realm);
 140
 141   CompileZone* zone();
 142   CompileRuntime* runtime();
 143
 144   const void* realmPtr() { return realm(); }
 145
 146   RealmFuses& realmFuses() { return realm()->realmFuses; }
 147
 148   const mozilla::non_crypto::XorShift128PlusRNG*
 149   addressOfRandomNumberGenerator();
 150
 151   const GlobalObject* maybeGlobal();
 152   const uint32_t* addressOfGlobalWriteBarriered();
 153 };
 154
 155 class JitCompileOptions {
 156  public:
 157   JitCompileOptions();
 158   explicit JitCompileOptions(JSContext* cx);
 159
 160   bool profilerSlowAssertionsEnabled() const {
 161     return profilerSlowAssertionsEnabled_;
 162   }
 163
 164   bool offThreadCompilationAvailable() const {
 165     return offThreadCompilationAvailable_;
 166   }
 167
 168 #ifdef DEBUG
 169   bool ionBailAfterEnabled() const { return ionBailAfterEnabled_; }
 170 #endif
 171
 172  private:
 173   bool profilerSlowAssertionsEnabled_;
 174   bool offThreadCompilationAvailable_;
 175 #ifdef DEBUG
 176   bool ionBailAfterEnabled_ = false;
 177 #endif
 178 };
 179
 180 }  // namespace jit
 181 }  // namespace js
 182
 183 #endif  // jit_CompileWrappers_h