/[jscoverage]/trunk/js/jscntxt.h
ViewVC logotype

Contents of /trunk/js/jscntxt.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 460 - (show annotations)
Sat Sep 26 23:15:22 2009 UTC (10 years, 1 month ago) by siliconforks
File MIME type: text/plain
File size: 52020 byte(s)
Upgrade to SpiderMonkey from Firefox 3.5.3.

1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 * vim: set ts=8 sw=4 et tw=78:
3 *
4 * ***** BEGIN LICENSE BLOCK *****
5 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
6 *
7 * The contents of this file are subject to the Mozilla Public License Version
8 * 1.1 (the "License"); you may not use this file except in compliance with
9 * the License. You may obtain a copy of the License at
10 * http://www.mozilla.org/MPL/
11 *
12 * Software distributed under the License is distributed on an "AS IS" basis,
13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14 * for the specific language governing rights and limitations under the
15 * License.
16 *
17 * The Original Code is Mozilla Communicator client code, released
18 * March 31, 1998.
19 *
20 * The Initial Developer of the Original Code is
21 * Netscape Communications Corporation.
22 * Portions created by the Initial Developer are Copyright (C) 1998
23 * the Initial Developer. All Rights Reserved.
24 *
25 * Contributor(s):
26 *
27 * Alternatively, the contents of this file may be used under the terms of
28 * either of the GNU General Public License Version 2 or later (the "GPL"),
29 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
30 * in which case the provisions of the GPL or the LGPL are applicable instead
31 * of those above. If you wish to allow use of your version of this file only
32 * under the terms of either the GPL or the LGPL, and not to allow others to
33 * use your version of this file under the terms of the MPL, indicate your
34 * decision by deleting the provisions above and replace them with the notice
35 * and other provisions required by the GPL or the LGPL. If you do not delete
36 * the provisions above, a recipient may use your version of this file under
37 * the terms of any one of the MPL, the GPL or the LGPL.
38 *
39 * ***** END LICENSE BLOCK ***** */
40
41 #ifndef jscntxt_h___
42 #define jscntxt_h___
43 /*
44 * JS execution context.
45 */
46 #include "jsarena.h" /* Added by JSIFY */
47 #include "jsclist.h"
48 #include "jslong.h"
49 #include "jsatom.h"
50 #include "jsversion.h"
51 #include "jsdhash.h"
52 #include "jsgc.h"
53 #include "jsinterp.h"
54 #include "jsobj.h"
55 #include "jsprvtd.h"
56 #include "jspubtd.h"
57 #include "jsregexp.h"
58 #include "jsutil.h"
59
60 JS_BEGIN_EXTERN_C
61
62 /*
63 * js_GetSrcNote cache to avoid O(n^2) growth in finding a source note for a
64 * given pc in a script. We use the script->code pointer to tag the cache,
65 * instead of the script address itself, so that source notes are always found
66 * by offset from the bytecode with which they were generated.
67 */
68 typedef struct JSGSNCache {
69 jsbytecode *code;
70 JSDHashTable table;
71 #ifdef JS_GSNMETER
72 uint32 hits;
73 uint32 misses;
74 uint32 fills;
75 uint32 purges;
76 # define GSN_CACHE_METER(cache,cnt) (++(cache)->cnt)
77 #else
78 # define GSN_CACHE_METER(cache,cnt) /* nothing */
79 #endif
80 } JSGSNCache;
81
82 #define js_FinishGSNCache(cache) js_PurgeGSNCache(cache)
83
84 extern void
85 js_PurgeGSNCache(JSGSNCache *cache);
86
87 /* These helper macros take a cx as parameter and operate on its GSN cache. */
88 #define JS_PURGE_GSN_CACHE(cx) js_PurgeGSNCache(&JS_GSN_CACHE(cx))
89 #define JS_METER_GSN_CACHE(cx,cnt) GSN_CACHE_METER(&JS_GSN_CACHE(cx), cnt)
90
91 typedef struct InterpState InterpState;
92 typedef struct VMSideExit VMSideExit;
93
94 #ifdef __cplusplus
95 namespace nanojit {
96 class Fragment;
97 class Fragmento;
98 class LirBuffer;
99 }
100 class TraceRecorder;
101 extern "C++" { template<typename T> class Queue; }
102 typedef Queue<uint16> SlotList;
103
104 # define CLS(T) T*
105 #else
106 # define CLS(T) void*
107 #endif
108
109 #define FRAGMENT_TABLE_SIZE 512
110 struct VMFragment;
111
112 #define MONITOR_N_GLOBAL_STATES 4
113 struct GlobalState {
114 JSObject* globalObj;
115 uint32 globalShape;
116 CLS(SlotList) globalSlots;
117 };
118
119 /*
120 * Trace monitor. Every JSThread (if JS_THREADSAFE) or JSRuntime (if not
121 * JS_THREADSAFE) has an associated trace monitor that keeps track of loop
122 * frequencies for all JavaScript code loaded into that runtime.
123 */
124 struct JSTraceMonitor {
125 /*
126 * The context currently executing JIT-compiled code on this thread, or
127 * NULL if none. Among other things, this can in certain cases prevent
128 * last-ditch GC and suppress calls to JS_ReportOutOfMemory.
129 *
130 * !tracecx && !recorder: not on trace
131 * !tracecx && !recorder && prohibitFlush: deep-bailed
132 * !tracecx && recorder && !recorder->deepAborted: recording
133 * !tracecx && recorder && recorder->deepAborted: deep aborted
134 * tracecx && !recorder: executing a trace
135 * tracecx && recorder: executing inner loop, recording outer loop
136 */
137 JSContext *tracecx;
138
139 CLS(nanojit::LirBuffer) lirbuf;
140 CLS(nanojit::Fragmento) fragmento;
141 CLS(TraceRecorder) recorder;
142 jsval *reservedDoublePool;
143 jsval *reservedDoublePoolPtr;
144
145 struct GlobalState globalStates[MONITOR_N_GLOBAL_STATES];
146 struct VMFragment* vmfragments[FRAGMENT_TABLE_SIZE];
147 JSDHashTable recordAttempts;
148
149 /*
150 * Maximum size of the code cache before we start flushing. 1/16 of this
151 * size is used as threshold for the regular expression code cache.
152 */
153 uint32 maxCodeCacheBytes;
154
155 /*
156 * If nonzero, do not flush the JIT cache after a deep bail. That would
157 * free JITted code pages that we will later return to. Instead, set the
158 * needFlush flag so that it can be flushed later.
159 *
160 * NB: needFlush and useReservedObjects are packed together.
161 */
162 uintN prohibitFlush;
163 JSPackedBool needFlush;
164
165 /*
166 * reservedObjects is a linked list (via fslots[0]) of preallocated JSObjects.
167 * The JIT uses this to ensure that leaving a trace tree can't fail.
168 */
169 JSPackedBool useReservedObjects;
170 JSObject *reservedObjects;
171
172 /* Fragmento for the regular expression compiler. This is logically
173 * a distinct compiler but needs to be managed in exactly the same
174 * way as the real tracing Fragmento. */
175 CLS(nanojit::LirBuffer) reLirBuf;
176 CLS(nanojit::Fragmento) reFragmento;
177
178 /* Keep a list of recorders we need to abort on cache flush. */
179 CLS(TraceRecorder) abortStack;
180 };
181
182 typedef struct InterpStruct InterpStruct;
183
184 /*
185 * N.B. JS_ON_TRACE(cx) is true if JIT code is on the stack in the current
186 * thread, regardless of whether cx is the context in which that trace is
187 * executing. cx must be a context on the current thread.
188 */
189 #ifdef JS_TRACER
190 # define JS_ON_TRACE(cx) (JS_TRACE_MONITOR(cx).tracecx != NULL)
191 #else
192 # define JS_ON_TRACE(cx) JS_FALSE
193 #endif
194
195 #ifdef DEBUG
196 # define JS_EVAL_CACHE_METERING 1
197 # define JS_FUNCTION_METERING 1
198 #endif
199
200 /* Number of potentially reusable scriptsToGC to search for the eval cache. */
201 #ifndef JS_EVAL_CACHE_SHIFT
202 # define JS_EVAL_CACHE_SHIFT 6
203 #endif
204 #define JS_EVAL_CACHE_SIZE JS_BIT(JS_EVAL_CACHE_SHIFT)
205
206 #ifdef JS_EVAL_CACHE_METERING
207 # define EVAL_CACHE_METER_LIST(_) _(probe), _(hit), _(step), _(noscope)
208 # define identity(x) x
209
210 /* Have to typedef this for LiveConnect C code, which includes us. */
211 typedef struct JSEvalCacheMeter {
212 uint64 EVAL_CACHE_METER_LIST(identity);
213 } JSEvalCacheMeter;
214
215 # undef identity
216 #endif
217
218 #ifdef JS_FUNCTION_METERING
219 # define FUNCTION_KIND_METER_LIST(_) \
220 _(allfun), _(heavy), _(nofreeupvar), _(onlyfreevar), \
221 _(display), _(flat), _(setupvar), _(badfunarg)
222 # define identity(x) x
223
224 typedef struct JSFunctionMeter {
225 int32 FUNCTION_KIND_METER_LIST(identity);
226 } JSFunctionMeter;
227
228 # undef identity
229 #endif
230
231 struct JSThreadData {
232 /*
233 * The GSN cache is per thread since even multi-cx-per-thread embeddings
234 * do not interleave js_GetSrcNote calls.
235 */
236 JSGSNCache gsnCache;
237
238 /* Property cache for faster call/get/set invocation. */
239 JSPropertyCache propertyCache;
240
241 #ifdef JS_TRACER
242 /* Trace-tree JIT recorder/interpreter state. */
243 JSTraceMonitor traceMonitor;
244 #endif
245
246 /* Lock-free hashed lists of scripts created by eval to garbage-collect. */
247 JSScript *scriptsToGC[JS_EVAL_CACHE_SIZE];
248
249 #ifdef JS_EVAL_CACHE_METERING
250 JSEvalCacheMeter evalCacheMeter;
251 #endif
252 };
253
254 #ifdef JS_THREADSAFE
255
256 /*
257 * Structure uniquely representing a thread. It holds thread-private data
258 * that can be accessed without a global lock.
259 */
260 struct JSThread {
261 /* Linked list of all contexts in use on this thread. */
262 JSCList contextList;
263
264 /* Opaque thread-id, from NSPR's PR_GetCurrentThread(). */
265 jsword id;
266
267 /*
268 * Thread-local version of JSRuntime.gcMallocBytes to avoid taking
269 * locks on each JS_malloc.
270 */
271 uint32 gcMallocBytes;
272
273 /* Indicates that the thread is waiting in ClaimTitle from jslock.cpp. */
274 JSTitle *titleToShare;
275
276 /* Factored out of JSThread for !JS_THREADSAFE embedding in JSRuntime. */
277 JSThreadData data;
278 };
279
280 #define JS_THREAD_DATA(cx) (&(cx)->thread->data)
281
282 struct JSThreadsHashEntry {
283 JSDHashEntryHdr base;
284 JSThread *thread;
285 };
286
287 /*
288 * The function takes the GC lock and does not release in successful return.
289 * On error (out of memory) the function releases the lock but delegates
290 * the error reporting to the caller.
291 */
292 extern JSBool
293 js_InitContextThread(JSContext *cx);
294
295 /*
296 * On entrance the GC lock must be held and it will be held on exit.
297 */
298 extern void
299 js_ClearContextThread(JSContext *cx);
300
301 #endif /* JS_THREADSAFE */
302
303 typedef enum JSDestroyContextMode {
304 JSDCM_NO_GC,
305 JSDCM_MAYBE_GC,
306 JSDCM_FORCE_GC,
307 JSDCM_NEW_FAILED
308 } JSDestroyContextMode;
309
310 typedef enum JSRuntimeState {
311 JSRTS_DOWN,
312 JSRTS_LAUNCHING,
313 JSRTS_UP,
314 JSRTS_LANDING
315 } JSRuntimeState;
316
317 typedef enum JSBuiltinFunctionId {
318 JSBUILTIN_ObjectToIterator,
319 JSBUILTIN_CallIteratorNext,
320 JSBUILTIN_GetProperty,
321 JSBUILTIN_GetElement,
322 JSBUILTIN_SetProperty,
323 JSBUILTIN_SetElement,
324 JSBUILTIN_LIMIT
325 } JSBuiltinFunctionId;
326
327 typedef struct JSPropertyTreeEntry {
328 JSDHashEntryHdr hdr;
329 JSScopeProperty *child;
330 } JSPropertyTreeEntry;
331
332 typedef struct JSSetSlotRequest JSSetSlotRequest;
333
334 struct JSSetSlotRequest {
335 JSObject *obj; /* object containing slot to set */
336 JSObject *pobj; /* new proto or parent reference */
337 uint16 slot; /* which to set, proto or parent */
338 JSPackedBool cycle; /* true if a cycle was detected */
339 JSSetSlotRequest *next; /* next request in GC worklist */
340 };
341
342 struct JSRuntime {
343 /* Runtime state, synchronized by the stateChange/gcLock condvar/lock. */
344 JSRuntimeState state;
345
346 /* Context create/destroy callback. */
347 JSContextCallback cxCallback;
348
349 /*
350 * Shape regenerated whenever a prototype implicated by an "add property"
351 * property cache fill and induced trace guard has a readonly property or a
352 * setter defined on it. This number proxies for the shapes of all objects
353 * along the prototype chain of all objects in the runtime on which such an
354 * add-property result has been cached/traced.
355 *
356 * See bug 492355 for more details.
357 *
358 * This comes early in JSRuntime to minimize the immediate format used by
359 * trace-JITted code that reads it.
360 */
361 uint32 protoHazardShape;
362
363 /* Garbage collector state, used by jsgc.c. */
364 JSGCChunkInfo *gcChunkList;
365 JSGCArenaList gcArenaList[GC_NUM_FREELISTS];
366 JSGCDoubleArenaList gcDoubleArenaList;
367 JSGCFreeListSet *gcFreeListsPool;
368 JSDHashTable gcRootsHash;
369 JSDHashTable *gcLocksHash;
370 jsrefcount gcKeepAtoms;
371 uint32 gcBytes;
372 uint32 gcLastBytes;
373 uint32 gcMaxBytes;
374 uint32 gcMaxMallocBytes;
375 uint32 gcEmptyArenaPoolLifespan;
376 uint32 gcLevel;
377 uint32 gcNumber;
378 JSTracer *gcMarkingTracer;
379 uint32 gcTriggerFactor;
380 volatile JSBool gcIsNeeded;
381
382 /*
383 * NB: do not pack another flag here by claiming gcPadding unless the new
384 * flag is written only by the GC thread. Atomic updates to packed bytes
385 * are not guaranteed, so stores issued by one thread may be lost due to
386 * unsynchronized read-modify-write cycles on other threads.
387 */
388 JSPackedBool gcPoke;
389 JSPackedBool gcRunning;
390 uint16 gcPadding;
391 #ifdef JS_GC_ZEAL
392 jsrefcount gcZeal;
393 #endif
394
395 JSGCCallback gcCallback;
396 uint32 gcMallocBytes;
397 JSGCArenaInfo *gcUntracedArenaStackTop;
398 #ifdef DEBUG
399 size_t gcTraceLaterCount;
400 #endif
401
402 /*
403 * Table for tracking iterators to ensure that we close iterator's state
404 * before finalizing the iterable object.
405 */
406 JSPtrTable gcIteratorTable;
407
408 /*
409 * The trace operation and its data argument to trace embedding-specific
410 * GC roots.
411 */
412 JSTraceDataOp gcExtraRootsTraceOp;
413 void *gcExtraRootsData;
414
415 /*
416 * Used to serialize cycle checks when setting __proto__ or __parent__ by
417 * requesting the GC handle the required cycle detection. If the GC hasn't
418 * been poked, it won't scan for garbage. This member is protected by
419 * rt->gcLock.
420 */
421 JSSetSlotRequest *setSlotRequests;
422
423 /* Random number generator state, used by jsmath.c. */
424 JSBool rngInitialized;
425 int64 rngMultiplier;
426 int64 rngAddend;
427 int64 rngMask;
428 int64 rngSeed;
429 jsdouble rngDscale;
430
431 /* Well-known numbers held for use by this runtime's contexts. */
432 jsdouble *jsNaN;
433 jsdouble *jsNegativeInfinity;
434 jsdouble *jsPositiveInfinity;
435
436 #ifdef JS_THREADSAFE
437 JSLock *deflatedStringCacheLock;
438 #endif
439 JSHashTable *deflatedStringCache;
440 #ifdef DEBUG
441 uint32 deflatedStringCacheBytes;
442 #endif
443
444 /*
445 * Empty and unit-length strings held for use by this runtime's contexts.
446 * The unitStrings array and its elements are created on demand.
447 */
448 JSString *emptyString;
449 JSString **unitStrings;
450
451 /*
452 * Builtin functions, lazily created and held for use by the trace recorder.
453 *
454 * This field would be #ifdef JS_TRACER, but XPConnect is compiled without
455 * -DJS_TRACER and includes this header.
456 */
457 JSObject *builtinFunctions[JSBUILTIN_LIMIT];
458
459 /* List of active contexts sharing this runtime; protected by gcLock. */
460 JSCList contextList;
461
462 /* Per runtime debug hooks -- see jsprvtd.h and jsdbgapi.h. */
463 JSDebugHooks globalDebugHooks;
464
465 /* More debugging state, see jsdbgapi.c. */
466 JSCList trapList;
467 JSCList watchPointList;
468
469 /* Client opaque pointers */
470 void *data;
471
472 #ifdef JS_THREADSAFE
473 /* These combine to interlock the GC and new requests. */
474 PRLock *gcLock;
475 PRCondVar *gcDone;
476 PRCondVar *requestDone;
477 uint32 requestCount;
478 JSThread *gcThread;
479
480 /* Lock and owning thread pointer for JS_LOCK_RUNTIME. */
481 PRLock *rtLock;
482 #ifdef DEBUG
483 jsword rtLockOwner;
484 #endif
485
486 /* Used to synchronize down/up state change; protected by gcLock. */
487 PRCondVar *stateChange;
488
489 /*
490 * State for sharing single-threaded titles, once a second thread tries to
491 * lock a title. The titleSharingDone condvar is protected by rt->gcLock
492 * to minimize number of locks taken in JS_EndRequest.
493 *
494 * The titleSharingTodo linked list is likewise "global" per runtime, not
495 * one-list-per-context, to conserve space over all contexts, optimizing
496 * for the likely case that titles become shared rarely, and among a very
497 * small set of threads (contexts).
498 */
499 PRCondVar *titleSharingDone;
500 JSTitle *titleSharingTodo;
501
502 /*
503 * Magic terminator for the rt->titleSharingTodo linked list, threaded through
504 * title->u.link. This hack allows us to test whether a title is on the list
505 * by asking whether title->u.link is non-null. We use a large, likely bogus
506 * pointer here to distinguish this value from any valid u.count (small int)
507 * value.
508 */
509 #define NO_TITLE_SHARING_TODO ((JSTitle *) 0xfeedbeef)
510
511 /*
512 * Lock serializing trapList and watchPointList accesses, and count of all
513 * mutations to trapList and watchPointList made by debugger threads. To
514 * keep the code simple, we define debuggerMutations for the thread-unsafe
515 * case too.
516 */
517 PRLock *debuggerLock;
518
519 JSDHashTable threads;
520 #endif /* JS_THREADSAFE */
521 uint32 debuggerMutations;
522
523 /*
524 * Security callbacks set on the runtime are used by each context unless
525 * an override is set on the context.
526 */
527 JSSecurityCallbacks *securityCallbacks;
528
529 /*
530 * Shared scope property tree, and arena-pool for allocating its nodes.
531 * The propertyRemovals counter is incremented for every js_ClearScope,
532 * and for each js_RemoveScopeProperty that frees a slot in an object.
533 * See js_NativeGet and js_NativeSet in jsobj.c.
534 */
535 JSDHashTable propertyTreeHash;
536 JSScopeProperty *propertyFreeList;
537 JSArenaPool propertyArenaPool;
538 int32 propertyRemovals;
539
540 /* Script filename table. */
541 struct JSHashTable *scriptFilenameTable;
542 JSCList scriptFilenamePrefixes;
543 #ifdef JS_THREADSAFE
544 PRLock *scriptFilenameTableLock;
545 #endif
546
547 /* Number localization, used by jsnum.c */
548 const char *thousandsSeparator;
549 const char *decimalSeparator;
550 const char *numGrouping;
551
552 /*
553 * Weak references to lazily-created, well-known XML singletons.
554 *
555 * NB: Singleton objects must be carefully disconnected from the rest of
556 * the object graph usually associated with a JSContext's global object,
557 * including the set of standard class objects. See jsxml.c for details.
558 */
559 JSObject *anynameObject;
560 JSObject *functionNamespaceObject;
561
562 /*
563 * A helper list for the GC, so it can mark native iterator states. See
564 * js_TraceNativeEnumerators for details.
565 */
566 JSNativeEnumerator *nativeEnumerators;
567
568 #ifndef JS_THREADSAFE
569 JSThreadData threadData;
570
571 #define JS_THREAD_DATA(cx) (&(cx)->runtime->threadData)
572 #endif
573
574 /*
575 * Object shape (property cache structural type) identifier generator.
576 *
577 * Type 0 stands for the empty scope, and must not be regenerated due to
578 * uint32 wrap-around. Since js_GenerateShape (in jsinterp.cpp) uses
579 * atomic pre-increment, the initial value for the first typed non-empty
580 * scope will be 1.
581 *
582 * If this counter overflows into SHAPE_OVERFLOW_BIT (in jsinterp.h), the
583 * cache is disabled, to avoid aliasing two different types. It stays
584 * disabled until a triggered GC at some later moment compresses live
585 * types, minimizing rt->shapeGen in the process.
586 */
587 volatile uint32 shapeGen;
588
589 /* Literal table maintained by jsatom.c functions. */
590 JSAtomState atomState;
591
592 /*
593 * Cache of reusable JSNativeEnumerators mapped by shape identifiers (as
594 * stored in scope->shape). This cache is nulled by the GC and protected
595 * by gcLock.
596 */
597 #define NATIVE_ENUM_CACHE_LOG2 8
598 #define NATIVE_ENUM_CACHE_MASK JS_BITMASK(NATIVE_ENUM_CACHE_LOG2)
599 #define NATIVE_ENUM_CACHE_SIZE JS_BIT(NATIVE_ENUM_CACHE_LOG2)
600
601 #define NATIVE_ENUM_CACHE_HASH(shape) \
602 ((((shape) >> NATIVE_ENUM_CACHE_LOG2) ^ (shape)) & NATIVE_ENUM_CACHE_MASK)
603
604 jsuword nativeEnumCache[NATIVE_ENUM_CACHE_SIZE];
605
606 /*
607 * Various metering fields are defined at the end of JSRuntime. In this
608 * way there is no need to recompile all the code that refers to other
609 * fields of JSRuntime after enabling the corresponding metering macro.
610 */
611 #ifdef JS_DUMP_ENUM_CACHE_STATS
612 int32 nativeEnumProbes;
613 int32 nativeEnumMisses;
614 # define ENUM_CACHE_METER(name) JS_ATOMIC_INCREMENT(&cx->runtime->name)
615 #else
616 # define ENUM_CACHE_METER(name) ((void) 0)
617 #endif
618
619 #ifdef JS_DUMP_LOOP_STATS
620 /* Loop statistics, to trigger trace recording and compiling. */
621 JSBasicStats loopStats;
622 #endif
623
624 #if defined DEBUG || defined JS_DUMP_PROPTREE_STATS
625 /* Function invocation metering. */
626 jsrefcount inlineCalls;
627 jsrefcount nativeCalls;
628 jsrefcount nonInlineCalls;
629 jsrefcount constructs;
630
631 /* Title lock and scope property metering. */
632 jsrefcount claimAttempts;
633 jsrefcount claimedTitles;
634 jsrefcount deadContexts;
635 jsrefcount deadlocksAvoided;
636 jsrefcount liveScopes;
637 jsrefcount sharedTitles;
638 jsrefcount totalScopes;
639 jsrefcount liveScopeProps;
640 jsrefcount liveScopePropsPreSweep;
641 jsrefcount totalScopeProps;
642 jsrefcount livePropTreeNodes;
643 jsrefcount duplicatePropTreeNodes;
644 jsrefcount totalPropTreeNodes;
645 jsrefcount propTreeKidsChunks;
646 jsrefcount middleDeleteFixups;
647
648 /* String instrumentation. */
649 jsrefcount liveStrings;
650 jsrefcount totalStrings;
651 jsrefcount liveDependentStrings;
652 jsrefcount totalDependentStrings;
653 jsrefcount badUndependStrings;
654 double lengthSum;
655 double lengthSquaredSum;
656 double strdepLengthSum;
657 double strdepLengthSquaredSum;
658 #endif /* DEBUG || JS_DUMP_PROPTREE_STATS */
659
660 #ifdef JS_SCOPE_DEPTH_METER
661 /*
662 * Stats on runtime prototype chain lookups and scope chain depths, i.e.,
663 * counts of objects traversed on a chain until the wanted id is found.
664 */
665 JSBasicStats protoLookupDepthStats;
666 JSBasicStats scopeSearchDepthStats;
667
668 /*
669 * Stats on compile-time host environment and lexical scope chain lengths
670 * (maximum depths).
671 */
672 JSBasicStats hostenvScopeDepthStats;
673 JSBasicStats lexicalScopeDepthStats;
674 #endif
675
676 #ifdef JS_GCMETER
677 JSGCStats gcStats;
678 #endif
679
680 #ifdef JS_FUNCTION_METERING
681 JSFunctionMeter functionMeter;
682 char lastScriptFilename[1024];
683 #endif
684 };
685
686 /* Common macros to access thread-local caches in JSThread or JSRuntime. */
687 #define JS_GSN_CACHE(cx) (JS_THREAD_DATA(cx)->gsnCache)
688 #define JS_PROPERTY_CACHE(cx) (JS_THREAD_DATA(cx)->propertyCache)
689 #define JS_TRACE_MONITOR(cx) (JS_THREAD_DATA(cx)->traceMonitor)
690 #define JS_SCRIPTS_TO_GC(cx) (JS_THREAD_DATA(cx)->scriptsToGC)
691
692 #ifdef JS_EVAL_CACHE_METERING
693 # define EVAL_CACHE_METER(x) (JS_THREAD_DATA(cx)->evalCacheMeter.x++)
694 #else
695 # define EVAL_CACHE_METER(x) ((void) 0)
696 #endif
697
698 #ifdef DEBUG
699 # define JS_RUNTIME_METER(rt, which) JS_ATOMIC_INCREMENT(&(rt)->which)
700 # define JS_RUNTIME_UNMETER(rt, which) JS_ATOMIC_DECREMENT(&(rt)->which)
701 #else
702 # define JS_RUNTIME_METER(rt, which) /* nothing */
703 # define JS_RUNTIME_UNMETER(rt, which) /* nothing */
704 #endif
705
706 #define JS_KEEP_ATOMS(rt) JS_ATOMIC_INCREMENT(&(rt)->gcKeepAtoms);
707 #define JS_UNKEEP_ATOMS(rt) JS_ATOMIC_DECREMENT(&(rt)->gcKeepAtoms);
708
709 #ifdef JS_ARGUMENT_FORMATTER_DEFINED
710 /*
711 * Linked list mapping format strings for JS_{Convert,Push}Arguments{,VA} to
712 * formatter functions. Elements are sorted in non-increasing format string
713 * length order.
714 */
715 struct JSArgumentFormatMap {
716 const char *format;
717 size_t length;
718 JSArgumentFormatter formatter;
719 JSArgumentFormatMap *next;
720 };
721 #endif
722
723 struct JSStackHeader {
724 uintN nslots;
725 JSStackHeader *down;
726 };
727
728 #define JS_STACK_SEGMENT(sh) ((jsval *)(sh) + 2)
729
730 /*
731 * Key and entry types for the JSContext.resolvingTable hash table, typedef'd
732 * here because all consumers need to see these declarations (and not just the
733 * typedef names, as would be the case for an opaque pointer-to-typedef'd-type
734 * declaration), along with cx->resolvingTable.
735 */
736 typedef struct JSResolvingKey {
737 JSObject *obj;
738 jsid id;
739 } JSResolvingKey;
740
741 typedef struct JSResolvingEntry {
742 JSDHashEntryHdr hdr;
743 JSResolvingKey key;
744 uint32 flags;
745 } JSResolvingEntry;
746
747 #define JSRESFLAG_LOOKUP 0x1 /* resolving id from lookup */
748 #define JSRESFLAG_WATCH 0x2 /* resolving id from watch */
749
750 typedef struct JSLocalRootChunk JSLocalRootChunk;
751
752 #define JSLRS_CHUNK_SHIFT 8
753 #define JSLRS_CHUNK_SIZE JS_BIT(JSLRS_CHUNK_SHIFT)
754 #define JSLRS_CHUNK_MASK JS_BITMASK(JSLRS_CHUNK_SHIFT)
755
756 struct JSLocalRootChunk {
757 jsval roots[JSLRS_CHUNK_SIZE];
758 JSLocalRootChunk *down;
759 };
760
761 typedef struct JSLocalRootStack {
762 uint32 scopeMark;
763 uint32 rootCount;
764 JSLocalRootChunk *topChunk;
765 JSLocalRootChunk firstChunk;
766 } JSLocalRootStack;
767
768 #define JSLRS_NULL_MARK ((uint32) -1)
769
770 /*
771 * Macros to push/pop JSTempValueRooter instances to context-linked stack of
772 * temporary GC roots. If you need to protect a result value that flows out of
773 * a C function across several layers of other functions, use the
774 * js_LeaveLocalRootScopeWithResult internal API (see further below) instead.
775 *
776 * The macros also provide a simple way to get a single rooted pointer via
777 * JS_PUSH_TEMP_ROOT_<KIND>(cx, NULL, &tvr). Then &tvr.u.<kind> gives the
778 * necessary pointer.
779 *
780 * JSTempValueRooter.count defines the type of the rooted value referenced by
781 * JSTempValueRooter.u union of type JSTempValueUnion. When count is positive
782 * or zero, u.array points to a vector of jsvals. Otherwise it must be one of
783 * the following constants:
784 */
785 #define JSTVU_SINGLE (-1) /* u.value or u.<gcthing> is single jsval
786 or GC-thing */
787 #define JSTVU_TRACE (-2) /* u.trace is a hook to trace a custom
788 * structure */
789 #define JSTVU_SPROP (-3) /* u.sprop roots property tree node */
790 #define JSTVU_WEAK_ROOTS (-4) /* u.weakRoots points to saved weak roots */
791 #define JSTVU_COMPILER (-5) /* u.compiler roots JSCompiler* */
792 #define JSTVU_SCRIPT (-6) /* u.script roots JSScript* */
793
794 /*
795 * Here single JSTVU_SINGLE covers both jsval and pointers to any GC-thing via
796 * reinterpreting the thing as JSVAL_OBJECT. It works because the GC-thing is
797 * aligned on a 0 mod 8 boundary, and object has the 0 jsval tag. So any
798 * GC-thing may be tagged as if it were an object and untagged, if it's then
799 * used only as an opaque pointer until discriminated by other means than tag
800 * bits. This is how, for example, js_GetGCThingTraceKind uses its |thing|
801 * parameter -- it consults GC-thing flags stored separately from the thing to
802 * decide the kind of thing.
803 */
804 #define JS_PUSH_TEMP_ROOT_COMMON(cx,x,tvr,cnt,kind) \
805 JS_BEGIN_MACRO \
806 JS_ASSERT((cx)->tempValueRooters != (tvr)); \
807 (tvr)->count = (cnt); \
808 (tvr)->u.kind = (x); \
809 (tvr)->down = (cx)->tempValueRooters; \
810 (cx)->tempValueRooters = (tvr); \
811 JS_END_MACRO
812
813 #define JS_POP_TEMP_ROOT(cx,tvr) \
814 JS_BEGIN_MACRO \
815 JS_ASSERT((cx)->tempValueRooters == (tvr)); \
816 (cx)->tempValueRooters = (tvr)->down; \
817 JS_END_MACRO
818
819 #define JS_PUSH_TEMP_ROOT(cx,cnt,arr,tvr) \
820 JS_BEGIN_MACRO \
821 JS_ASSERT((int)(cnt) >= 0); \
822 JS_PUSH_TEMP_ROOT_COMMON(cx, arr, tvr, (ptrdiff_t) (cnt), array); \
823 JS_END_MACRO
824
825 #define JS_PUSH_SINGLE_TEMP_ROOT(cx,val,tvr) \
826 JS_PUSH_TEMP_ROOT_COMMON(cx, val, tvr, JSTVU_SINGLE, value)
827
828 #define JS_PUSH_TEMP_ROOT_OBJECT(cx,obj,tvr) \
829 JS_PUSH_TEMP_ROOT_COMMON(cx, obj, tvr, JSTVU_SINGLE, object)
830
831 #define JS_PUSH_TEMP_ROOT_STRING(cx,str,tvr) \
832 JS_PUSH_TEMP_ROOT_COMMON(cx, str, tvr, JSTVU_SINGLE, string)
833
834 #define JS_PUSH_TEMP_ROOT_XML(cx,xml_,tvr) \
835 JS_PUSH_TEMP_ROOT_COMMON(cx, xml_, tvr, JSTVU_SINGLE, xml)
836
837 #define JS_PUSH_TEMP_ROOT_TRACE(cx,trace_,tvr) \
838 JS_PUSH_TEMP_ROOT_COMMON(cx, trace_, tvr, JSTVU_TRACE, trace)
839
840 #define JS_PUSH_TEMP_ROOT_SPROP(cx,sprop_,tvr) \
841 JS_PUSH_TEMP_ROOT_COMMON(cx, sprop_, tvr, JSTVU_SPROP, sprop)
842
843 #define JS_PUSH_TEMP_ROOT_WEAK_COPY(cx,weakRoots_,tvr) \
844 JS_PUSH_TEMP_ROOT_COMMON(cx, weakRoots_, tvr, JSTVU_WEAK_ROOTS, weakRoots)
845
846 #define JS_PUSH_TEMP_ROOT_COMPILER(cx,pc,tvr) \
847 JS_PUSH_TEMP_ROOT_COMMON(cx, pc, tvr, JSTVU_COMPILER, compiler)
848
849 #define JS_PUSH_TEMP_ROOT_SCRIPT(cx,script_,tvr) \
850 JS_PUSH_TEMP_ROOT_COMMON(cx, script_, tvr, JSTVU_SCRIPT, script)
851
852
853 #define JSRESOLVE_INFER 0xffff /* infer bits from current bytecode */
854
855 struct JSContext {
856 /*
857 * If this flag is set, we were asked to call back the operation callback
858 * as soon as possible.
859 */
860 volatile jsint operationCallbackFlag;
861
862 /* JSRuntime contextList linkage. */
863 JSCList link;
864
865 #if JS_HAS_XML_SUPPORT
866 /*
867 * Bit-set formed from binary exponentials of the XML_* tiny-ids defined
868 * for boolean settings in jsxml.c, plus an XSF_CACHE_VALID bit. Together
869 * these act as a cache of the boolean XML.ignore* and XML.prettyPrinting
870 * property values associated with this context's global object.
871 */
872 uint8 xmlSettingFlags;
873 uint8 padding;
874 #else
875 uint16 padding;
876 #endif
877
878 /*
879 * Classic Algol "display" static link optimization.
880 */
881 #define JS_DISPLAY_SIZE 16U
882
883 JSStackFrame *display[JS_DISPLAY_SIZE];
884
885 /* Runtime version control identifier. */
886 uint16 version;
887
888 /* Per-context options. */
889 uint32 options; /* see jsapi.h for JSOPTION_* */
890
891 /* Locale specific callbacks for string conversion. */
892 JSLocaleCallbacks *localeCallbacks;
893
894 /*
895 * cx->resolvingTable is non-null and non-empty if we are initializing
896 * standard classes lazily, or if we are otherwise recursing indirectly
897 * from js_LookupProperty through a JSClass.resolve hook. It is used to
898 * limit runaway recursion (see jsapi.c and jsobj.c).
899 */
900 JSDHashTable *resolvingTable;
901
902 #if JS_HAS_LVALUE_RETURN
903 /*
904 * Secondary return value from native method called on the left-hand side
905 * of an assignment operator. The native should store the object in which
906 * to set a property in *rval, and return the property's id expressed as a
907 * jsval by calling JS_SetCallReturnValue2(cx, idval).
908 */
909 jsval rval2;
910 JSPackedBool rval2set;
911 #endif
912
913 /*
914 * True if generating an error, to prevent runaway recursion.
915 * NB: generatingError packs with rval2set, #if JS_HAS_LVALUE_RETURN;
916 * with insideGCMarkCallback and with throwing below.
917 */
918 JSPackedBool generatingError;
919
920 /* Flag to indicate that we run inside gcCallback(cx, JSGC_MARK_END). */
921 JSPackedBool insideGCMarkCallback;
922
923 /* Exception state -- the exception member is a GC root by definition. */
924 JSPackedBool throwing; /* is there a pending exception? */
925 jsval exception; /* most-recently-thrown exception */
926
927 /* Limit pointer for checking native stack consumption during recursion. */
928 jsuword stackLimit;
929
930 /* Quota on the size of arenas used to compile and execute scripts. */
931 size_t scriptStackQuota;
932
933 /* Data shared by threads in an address space. */
934 JSRuntime *runtime;
935
936 /* Stack arena pool and frame pointer register. */
937 JS_REQUIRES_STACK
938 JSArenaPool stackPool;
939
940 JS_REQUIRES_STACK
941 JSStackFrame *fp;
942
943 /* Temporary arena pool used while compiling and decompiling. */
944 JSArenaPool tempPool;
945
946 /* Top-level object and pointer to top stack frame's scope chain. */
947 JSObject *globalObject;
948
949 /* Storage to root recently allocated GC things and script result. */
950 JSWeakRoots weakRoots;
951
952 /* Regular expression class statics (XXX not shared globally). */
953 JSRegExpStatics regExpStatics;
954
955 /* State for object and array toSource conversion. */
956 JSSharpObjectMap sharpObjectMap;
957
958 /* Argument formatter support for JS_{Convert,Push}Arguments{,VA}. */
959 JSArgumentFormatMap *argumentFormatMap;
960
961 /* Last message string and trace file for debugging. */
962 char *lastMessage;
963 #ifdef DEBUG
964 void *tracefp;
965 jsbytecode *tracePrevPc;
966 #endif
967
968 /* Per-context optional error reporter. */
969 JSErrorReporter errorReporter;
970
971 /* Branch callback. */
972 JSOperationCallback operationCallback;
973
974 /* Interpreter activation count. */
975 uintN interpLevel;
976
977 /* Client opaque pointers. */
978 void *data;
979 void *data2;
980
981 /* GC and thread-safe state. */
982 JSStackFrame *dormantFrameChain; /* dormant stack frame to scan */
983 #ifdef JS_THREADSAFE
984 JSThread *thread;
985 jsrefcount requestDepth;
986 /* Same as requestDepth but ignoring JS_SuspendRequest/JS_ResumeRequest */
987 jsrefcount outstandingRequests;
988 JSTitle *lockedSealedTitle; /* weak ref, for low-cost sealed
989 title locking */
990 JSCList threadLinks; /* JSThread contextList linkage */
991
992 #define CX_FROM_THREAD_LINKS(tl) \
993 ((JSContext *)((char *)(tl) - offsetof(JSContext, threadLinks)))
994 #endif
995
996 /* PDL of stack headers describing stack slots not rooted by argv, etc. */
997 JSStackHeader *stackHeaders;
998
999 /* Optional stack of heap-allocated scoped local GC roots. */
1000 JSLocalRootStack *localRootStack;
1001
1002 /* Stack of thread-stack-allocated temporary GC roots. */
1003 JSTempValueRooter *tempValueRooters;
1004
1005 #ifdef JS_THREADSAFE
1006 JSGCFreeListSet *gcLocalFreeLists;
1007 #endif
1008
1009 /* List of pre-allocated doubles. */
1010 JSGCDoubleCell *doubleFreeList;
1011
1012 /* Debug hooks associated with the current context. */
1013 JSDebugHooks *debugHooks;
1014
1015 /* Security callbacks that override any defined on the runtime. */
1016 JSSecurityCallbacks *securityCallbacks;
1017
1018 /* Pinned regexp pool used for regular expressions. */
1019 JSArenaPool regexpPool;
1020
1021 /* Stored here to avoid passing it around as a parameter. */
1022 uintN resolveFlags;
1023
1024 #ifdef JS_TRACER
1025 /*
1026 * State for the current tree execution. bailExit is valid if the tree has
1027 * called back into native code via a _FAIL builtin and has not yet bailed,
1028 * else garbage (NULL in debug builds).
1029 */
1030 InterpState *interpState;
1031 VMSideExit *bailExit;
1032
1033 /* Used when calling natives from trace to root the vp vector. */
1034 uintN nativeVpLen;
1035 jsval *nativeVp;
1036 #endif
1037 };
1038
1039 #ifdef JS_THREADSAFE
1040 # define JS_THREAD_ID(cx) ((cx)->thread ? (cx)->thread->id : 0)
1041 #endif
1042
1043 #ifdef __cplusplus
1044
1045 static inline JSAtom **
1046 FrameAtomBase(JSContext *cx, JSStackFrame *fp)
1047 {
1048 return fp->imacpc
1049 ? COMMON_ATOMS_START(&cx->runtime->atomState)
1050 : fp->script->atomMap.vector;
1051 }
1052
1053 /* FIXME(bug 332648): Move this into a public header. */
1054 class JSAutoTempValueRooter
1055 {
1056 public:
1057 JSAutoTempValueRooter(JSContext *cx, size_t len, jsval *vec)
1058 : mContext(cx) {
1059 JS_PUSH_TEMP_ROOT(mContext, len, vec, &mTvr);
1060 }
1061 explicit JSAutoTempValueRooter(JSContext *cx, jsval v = JSVAL_NULL)
1062 : mContext(cx) {
1063 JS_PUSH_SINGLE_TEMP_ROOT(mContext, v, &mTvr);
1064 }
1065 JSAutoTempValueRooter(JSContext *cx, JSString *str)
1066 : mContext(cx) {
1067 JS_PUSH_TEMP_ROOT_STRING(mContext, str, &mTvr);
1068 }
1069 JSAutoTempValueRooter(JSContext *cx, JSObject *obj)
1070 : mContext(cx) {
1071 JS_PUSH_TEMP_ROOT_OBJECT(mContext, obj, &mTvr);
1072 }
1073
1074 ~JSAutoTempValueRooter() {
1075 JS_POP_TEMP_ROOT(mContext, &mTvr);
1076 }
1077
1078 jsval value() { return mTvr.u.value; }
1079 jsval *addr() { return &mTvr.u.value; }
1080
1081 protected:
1082 JSContext *mContext;
1083
1084 private:
1085 #ifndef AIX
1086 static void *operator new(size_t);
1087 static void operator delete(void *, size_t);
1088 #endif
1089
1090 JSTempValueRooter mTvr;
1091 };
1092
1093 class JSAutoTempIdRooter
1094 {
1095 public:
1096 explicit JSAutoTempIdRooter(JSContext *cx, jsid id = INT_TO_JSID(0))
1097 : mContext(cx) {
1098 JS_PUSH_SINGLE_TEMP_ROOT(mContext, ID_TO_VALUE(id), &mTvr);
1099 }
1100
1101 ~JSAutoTempIdRooter() {
1102 JS_POP_TEMP_ROOT(mContext, &mTvr);
1103 }
1104
1105 jsid id() { return (jsid) mTvr.u.value; }
1106 jsid * addr() { return (jsid *) &mTvr.u.value; }
1107
1108 private:
1109 JSContext *mContext;
1110 JSTempValueRooter mTvr;
1111 };
1112
1113 class JSAutoResolveFlags
1114 {
1115 public:
1116 JSAutoResolveFlags(JSContext *cx, uintN flags)
1117 : mContext(cx), mSaved(cx->resolveFlags) {
1118 cx->resolveFlags = flags;
1119 }
1120
1121 ~JSAutoResolveFlags() { mContext->resolveFlags = mSaved; }
1122
1123 private:
1124 JSContext *mContext;
1125 uintN mSaved;
1126 };
1127
1128 #endif /* __cpluscplus */
1129
1130 /*
1131 * Slightly more readable macros for testing per-context option settings (also
1132 * to hide bitset implementation detail).
1133 *
1134 * JSOPTION_XML must be handled specially in order to propagate from compile-
1135 * to run-time (from cx->options to script->version/cx->version). To do that,
1136 * we copy JSOPTION_XML from cx->options into cx->version as JSVERSION_HAS_XML
1137 * whenever options are set, and preserve this XML flag across version number
1138 * changes done via the JS_SetVersion API.
1139 *
1140 * But when executing a script or scripted function, the interpreter changes
1141 * cx->version, including the XML flag, to script->version. Thus JSOPTION_XML
1142 * is a compile-time option that causes a run-time version change during each
1143 * activation of the compiled script. That version change has the effect of
1144 * changing JS_HAS_XML_OPTION, so that any compiling done via eval enables XML
1145 * support. If an XML-enabled script or function calls a non-XML function,
1146 * the flag bit will be cleared during the callee's activation.
1147 *
1148 * Note that JS_SetVersion API calls never pass JSVERSION_HAS_XML or'd into
1149 * that API's version parameter.
1150 *
1151 * Note also that script->version must contain this XML option flag in order
1152 * for XDR'ed scripts to serialize and deserialize with that option preserved
1153 * for detection at run-time. We can't copy other compile-time options into
1154 * script->version because that would break backward compatibility (certain
1155 * other options, e.g. JSOPTION_VAROBJFIX, are analogous to JSOPTION_XML).
1156 */
1157 #define JS_HAS_OPTION(cx,option) (((cx)->options & (option)) != 0)
1158 #define JS_HAS_STRICT_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_STRICT)
1159 #define JS_HAS_WERROR_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_WERROR)
1160 #define JS_HAS_COMPILE_N_GO_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_COMPILE_N_GO)
1161 #define JS_HAS_ATLINE_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_ATLINE)
1162
1163 #define JSVERSION_MASK 0x0FFF /* see JSVersion in jspubtd.h */
1164 #define JSVERSION_HAS_XML 0x1000 /* flag induced by XML option */
1165 #define JSVERSION_ANONFUNFIX 0x2000 /* see jsapi.h, the comments
1166 for JSOPTION_ANONFUNFIX */
1167
1168 #define JSVERSION_NUMBER(cx) ((JSVersion)((cx)->version & \
1169 JSVERSION_MASK))
1170 #define JS_HAS_XML_OPTION(cx) ((cx)->version & JSVERSION_HAS_XML || \
1171 JSVERSION_NUMBER(cx) >= JSVERSION_1_6)
1172
1173 extern JSBool
1174 js_InitThreads(JSRuntime *rt);
1175
1176 extern void
1177 js_FinishThreads(JSRuntime *rt);
1178
1179 extern void
1180 js_PurgeThreads(JSContext *cx);
1181
1182 /*
1183 * Ensures the JSOPTION_XML and JSOPTION_ANONFUNFIX bits of cx->options are
1184 * reflected in cx->version, since each bit must travel with a script that has
1185 * it set.
1186 */
1187 extern void
1188 js_SyncOptionsToVersion(JSContext *cx);
1189
1190 /*
1191 * Common subroutine of JS_SetVersion and js_SetVersion, to update per-context
1192 * data that depends on version.
1193 */
1194 extern void
1195 js_OnVersionChange(JSContext *cx);
1196
1197 /*
1198 * Unlike the JS_SetVersion API, this function stores JSVERSION_HAS_XML and
1199 * any future non-version-number flags induced by compiler options.
1200 */
1201 extern void
1202 js_SetVersion(JSContext *cx, JSVersion version);
1203
1204 /*
1205 * Create and destroy functions for JSContext, which is manually allocated
1206 * and exclusively owned.
1207 */
1208 extern JSContext *
1209 js_NewContext(JSRuntime *rt, size_t stackChunkSize);
1210
1211 extern void
1212 js_DestroyContext(JSContext *cx, JSDestroyContextMode mode);
1213
1214 /*
1215 * Return true if cx points to a context in rt->contextList, else return false.
1216 * NB: the caller (see jslock.c:ClaimTitle) must hold rt->gcLock.
1217 */
1218 extern JSBool
1219 js_ValidContextPointer(JSRuntime *rt, JSContext *cx);
1220
1221 static JS_INLINE JSContext *
1222 js_ContextFromLinkField(JSCList *link)
1223 {
1224 JS_ASSERT(link);
1225 return (JSContext *) ((uint8 *) link - offsetof(JSContext, link));
1226 }
1227
1228 /*
1229 * If unlocked, acquire and release rt->gcLock around *iterp update; otherwise
1230 * the caller must be holding rt->gcLock.
1231 */
1232 extern JSContext *
1233 js_ContextIterator(JSRuntime *rt, JSBool unlocked, JSContext **iterp);
1234
1235 /*
1236 * Iterate through contexts with active requests. The caller must be holding
1237 * rt->gcLock in case of a thread-safe build, or otherwise guarantee that the
1238 * context list is not alternated asynchroniously.
1239 */
1240 extern JS_FRIEND_API(JSContext *)
1241 js_NextActiveContext(JSRuntime *, JSContext *);
1242
1243 #ifdef JS_THREADSAFE
1244
1245 /*
1246 * Count the number of contexts entered requests on the current thread.
1247 */
1248 uint32
1249 js_CountThreadRequests(JSContext *cx);
1250
1251 /*
1252 * This is a helper for code at can potentially run outside JS request to
1253 * ensure that the GC is not running when the function returns.
1254 *
1255 * This function must be called with the GC lock held.
1256 */
1257 extern void
1258 js_WaitForGC(JSRuntime *rt);
1259
1260 /*
1261 * If we're in one or more requests (possibly on more than one context)
1262 * running on the current thread, indicate, temporarily, that all these
1263 * requests are inactive so a possible GC can proceed on another thread.
1264 * This function returns the number of discounted requests. The number must
1265 * be passed later to js_ActivateRequestAfterGC to reactivate the requests.
1266 *
1267 * This function must be called with the GC lock held.
1268 */
1269 uint32
1270 js_DiscountRequestsForGC(JSContext *cx);
1271
1272 /*
1273 * This function must be called with the GC lock held.
1274 */
1275 void
1276 js_RecountRequestsAfterGC(JSRuntime *rt, uint32 requestDebit);
1277
1278 #else /* !JS_THREADSAFE */
1279
1280 # define js_WaitForGC(rt) ((void) 0)
1281
1282 #endif
1283
1284 /*
1285 * JSClass.resolve and watchpoint recursion damping machinery.
1286 */
1287 extern JSBool
1288 js_StartResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
1289 JSResolvingEntry **entryp);
1290
1291 extern void
1292 js_StopResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
1293 JSResolvingEntry *entry, uint32 generation);
1294
1295 /*
1296 * Local root set management.
1297 *
1298 * NB: the jsval parameters below may be properly tagged jsvals, or GC-thing
1299 * pointers cast to (jsval). This relies on JSObject's tag being zero, but
1300 * on the up side it lets us push int-jsval-encoded scopeMark values on the
1301 * local root stack.
1302 */
1303 extern JSBool
1304 js_EnterLocalRootScope(JSContext *cx);
1305
1306 #define js_LeaveLocalRootScope(cx) \
1307 js_LeaveLocalRootScopeWithResult(cx, JSVAL_NULL)
1308
1309 extern void
1310 js_LeaveLocalRootScopeWithResult(JSContext *cx, jsval rval);
1311
1312 extern void
1313 js_ForgetLocalRoot(JSContext *cx, jsval v);
1314
1315 extern int
1316 js_PushLocalRoot(JSContext *cx, JSLocalRootStack *lrs, jsval v);
1317
1318 extern void
1319 js_TraceLocalRoots(JSTracer *trc, JSLocalRootStack *lrs);
1320
1321 /*
1322 * Report an exception, which is currently realized as a printf-style format
1323 * string and its arguments.
1324 */
1325 typedef enum JSErrNum {
1326 #define MSG_DEF(name, number, count, exception, format) \
1327 name = number,
1328 #include "js.msg"
1329 #undef MSG_DEF
1330 JSErr_Limit
1331 } JSErrNum;
1332
1333 extern JS_FRIEND_API(const JSErrorFormatString *)
1334 js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber);
1335
1336 #ifdef va_start
1337 extern JSBool
1338 js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap);
1339
1340 extern JSBool
1341 js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback,
1342 void *userRef, const uintN errorNumber,
1343 JSBool charArgs, va_list ap);
1344
1345 extern JSBool
1346 js_ExpandErrorArguments(JSContext *cx, JSErrorCallback callback,
1347 void *userRef, const uintN errorNumber,
1348 char **message, JSErrorReport *reportp,
1349 JSBool *warningp, JSBool charArgs, va_list ap);
1350 #endif
1351
1352 extern void
1353 js_ReportOutOfMemory(JSContext *cx);
1354
1355 /*
1356 * Report that cx->scriptStackQuota is exhausted.
1357 */
1358 extern void
1359 js_ReportOutOfScriptQuota(JSContext *cx);
1360
1361 extern void
1362 js_ReportOverRecursed(JSContext *cx);
1363
1364 extern void
1365 js_ReportAllocationOverflow(JSContext *cx);
1366
1367 #define JS_CHECK_RECURSION(cx, onerror) \
1368 JS_BEGIN_MACRO \
1369 int stackDummy_; \
1370 \
1371 if (!JS_CHECK_STACK_SIZE(cx, stackDummy_)) { \
1372 js_ReportOverRecursed(cx); \
1373 onerror; \
1374 } \
1375 JS_END_MACRO
1376
1377 /*
1378 * Report an exception using a previously composed JSErrorReport.
1379 * XXXbe remove from "friend" API
1380 */
1381 extern JS_FRIEND_API(void)
1382 js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *report);
1383
1384 extern void
1385 js_ReportIsNotDefined(JSContext *cx, const char *name);
1386
1387 /*
1388 * Report an attempt to access the property of a null or undefined value (v).
1389 */
1390 extern JSBool
1391 js_ReportIsNullOrUndefined(JSContext *cx, intN spindex, jsval v,
1392 JSString *fallback);
1393
1394 extern void
1395 js_ReportMissingArg(JSContext *cx, jsval *vp, uintN arg);
1396
1397 /*
1398 * Report error using js_DecompileValueGenerator(cx, spindex, v, fallback) as
1399 * the first argument for the error message. If the error message has less
1400 * then 3 arguments, use null for arg1 or arg2.
1401 */
1402 extern JSBool
1403 js_ReportValueErrorFlags(JSContext *cx, uintN flags, const uintN errorNumber,
1404 intN spindex, jsval v, JSString *fallback,
1405 const char *arg1, const char *arg2);
1406
1407 #define js_ReportValueError(cx,errorNumber,spindex,v,fallback) \
1408 ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber, \
1409 spindex, v, fallback, NULL, NULL))
1410
1411 #define js_ReportValueError2(cx,errorNumber,spindex,v,fallback,arg1) \
1412 ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber, \
1413 spindex, v, fallback, arg1, NULL))
1414
1415 #define js_ReportValueError3(cx,errorNumber,spindex,v,fallback,arg1,arg2) \
1416 ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber, \
1417 spindex, v, fallback, arg1, arg2))
1418
1419 extern JSErrorFormatString js_ErrorFormatString[JSErr_Limit];
1420
1421 /*
1422 * See JS_SetThreadStackLimit in jsapi.c, where we check that the stack grows
1423 * in the expected direction. On Unix-y systems, JS_STACK_GROWTH_DIRECTION is
1424 * computed on the build host by jscpucfg.c and written into jsautocfg.h. The
1425 * macro is hardcoded in jscpucfg.h on Windows and Mac systems (for historical
1426 * reasons pre-dating autoconf usage).
1427 */
1428 #if JS_STACK_GROWTH_DIRECTION > 0
1429 # define JS_CHECK_STACK_SIZE(cx, lval) ((jsuword)&(lval) < (cx)->stackLimit)
1430 #else
1431 # define JS_CHECK_STACK_SIZE(cx, lval) ((jsuword)&(lval) > (cx)->stackLimit)
1432 #endif
1433
1434 /*
1435 * If the operation callback flag was set, call the operation callback.
1436 * This macro can run the full GC. Return true if it is OK to continue and
1437 * false otherwise.
1438 */
1439 #define JS_CHECK_OPERATION_LIMIT(cx) \
1440 (!(cx)->operationCallbackFlag || js_InvokeOperationCallback(cx))
1441
1442 /*
1443 * Invoke the operation callback and return false if the current execution
1444 * is to be terminated.
1445 */
1446 extern JSBool
1447 js_InvokeOperationCallback(JSContext *cx);
1448
1449 #ifndef JS_THREADSAFE
1450 # define js_TriggerAllOperationCallbacks(rt, gcLocked) \
1451 js_TriggerAllOperationCallbacks (rt)
1452 #endif
1453
1454 void
1455 js_TriggerAllOperationCallbacks(JSRuntime *rt, JSBool gcLocked);
1456
1457 extern JSStackFrame *
1458 js_GetScriptedCaller(JSContext *cx, JSStackFrame *fp);
1459
1460 extern jsbytecode*
1461 js_GetCurrentBytecodePC(JSContext* cx);
1462
1463 #ifdef JS_TRACER
1464 /*
1465 * Reconstruct the JS stack and clear cx->tracecx. We must be currently in a
1466 * _FAIL builtin from trace on cx or another context on the same thread. The
1467 * machine code for the trace remains on the C stack when js_DeepBail returns.
1468 *
1469 * Implemented in jstracer.cpp.
1470 */
1471 JS_FORCES_STACK JS_FRIEND_API(void)
1472 js_DeepBail(JSContext *cx);
1473 #endif
1474
1475 static JS_FORCES_STACK JS_INLINE void
1476 js_LeaveTrace(JSContext *cx)
1477 {
1478 #ifdef JS_TRACER
1479 if (JS_ON_TRACE(cx))
1480 js_DeepBail(cx);
1481 #endif
1482 }
1483
1484 static JS_INLINE void
1485 js_LeaveTraceIfGlobalObject(JSContext *cx, JSObject *obj)
1486 {
1487 if (!obj->fslots[JSSLOT_PARENT])
1488 js_LeaveTrace(cx);
1489 }
1490
1491 static JS_INLINE JSBool
1492 js_CanLeaveTrace(JSContext *cx)
1493 {
1494 JS_ASSERT(JS_ON_TRACE(cx));
1495 #ifdef JS_TRACER
1496 return cx->bailExit != NULL;
1497 #else
1498 return JS_FALSE;
1499 #endif
1500 }
1501
1502 /*
1503 * Get the current cx->fp, first lazily instantiating stack frames if needed.
1504 * (Do not access cx->fp directly except in JS_REQUIRES_STACK code.)
1505 *
1506 * Defined in jstracer.cpp if JS_TRACER is defined.
1507 */
1508 static JS_FORCES_STACK JS_INLINE JSStackFrame *
1509 js_GetTopStackFrame(JSContext *cx)
1510 {
1511 js_LeaveTrace(cx);
1512 return cx->fp;
1513 }
1514
1515 static JS_INLINE JSBool
1516 js_IsPropertyCacheDisabled(JSContext *cx)
1517 {
1518 return cx->runtime->shapeGen >= SHAPE_OVERFLOW_BIT;
1519 }
1520
1521 static JS_INLINE uint32
1522 js_RegenerateShapeForGC(JSContext *cx)
1523 {
1524 uint32 shape;
1525
1526 JS_ASSERT(cx->runtime->gcRunning);
1527
1528 /*
1529 * Under the GC, compared with js_GenerateShape, we don't need to use
1530 * atomic increments but we still must make sure that after an overflow
1531 * the shape stays such.
1532 */
1533 shape = cx->runtime->shapeGen;
1534 shape = (shape + 1) | (shape & SHAPE_OVERFLOW_BIT);
1535 cx->runtime->shapeGen = shape;
1536 return shape;
1537 }
1538
1539 JS_END_EXTERN_C
1540
1541 #endif /* jscntxt_h___ */

  ViewVC Help
Powered by ViewVC 1.1.24