mozjs_sys 0.67.1

System crate for the Mozilla SpiderMonkey JavaScript engine.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * 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 "vm/JSContext.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 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);

#ifdef JS_GC_ZEAL
  const uint32_t* addressOfGCZealModeBits();
#endif

  const JitRuntime* jitRuntime();

  // Compilation does not occur off thread when the Gecko Profiler is enabled.
  GeckoProfilerRuntime& geckoProfiler();

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

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

  const void* mainContextPtr();
  uint32_t* addressOfTenuredAllocCount();
  const void* addressOfJitStackLimit();
  const void* addressOfInterruptBits();
  const void* addressOfZone();

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

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

  bool runtimeMatches(JSRuntime* rt);
};

class CompileZone {
  Zone* zone();

 public:
  static CompileZone* get(Zone* zone);

  CompileRuntime* runtime();
  bool isAtomsZone();

#ifdef DEBUG
  const void* addressOfIonBailAfter();
#endif

  const uint32_t* addressOfNeedsIncrementalBarrier();
  gc::FreeSpan** addressOfFreeList(gc::AllocKind allocKind);
  void* addressOfNurseryPosition();
  void* addressOfStringNurseryPosition();
  const void* addressOfNurseryCurrentEnd();
  const void* addressOfStringNurseryCurrentEnd();

  uint32_t* addressOfNurseryAllocCount();

  bool nurseryExists();
  bool canNurseryAllocateStrings();
  void setMinorGCShouldCancelIonCompilations();
};

class JitRealm;

class CompileRealm {
  JS::Realm* realm();

 public:
  static CompileRealm* get(JS::Realm* realm);

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

  const void* realmPtr() { return realm(); }

  const mozilla::non_crypto::XorShift128PlusRNG*
  addressOfRandomNumberGenerator();

  const JitRealm* jitRealm();

  const GlobalObject* maybeGlobal();
  const uint32_t* addressOfGlobalWriteBarriered();

  bool hasAllocationMetadataBuilder();

  // Mirror RealmOptions.
  void setSingletonsAsValues();
};

class JitCompileOptions {
 public:
  JitCompileOptions();
  explicit JitCompileOptions(JSContext* cx);

  bool cloneSingletons() const { return cloneSingletons_; }

  bool profilerSlowAssertionsEnabled() const {
    return profilerSlowAssertionsEnabled_;
  }

  bool offThreadCompilationAvailable() const {
    return offThreadCompilationAvailable_;
  }

 private:
  bool cloneSingletons_;
  bool profilerSlowAssertionsEnabled_;
  bool offThreadCompilationAvailable_;
};

}  // namespace jit
}  // namespace js

#endif  // jit_CompileWrappers_h