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

Contents of /trunk/js/jscntxt.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 399 - (show annotations)
Tue Dec 9 03:37:47 2008 UTC (11 years, 1 month ago) by siliconforks
File MIME type: text/plain
File size: 45545 byte(s)
Use SpiderMonkey from Firefox 3.1b2.

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 clears;
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 GSN_CACHE_CLEAR(cache) \
83 JS_BEGIN_MACRO \
84 (cache)->code = NULL; \
85 if ((cache)->table.ops) { \
86 JS_DHashTableFinish(&(cache)->table); \
87 (cache)->table.ops = NULL; \
88 } \
89 GSN_CACHE_METER(cache, clears); \
90 JS_END_MACRO
91
92 /* These helper macros take a cx as parameter and operate on its GSN cache. */
93 #define JS_CLEAR_GSN_CACHE(cx) GSN_CACHE_CLEAR(&JS_GSN_CACHE(cx))
94 #define JS_METER_GSN_CACHE(cx,cnt) GSN_CACHE_METER(&JS_GSN_CACHE(cx), cnt)
95
96 #ifdef __cplusplus
97 namespace nanojit {
98 class Fragment;
99 class Fragmento;
100 }
101 class TraceRecorder;
102 extern "C++" { template<typename T> class Queue; }
103 typedef Queue<uint16> SlotList;
104 class TypeMap;
105
106 # define CLS(T) T*
107 #else
108 # define CLS(T) void*
109 #endif
110
111 /*
112 * Trace monitor. Every JSThread (if JS_THREADSAFE) or JSRuntime (if not
113 * JS_THREADSAFE) has an associated trace monitor that keeps track of loop
114 * frequencies for all JavaScript code loaded into that runtime.
115 */
116 typedef struct JSTraceMonitor {
117 /*
118 * Flag set when running (or recording) JIT-compiled code. This prevents
119 * both interpreter activation and last-ditch garbage collection when up
120 * against our runtime's memory limits. This flag also suppresses calls to
121 * JS_ReportOutOfMemory when failing due to runtime limits.
122 */
123 JSBool onTrace;
124 CLS(nanojit::Fragmento) fragmento;
125 CLS(TraceRecorder) recorder;
126 uint32 globalShape;
127 CLS(SlotList) globalSlots;
128 CLS(TypeMap) globalTypeMap;
129 jsval *recoveryDoublePool;
130 jsval *recoveryDoublePoolPtr;
131
132 /* Fragmento for the regular expression compiler. This is logically
133 * a distinct compiler but needs to be managed in exactly the same
134 * way as the real tracing Fragmento. */
135 CLS(nanojit::Fragmento) reFragmento;
136
137 /* Keep a list of recorders we need to abort on cache flush. */
138 CLS(TraceRecorder) abortStack;
139 } JSTraceMonitor;
140
141 #ifdef JS_TRACER
142 # define JS_ON_TRACE(cx) (JS_TRACE_MONITOR(cx).onTrace)
143 #else
144 # define JS_ON_TRACE(cx) JS_FALSE
145 #endif
146
147 #ifdef JS_THREADSAFE
148
149 /*
150 * Structure uniquely representing a thread. It holds thread-private data
151 * that can be accessed without a global lock.
152 */
153 struct JSThread {
154 /* Linked list of all contexts active on this thread. */
155 JSCList contextList;
156
157 /* Opaque thread-id, from NSPR's PR_GetCurrentThread(). */
158 jsword id;
159
160 /*
161 * Thread-local version of JSRuntime.gcMallocBytes to avoid taking
162 * locks on each JS_malloc.
163 */
164 uint32 gcMallocBytes;
165
166 /*
167 * Store the GSN cache in struct JSThread, not struct JSContext, both to
168 * save space and to simplify cleanup in js_GC. Any embedding (Firefox
169 * or another Gecko application) that uses many contexts per thread is
170 * unlikely to interleave js_GetSrcNote-intensive loops in the decompiler
171 * among two or more contexts running script in one thread.
172 */
173 JSGSNCache gsnCache;
174
175 /* Property cache for faster call/get/set invocation. */
176 JSPropertyCache propertyCache;
177
178 /* Trace-tree JIT recorder/interpreter state. */
179 JSTraceMonitor traceMonitor;
180
181 /* Lock-free list of scripts created by eval to garbage-collect. */
182 JSScript *scriptsToGC;
183 };
184
185 #define JS_GSN_CACHE(cx) ((cx)->thread->gsnCache)
186 #define JS_PROPERTY_CACHE(cx) ((cx)->thread->propertyCache)
187 #define JS_TRACE_MONITOR(cx) ((cx)->thread->traceMonitor)
188 #define JS_SCRIPTS_TO_GC(cx) ((cx)->thread->scriptsToGC)
189
190 extern void
191 js_ThreadDestructorCB(void *ptr);
192
193 extern JSBool
194 js_SetContextThread(JSContext *cx);
195
196 extern void
197 js_ClearContextThread(JSContext *cx);
198
199 extern JSThread *
200 js_GetCurrentThread(JSRuntime *rt);
201
202 #endif /* JS_THREADSAFE */
203
204 typedef enum JSDestroyContextMode {
205 JSDCM_NO_GC,
206 JSDCM_MAYBE_GC,
207 JSDCM_FORCE_GC,
208 JSDCM_NEW_FAILED
209 } JSDestroyContextMode;
210
211 typedef enum JSRuntimeState {
212 JSRTS_DOWN,
213 JSRTS_LAUNCHING,
214 JSRTS_UP,
215 JSRTS_LANDING
216 } JSRuntimeState;
217
218 typedef struct JSPropertyTreeEntry {
219 JSDHashEntryHdr hdr;
220 JSScopeProperty *child;
221 } JSPropertyTreeEntry;
222
223 typedef struct JSSetSlotRequest JSSetSlotRequest;
224
225 struct JSSetSlotRequest {
226 JSObject *obj; /* object containing slot to set */
227 JSObject *pobj; /* new proto or parent reference */
228 uint16 slot; /* which to set, proto or parent */
229 uint16 errnum; /* JSMSG_NO_ERROR or error result */
230 JSSetSlotRequest *next; /* next request in GC worklist */
231 };
232
233 struct JSRuntime {
234 /* Runtime state, synchronized by the stateChange/gcLock condvar/lock. */
235 JSRuntimeState state;
236
237 /* Context create/destroy callback. */
238 JSContextCallback cxCallback;
239
240 /* Garbage collector state, used by jsgc.c. */
241 JSGCChunkInfo *gcChunkList;
242 JSGCArenaList gcArenaList[GC_NUM_FREELISTS];
243 JSGCDoubleArenaList gcDoubleArenaList;
244 JSGCFreeListSet *gcFreeListsPool;
245 JSDHashTable gcRootsHash;
246 JSDHashTable *gcLocksHash;
247 jsrefcount gcKeepAtoms;
248 uint32 gcBytes;
249 uint32 gcLastBytes;
250 uint32 gcMaxBytes;
251 uint32 gcMaxMallocBytes;
252 uint32 gcEmptyArenaPoolLifespan;
253 uint32 gcLevel;
254 uint32 gcNumber;
255 JSTracer *gcMarkingTracer;
256
257 /*
258 * NB: do not pack another flag here by claiming gcPadding unless the new
259 * flag is written only by the GC thread. Atomic updates to packed bytes
260 * are not guaranteed, so stores issued by one thread may be lost due to
261 * unsynchronized read-modify-write cycles on other threads.
262 */
263 JSPackedBool gcPoke;
264 JSPackedBool gcRunning;
265 uint16 gcPadding;
266 #ifdef JS_GC_ZEAL
267 jsrefcount gcZeal;
268 #endif
269
270 JSGCCallback gcCallback;
271 uint32 gcMallocBytes;
272 JSGCArenaInfo *gcUntracedArenaStackTop;
273 #ifdef DEBUG
274 size_t gcTraceLaterCount;
275 #endif
276
277 /*
278 * Table for tracking iterators to ensure that we close iterator's state
279 * before finalizing the iterable object.
280 */
281 JSPtrTable gcIteratorTable;
282
283 /*
284 * The trace operation and its data argument to trace embedding-specific
285 * GC roots.
286 */
287 JSTraceDataOp gcExtraRootsTraceOp;
288 void *gcExtraRootsData;
289
290 /*
291 * Used to serialize cycle checks when setting __proto__ or __parent__ by
292 * requesting the GC handle the required cycle detection. If the GC hasn't
293 * been poked, it won't scan for garbage. This member is protected by
294 * rt->gcLock.
295 */
296 JSSetSlotRequest *setSlotRequests;
297
298 /* Random number generator state, used by jsmath.c. */
299 JSBool rngInitialized;
300 int64 rngMultiplier;
301 int64 rngAddend;
302 int64 rngMask;
303 int64 rngSeed;
304 jsdouble rngDscale;
305
306 /* Well-known numbers held for use by this runtime's contexts. */
307 jsdouble *jsNaN;
308 jsdouble *jsNegativeInfinity;
309 jsdouble *jsPositiveInfinity;
310
311 #ifdef JS_THREADSAFE
312 JSLock *deflatedStringCacheLock;
313 #endif
314 JSHashTable *deflatedStringCache;
315 #ifdef DEBUG
316 uint32 deflatedStringCacheBytes;
317 #endif
318
319 /*
320 * Empty and unit-length strings held for use by this runtime's contexts.
321 * The unitStrings array and its elements are created on demand.
322 */
323 JSString *emptyString;
324 JSString **unitStrings;
325
326 /* List of active contexts sharing this runtime; protected by gcLock. */
327 JSCList contextList;
328
329 /* Per runtime debug hooks -- see jsprvtd.h and jsdbgapi.h. */
330 JSDebugHooks globalDebugHooks;
331
332 /* More debugging state, see jsdbgapi.c. */
333 JSCList trapList;
334 JSCList watchPointList;
335
336 /* Client opaque pointers */
337 void *data;
338
339 #ifdef JS_THREADSAFE
340 /* These combine to interlock the GC and new requests. */
341 PRLock *gcLock;
342 PRCondVar *gcDone;
343 PRCondVar *requestDone;
344 uint32 requestCount;
345 JSThread *gcThread;
346
347 /* Lock and owning thread pointer for JS_LOCK_RUNTIME. */
348 PRLock *rtLock;
349 #ifdef DEBUG
350 jsword rtLockOwner;
351 #endif
352
353 /* Used to synchronize down/up state change; protected by gcLock. */
354 PRCondVar *stateChange;
355
356 /*
357 * State for sharing single-threaded titles, once a second thread tries to
358 * lock a title. The titleSharingDone condvar is protected by rt->gcLock
359 * to minimize number of locks taken in JS_EndRequest.
360 *
361 * The titleSharingTodo linked list is likewise "global" per runtime, not
362 * one-list-per-context, to conserve space over all contexts, optimizing
363 * for the likely case that titles become shared rarely, and among a very
364 * small set of threads (contexts).
365 */
366 PRCondVar *titleSharingDone;
367 JSTitle *titleSharingTodo;
368
369 /*
370 * Magic terminator for the rt->titleSharingTodo linked list, threaded through
371 * title->u.link. This hack allows us to test whether a title is on the list
372 * by asking whether title->u.link is non-null. We use a large, likely bogus
373 * pointer here to distinguish this value from any valid u.count (small int)
374 * value.
375 */
376 #define NO_TITLE_SHARING_TODO ((JSTitle *) 0xfeedbeef)
377
378 /*
379 * Lock serializing trapList and watchPointList accesses, and count of all
380 * mutations to trapList and watchPointList made by debugger threads. To
381 * keep the code simple, we define debuggerMutations for the thread-unsafe
382 * case too.
383 */
384 PRLock *debuggerLock;
385 #endif /* JS_THREADSAFE */
386 uint32 debuggerMutations;
387
388 /*
389 * Security callbacks set on the runtime are used by each context unless
390 * an override is set on the context.
391 */
392 JSSecurityCallbacks *securityCallbacks;
393
394 /*
395 * Shared scope property tree, and arena-pool for allocating its nodes.
396 * The propertyRemovals counter is incremented for every js_ClearScope,
397 * and for each js_RemoveScopeProperty that frees a slot in an object.
398 * See js_NativeGet and js_NativeSet in jsobj.c.
399 */
400 JSDHashTable propertyTreeHash;
401 JSScopeProperty *propertyFreeList;
402 JSArenaPool propertyArenaPool;
403 int32 propertyRemovals;
404
405 /* Script filename table. */
406 struct JSHashTable *scriptFilenameTable;
407 JSCList scriptFilenamePrefixes;
408 #ifdef JS_THREADSAFE
409 PRLock *scriptFilenameTableLock;
410 #endif
411
412 /* Number localization, used by jsnum.c */
413 const char *thousandsSeparator;
414 const char *decimalSeparator;
415 const char *numGrouping;
416
417 /*
418 * Weak references to lazily-created, well-known XML singletons.
419 *
420 * NB: Singleton objects must be carefully disconnected from the rest of
421 * the object graph usually associated with a JSContext's global object,
422 * including the set of standard class objects. See jsxml.c for details.
423 */
424 JSObject *anynameObject;
425 JSObject *functionNamespaceObject;
426
427 /*
428 * A helper list for the GC, so it can mark native iterator states. See
429 * js_TraceNativeEnumerators for details.
430 */
431 JSNativeEnumerator *nativeEnumerators;
432
433 #ifndef JS_THREADSAFE
434 /*
435 * For thread-unsafe embeddings, the GSN cache lives in the runtime and
436 * not each context, since we expect it to be filled once when decompiling
437 * a longer script, then hit repeatedly as js_GetSrcNote is called during
438 * the decompiler activation that filled it.
439 */
440 JSGSNCache gsnCache;
441
442 /* Property cache for faster call/get/set invocation. */
443 JSPropertyCache propertyCache;
444
445 /* Trace-tree JIT recorder/interpreter state. */
446 JSTraceMonitor traceMonitor;
447
448 /* Lock-free list of scripts created by eval to garbage-collect. */
449 JSScript *scriptsToGC;
450
451 #define JS_GSN_CACHE(cx) ((cx)->runtime->gsnCache)
452 #define JS_PROPERTY_CACHE(cx) ((cx)->runtime->propertyCache)
453 #define JS_TRACE_MONITOR(cx) ((cx)->runtime->traceMonitor)
454 #define JS_SCRIPTS_TO_GC(cx) ((cx)->runtime->scriptsToGC)
455 #endif
456
457 /*
458 * Object shape (property cache structural type) identifier generator.
459 *
460 * Type 0 stands for the empty scope, and must not be regenerated due to
461 * uint32 wrap-around. Since we use atomic pre-increment, the initial
462 * value for the first typed non-empty scope will be 1.
463 *
464 * The GC compresses live types, minimizing rt->shapeGen in the process.
465 * If this counter overflows into SHAPE_OVERFLOW_BIT (in jsinterp.h), the
466 * GC will disable property caches for all threads, to avoid aliasing two
467 * different types. Updated by js_GenerateShape (in jsinterp.c).
468 */
469 uint32 shapeGen;
470
471 /* Literal table maintained by jsatom.c functions. */
472 JSAtomState atomState;
473
474 /*
475 * Cache of reusable JSNativeEnumerators mapped by shape identifiers (as
476 * stored in scope->shape). This cache is nulled by the GC and protected
477 * by gcLock.
478 */
479 #define NATIVE_ENUM_CACHE_LOG2 8
480 #define NATIVE_ENUM_CACHE_MASK JS_BITMASK(NATIVE_ENUM_CACHE_LOG2)
481 #define NATIVE_ENUM_CACHE_SIZE JS_BIT(NATIVE_ENUM_CACHE_LOG2)
482
483 #define NATIVE_ENUM_CACHE_HASH(shape) \
484 ((((shape) >> NATIVE_ENUM_CACHE_LOG2) ^ (shape)) & NATIVE_ENUM_CACHE_MASK)
485
486 jsuword nativeEnumCache[NATIVE_ENUM_CACHE_SIZE];
487
488 /*
489 * Runtime-wide flag set to true when any Array prototype has an indexed
490 * property defined on it, creating a hazard for code reading or writing
491 * over a hole from a dense Array instance that is not prepared to look up
492 * the proto chain (the writing case must involve a check for a read-only
493 * element, which cannot be shadowed).
494 */
495 JSBool anyArrayProtoHasElement;
496
497 /*
498 * Various metering fields are defined at the end of JSRuntime. In this
499 * way there is no need to recompile all the code that refers to other
500 * fields of JSRuntime after enabling the corresponding metering macro.
501 */
502 #ifdef JS_DUMP_ENUM_CACHE_STATS
503 int32 nativeEnumProbes;
504 int32 nativeEnumMisses;
505 # define ENUM_CACHE_METER(name) JS_ATOMIC_INCREMENT(&cx->runtime->name)
506 #else
507 # define ENUM_CACHE_METER(name) ((void) 0)
508 #endif
509
510 #ifdef JS_DUMP_LOOP_STATS
511 /* Loop statistics, to trigger trace recording and compiling. */
512 JSBasicStats loopStats;
513 #endif
514
515 #if defined DEBUG || defined JS_DUMP_PROPTREE_STATS
516 /* Function invocation metering. */
517 jsrefcount inlineCalls;
518 jsrefcount nativeCalls;
519 jsrefcount nonInlineCalls;
520 jsrefcount constructs;
521
522 /* Title lock and scope property metering. */
523 jsrefcount claimAttempts;
524 jsrefcount claimedTitles;
525 jsrefcount deadContexts;
526 jsrefcount deadlocksAvoided;
527 jsrefcount liveScopes;
528 jsrefcount sharedTitles;
529 jsrefcount totalScopes;
530 jsrefcount liveScopeProps;
531 jsrefcount liveScopePropsPreSweep;
532 jsrefcount totalScopeProps;
533 jsrefcount livePropTreeNodes;
534 jsrefcount duplicatePropTreeNodes;
535 jsrefcount totalPropTreeNodes;
536 jsrefcount propTreeKidsChunks;
537 jsrefcount middleDeleteFixups;
538
539 /* String instrumentation. */
540 jsrefcount liveStrings;
541 jsrefcount totalStrings;
542 jsrefcount liveDependentStrings;
543 jsrefcount totalDependentStrings;
544 jsrefcount badUndependStrings;
545 double lengthSum;
546 double lengthSquaredSum;
547 double strdepLengthSum;
548 double strdepLengthSquaredSum;
549 #endif /* DEBUG || JS_DUMP_PROPTREE_STATS */
550
551 #ifdef JS_SCOPE_DEPTH_METER
552 /*
553 * Stats on runtime prototype chain lookups and scope chain depths, i.e.,
554 * counts of objects traversed on a chain until the wanted id is found.
555 */
556 JSBasicStats protoLookupDepthStats;
557 JSBasicStats scopeSearchDepthStats;
558
559 /*
560 * Stats on compile-time host environment and lexical scope chain lengths
561 * (maximum depths).
562 */
563 JSBasicStats hostenvScopeDepthStats;
564 JSBasicStats lexicalScopeDepthStats;
565 #endif
566
567 #ifdef JS_GCMETER
568 JSGCStats gcStats;
569 #endif
570 };
571
572 #ifdef DEBUG
573 # define JS_RUNTIME_METER(rt, which) JS_ATOMIC_INCREMENT(&(rt)->which)
574 # define JS_RUNTIME_UNMETER(rt, which) JS_ATOMIC_DECREMENT(&(rt)->which)
575 #else
576 # define JS_RUNTIME_METER(rt, which) /* nothing */
577 # define JS_RUNTIME_UNMETER(rt, which) /* nothing */
578 #endif
579
580 #define JS_KEEP_ATOMS(rt) JS_ATOMIC_INCREMENT(&(rt)->gcKeepAtoms);
581 #define JS_UNKEEP_ATOMS(rt) JS_ATOMIC_DECREMENT(&(rt)->gcKeepAtoms);
582
583 #ifdef JS_ARGUMENT_FORMATTER_DEFINED
584 /*
585 * Linked list mapping format strings for JS_{Convert,Push}Arguments{,VA} to
586 * formatter functions. Elements are sorted in non-increasing format string
587 * length order.
588 */
589 struct JSArgumentFormatMap {
590 const char *format;
591 size_t length;
592 JSArgumentFormatter formatter;
593 JSArgumentFormatMap *next;
594 };
595 #endif
596
597 struct JSStackHeader {
598 uintN nslots;
599 JSStackHeader *down;
600 };
601
602 #define JS_STACK_SEGMENT(sh) ((jsval *)(sh) + 2)
603
604 /*
605 * Key and entry types for the JSContext.resolvingTable hash table, typedef'd
606 * here because all consumers need to see these declarations (and not just the
607 * typedef names, as would be the case for an opaque pointer-to-typedef'd-type
608 * declaration), along with cx->resolvingTable.
609 */
610 typedef struct JSResolvingKey {
611 JSObject *obj;
612 jsid id;
613 } JSResolvingKey;
614
615 typedef struct JSResolvingEntry {
616 JSDHashEntryHdr hdr;
617 JSResolvingKey key;
618 uint32 flags;
619 } JSResolvingEntry;
620
621 #define JSRESFLAG_LOOKUP 0x1 /* resolving id from lookup */
622 #define JSRESFLAG_WATCH 0x2 /* resolving id from watch */
623
624 typedef struct JSLocalRootChunk JSLocalRootChunk;
625
626 #define JSLRS_CHUNK_SHIFT 8
627 #define JSLRS_CHUNK_SIZE JS_BIT(JSLRS_CHUNK_SHIFT)
628 #define JSLRS_CHUNK_MASK JS_BITMASK(JSLRS_CHUNK_SHIFT)
629
630 struct JSLocalRootChunk {
631 jsval roots[JSLRS_CHUNK_SIZE];
632 JSLocalRootChunk *down;
633 };
634
635 typedef struct JSLocalRootStack {
636 uint32 scopeMark;
637 uint32 rootCount;
638 JSLocalRootChunk *topChunk;
639 JSLocalRootChunk firstChunk;
640 } JSLocalRootStack;
641
642 #define JSLRS_NULL_MARK ((uint32) -1)
643
644 /*
645 * Macros to push/pop JSTempValueRooter instances to context-linked stack of
646 * temporary GC roots. If you need to protect a result value that flows out of
647 * a C function across several layers of other functions, use the
648 * js_LeaveLocalRootScopeWithResult internal API (see further below) instead.
649 *
650 * The macros also provide a simple way to get a single rooted pointer via
651 * JS_PUSH_TEMP_ROOT_<KIND>(cx, NULL, &tvr). Then &tvr.u.<kind> gives the
652 * necessary pointer.
653 *
654 * JSTempValueRooter.count defines the type of the rooted value referenced by
655 * JSTempValueRooter.u union of type JSTempValueUnion. When count is positive
656 * or zero, u.array points to a vector of jsvals. Otherwise it must be one of
657 * the following constants:
658 */
659 #define JSTVU_SINGLE (-1) /* u.value or u.<gcthing> is single jsval
660 or GC-thing */
661 #define JSTVU_TRACE (-2) /* u.trace is a hook to trace a custom
662 * structure */
663 #define JSTVU_SPROP (-3) /* u.sprop roots property tree node */
664 #define JSTVU_WEAK_ROOTS (-4) /* u.weakRoots points to saved weak roots */
665 #define JSTVU_PARSE_CONTEXT (-5) /* u.parseContext roots JSParseContext* */
666 #define JSTVU_SCRIPT (-6) /* u.script roots JSScript* */
667
668 /*
669 * Here single JSTVU_SINGLE covers both jsval and pointers to any GC-thing via
670 * reinterpreting the thing as JSVAL_OBJECT. It works because the GC-thing is
671 * aligned on a 0 mod 8 boundary, and object has the 0 jsval tag. So any
672 * GC-thing may be tagged as if it were an object and untagged, if it's then
673 * used only as an opaque pointer until discriminated by other means than tag
674 * bits. This is how, for example, js_GetGCThingTraceKind uses its |thing|
675 * parameter -- it consults GC-thing flags stored separately from the thing to
676 * decide the kind of thing.
677 *
678 * The following checks that this type-punning is possible.
679 */
680 JS_STATIC_ASSERT(sizeof(JSTempValueUnion) == sizeof(jsval));
681 JS_STATIC_ASSERT(sizeof(JSTempValueUnion) == sizeof(void *));
682
683 #define JS_PUSH_TEMP_ROOT_COMMON(cx,x,tvr,cnt,kind) \
684 JS_BEGIN_MACRO \
685 JS_ASSERT((cx)->tempValueRooters != (tvr)); \
686 (tvr)->count = (cnt); \
687 (tvr)->u.kind = (x); \
688 (tvr)->down = (cx)->tempValueRooters; \
689 (cx)->tempValueRooters = (tvr); \
690 JS_END_MACRO
691
692 #define JS_POP_TEMP_ROOT(cx,tvr) \
693 JS_BEGIN_MACRO \
694 JS_ASSERT((cx)->tempValueRooters == (tvr)); \
695 (cx)->tempValueRooters = (tvr)->down; \
696 JS_END_MACRO
697
698 #define JS_PUSH_TEMP_ROOT(cx,cnt,arr,tvr) \
699 JS_BEGIN_MACRO \
700 JS_ASSERT((int)(cnt) >= 0); \
701 JS_PUSH_TEMP_ROOT_COMMON(cx, arr, tvr, (ptrdiff_t) (cnt), array); \
702 JS_END_MACRO
703
704 #define JS_PUSH_SINGLE_TEMP_ROOT(cx,val,tvr) \
705 JS_PUSH_TEMP_ROOT_COMMON(cx, val, tvr, JSTVU_SINGLE, value)
706
707 #define JS_PUSH_TEMP_ROOT_OBJECT(cx,obj,tvr) \
708 JS_PUSH_TEMP_ROOT_COMMON(cx, obj, tvr, JSTVU_SINGLE, object)
709
710 #define JS_PUSH_TEMP_ROOT_STRING(cx,str,tvr) \
711 JS_PUSH_TEMP_ROOT_COMMON(cx, str, tvr, JSTVU_SINGLE, string)
712
713 #define JS_PUSH_TEMP_ROOT_XML(cx,xml_,tvr) \
714 JS_PUSH_TEMP_ROOT_COMMON(cx, xml_, tvr, JSTVU_SINGLE, xml)
715
716 #define JS_PUSH_TEMP_ROOT_TRACE(cx,trace_,tvr) \
717 JS_PUSH_TEMP_ROOT_COMMON(cx, trace_, tvr, JSTVU_TRACE, trace)
718
719 #define JS_PUSH_TEMP_ROOT_SPROP(cx,sprop_,tvr) \
720 JS_PUSH_TEMP_ROOT_COMMON(cx, sprop_, tvr, JSTVU_SPROP, sprop)
721
722 #define JS_PUSH_TEMP_ROOT_WEAK_COPY(cx,weakRoots_,tvr) \
723 JS_PUSH_TEMP_ROOT_COMMON(cx, weakRoots_, tvr, JSTVU_WEAK_ROOTS, weakRoots)
724
725 #define JS_PUSH_TEMP_ROOT_PARSE_CONTEXT(cx,pc,tvr) \
726 JS_PUSH_TEMP_ROOT_COMMON(cx, pc, tvr, JSTVU_PARSE_CONTEXT, parseContext)
727
728 #define JS_PUSH_TEMP_ROOT_SCRIPT(cx,script_,tvr) \
729 JS_PUSH_TEMP_ROOT_COMMON(cx, script_, tvr, JSTVU_SCRIPT, script)
730
731
732 #define JSRESOLVE_INFER 0xffff /* infer bits from current bytecode */
733
734 struct JSContext {
735 /* JSRuntime contextList linkage. */
736 JSCList links;
737
738 /*
739 * Operation count. It is declared early in the structure as a frequently
740 * accessed field.
741 */
742 int32 operationCount;
743
744 #if JS_HAS_XML_SUPPORT
745 /*
746 * Bit-set formed from binary exponentials of the XML_* tiny-ids defined
747 * for boolean settings in jsxml.c, plus an XSF_CACHE_VALID bit. Together
748 * these act as a cache of the boolean XML.ignore* and XML.prettyPrinting
749 * property values associated with this context's global object.
750 */
751 uint8 xmlSettingFlags;
752 uint8 padding;
753 #else
754 uint16 padding;
755 #endif
756
757 /*
758 * Classic Algol "display" static link optimization.
759 */
760 #define JS_DISPLAY_SIZE 16
761
762 JSStackFrame *display[JS_DISPLAY_SIZE];
763
764 /* Runtime version control identifier. */
765 uint16 version;
766
767 /* Per-context options. */
768 uint32 options; /* see jsapi.h for JSOPTION_* */
769
770 /* Locale specific callbacks for string conversion. */
771 JSLocaleCallbacks *localeCallbacks;
772
773 /*
774 * cx->resolvingTable is non-null and non-empty if we are initializing
775 * standard classes lazily, or if we are otherwise recursing indirectly
776 * from js_LookupProperty through a JSClass.resolve hook. It is used to
777 * limit runaway recursion (see jsapi.c and jsobj.c).
778 */
779 JSDHashTable *resolvingTable;
780
781 #if JS_HAS_LVALUE_RETURN
782 /*
783 * Secondary return value from native method called on the left-hand side
784 * of an assignment operator. The native should store the object in which
785 * to set a property in *rval, and return the property's id expressed as a
786 * jsval by calling JS_SetCallReturnValue2(cx, idval).
787 */
788 jsval rval2;
789 JSPackedBool rval2set;
790 #endif
791
792 /*
793 * True if generating an error, to prevent runaway recursion.
794 * NB: generatingError packs with rval2set, #if JS_HAS_LVALUE_RETURN;
795 * with insideGCMarkCallback and with throwing below.
796 */
797 JSPackedBool generatingError;
798
799 /* Flag to indicate that we run inside gcCallback(cx, JSGC_MARK_END). */
800 JSPackedBool insideGCMarkCallback;
801
802 /* Exception state -- the exception member is a GC root by definition. */
803 JSPackedBool throwing; /* is there a pending exception? */
804 jsval exception; /* most-recently-thrown exception */
805
806 /* Limit pointer for checking native stack consumption during recursion. */
807 jsuword stackLimit;
808
809 /* Quota on the size of arenas used to compile and execute scripts. */
810 size_t scriptStackQuota;
811
812 /* Data shared by threads in an address space. */
813 JSRuntime *runtime;
814
815 /* Stack arena pool and frame pointer register. */
816 JSArenaPool stackPool;
817 JSStackFrame *fp;
818
819 /* Temporary arena pool used while compiling and decompiling. */
820 JSArenaPool tempPool;
821
822 /* Top-level object and pointer to top stack frame's scope chain. */
823 JSObject *globalObject;
824
825 /* Storage to root recently allocated GC things and script result. */
826 JSWeakRoots weakRoots;
827
828 /* Regular expression class statics (XXX not shared globally). */
829 JSRegExpStatics regExpStatics;
830
831 /* State for object and array toSource conversion. */
832 JSSharpObjectMap sharpObjectMap;
833
834 /* Argument formatter support for JS_{Convert,Push}Arguments{,VA}. */
835 JSArgumentFormatMap *argumentFormatMap;
836
837 /* Last message string and trace file for debugging. */
838 char *lastMessage;
839 #ifdef DEBUG
840 void *tracefp;
841 #endif
842
843 /* Per-context optional error reporter. */
844 JSErrorReporter errorReporter;
845
846 /*
847 * Flag indicating that the operation callback is set. When the flag is 0
848 * but operationCallback is not null, operationCallback stores the branch
849 * callback.
850 */
851 uint32 operationCallbackIsSet : 1;
852 uint32 operationLimit : 31;
853 JSOperationCallback operationCallback;
854
855 /* Interpreter activation count. */
856 uintN interpLevel;
857
858 /* Client opaque pointers. */
859 void *data;
860 void *data2;
861
862 /* GC and thread-safe state. */
863 JSStackFrame *dormantFrameChain; /* dormant stack frame to scan */
864 #ifdef JS_THREADSAFE
865 JSThread *thread;
866 jsrefcount requestDepth;
867 /* Same as requestDepth but ignoring JS_SuspendRequest/JS_ResumeRequest */
868 jsrefcount outstandingRequests;
869 JSTitle *titleToShare; /* weak reference, see jslock.c */
870 JSTitle *lockedSealedTitle; /* weak ref, for low-cost sealed
871 title locking */
872 JSCList threadLinks; /* JSThread contextList linkage */
873
874 #define CX_FROM_THREAD_LINKS(tl) \
875 ((JSContext *)((char *)(tl) - offsetof(JSContext, threadLinks)))
876 #endif
877
878 /* PDL of stack headers describing stack slots not rooted by argv, etc. */
879 JSStackHeader *stackHeaders;
880
881 /* Optional stack of heap-allocated scoped local GC roots. */
882 JSLocalRootStack *localRootStack;
883
884 /* Stack of thread-stack-allocated temporary GC roots. */
885 JSTempValueRooter *tempValueRooters;
886
887 #ifdef JS_THREADSAFE
888 JSGCFreeListSet *gcLocalFreeLists;
889 #endif
890
891 /* List of pre-allocated doubles. */
892 JSGCDoubleCell *doubleFreeList;
893
894 /* Debug hooks associated with the current context. */
895 JSDebugHooks *debugHooks;
896
897 /* Security callbacks that override any defined on the runtime. */
898 JSSecurityCallbacks *securityCallbacks;
899
900 /* Pinned regexp pool used for regular expressions. */
901 JSArenaPool regexpPool;
902
903 /* Stored here to avoid passing it around as a parameter. */
904 uintN resolveFlags;
905 };
906
907 #ifdef JS_THREADSAFE
908 # define JS_THREAD_ID(cx) ((cx)->thread ? (cx)->thread->id : 0)
909 #endif
910
911 #ifdef __cplusplus
912 /* FIXME(bug 332648): Move this into a public header. */
913 class JSAutoTempValueRooter
914 {
915 public:
916 JSAutoTempValueRooter(JSContext *cx, size_t len, jsval *vec)
917 : mContext(cx) {
918 JS_PUSH_TEMP_ROOT(mContext, len, vec, &mTvr);
919 }
920 JSAutoTempValueRooter(JSContext *cx, jsval v)
921 : mContext(cx) {
922 JS_PUSH_SINGLE_TEMP_ROOT(mContext, v, &mTvr);
923 }
924
925 ~JSAutoTempValueRooter() {
926 JS_POP_TEMP_ROOT(mContext, &mTvr);
927 }
928
929 protected:
930 JSContext *mContext;
931
932 private:
933 #ifndef AIX
934 static void *operator new(size_t);
935 static void operator delete(void *, size_t);
936 #endif
937
938 JSTempValueRooter mTvr;
939 };
940
941 class JSAutoResolveFlags
942 {
943 public:
944 JSAutoResolveFlags(JSContext *cx, uintN flags)
945 : mContext(cx), mSaved(cx->resolveFlags) {
946 cx->resolveFlags = flags;
947 }
948
949 ~JSAutoResolveFlags() { mContext->resolveFlags = mSaved; }
950
951 private:
952 JSContext *mContext;
953 uintN mSaved;
954 };
955 #endif
956
957 /*
958 * Slightly more readable macros for testing per-context option settings (also
959 * to hide bitset implementation detail).
960 *
961 * JSOPTION_XML must be handled specially in order to propagate from compile-
962 * to run-time (from cx->options to script->version/cx->version). To do that,
963 * we copy JSOPTION_XML from cx->options into cx->version as JSVERSION_HAS_XML
964 * whenever options are set, and preserve this XML flag across version number
965 * changes done via the JS_SetVersion API.
966 *
967 * But when executing a script or scripted function, the interpreter changes
968 * cx->version, including the XML flag, to script->version. Thus JSOPTION_XML
969 * is a compile-time option that causes a run-time version change during each
970 * activation of the compiled script. That version change has the effect of
971 * changing JS_HAS_XML_OPTION, so that any compiling done via eval enables XML
972 * support. If an XML-enabled script or function calls a non-XML function,
973 * the flag bit will be cleared during the callee's activation.
974 *
975 * Note that JS_SetVersion API calls never pass JSVERSION_HAS_XML or'd into
976 * that API's version parameter.
977 *
978 * Note also that script->version must contain this XML option flag in order
979 * for XDR'ed scripts to serialize and deserialize with that option preserved
980 * for detection at run-time. We can't copy other compile-time options into
981 * script->version because that would break backward compatibility (certain
982 * other options, e.g. JSOPTION_VAROBJFIX, are analogous to JSOPTION_XML).
983 */
984 #define JS_HAS_OPTION(cx,option) (((cx)->options & (option)) != 0)
985 #define JS_HAS_STRICT_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_STRICT)
986 #define JS_HAS_WERROR_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_WERROR)
987 #define JS_HAS_COMPILE_N_GO_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_COMPILE_N_GO)
988 #define JS_HAS_ATLINE_OPTION(cx) JS_HAS_OPTION(cx, JSOPTION_ATLINE)
989
990 #define JSVERSION_MASK 0x0FFF /* see JSVersion in jspubtd.h */
991 #define JSVERSION_HAS_XML 0x1000 /* flag induced by XML option */
992
993 #define JSVERSION_NUMBER(cx) ((JSVersion)((cx)->version & \
994 JSVERSION_MASK))
995 #define JS_HAS_XML_OPTION(cx) ((cx)->version & JSVERSION_HAS_XML || \
996 JSVERSION_NUMBER(cx) >= JSVERSION_1_6)
997
998 /*
999 * Initialize a library-wide thread private data index, and remember that it
1000 * has already been done, so that it happens only once ever. Returns true on
1001 * success.
1002 */
1003 extern JSBool
1004 js_InitThreadPrivateIndex(void (*ptr)(void *));
1005
1006 /*
1007 * Common subroutine of JS_SetVersion and js_SetVersion, to update per-context
1008 * data that depends on version.
1009 */
1010 extern void
1011 js_OnVersionChange(JSContext *cx);
1012
1013 /*
1014 * Unlike the JS_SetVersion API, this function stores JSVERSION_HAS_XML and
1015 * any future non-version-number flags induced by compiler options.
1016 */
1017 extern void
1018 js_SetVersion(JSContext *cx, JSVersion version);
1019
1020 /*
1021 * Create and destroy functions for JSContext, which is manually allocated
1022 * and exclusively owned.
1023 */
1024 extern JSContext *
1025 js_NewContext(JSRuntime *rt, size_t stackChunkSize);
1026
1027 extern void
1028 js_DestroyContext(JSContext *cx, JSDestroyContextMode mode);
1029
1030 /*
1031 * Return true if cx points to a context in rt->contextList, else return false.
1032 * NB: the caller (see jslock.c:ClaimTitle) must hold rt->gcLock.
1033 */
1034 extern JSBool
1035 js_ValidContextPointer(JSRuntime *rt, JSContext *cx);
1036
1037 /*
1038 * If unlocked, acquire and release rt->gcLock around *iterp update; otherwise
1039 * the caller must be holding rt->gcLock.
1040 */
1041 extern JSContext *
1042 js_ContextIterator(JSRuntime *rt, JSBool unlocked, JSContext **iterp);
1043
1044 /*
1045 * JSClass.resolve and watchpoint recursion damping machinery.
1046 */
1047 extern JSBool
1048 js_StartResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
1049 JSResolvingEntry **entryp);
1050
1051 extern void
1052 js_StopResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
1053 JSResolvingEntry *entry, uint32 generation);
1054
1055 /*
1056 * Local root set management.
1057 *
1058 * NB: the jsval parameters below may be properly tagged jsvals, or GC-thing
1059 * pointers cast to (jsval). This relies on JSObject's tag being zero, but
1060 * on the up side it lets us push int-jsval-encoded scopeMark values on the
1061 * local root stack.
1062 */
1063 extern JSBool
1064 js_EnterLocalRootScope(JSContext *cx);
1065
1066 #define js_LeaveLocalRootScope(cx) \
1067 js_LeaveLocalRootScopeWithResult(cx, JSVAL_NULL)
1068
1069 extern void
1070 js_LeaveLocalRootScopeWithResult(JSContext *cx, jsval rval);
1071
1072 extern void
1073 js_ForgetLocalRoot(JSContext *cx, jsval v);
1074
1075 extern int
1076 js_PushLocalRoot(JSContext *cx, JSLocalRootStack *lrs, jsval v);
1077
1078 extern void
1079 js_TraceLocalRoots(JSTracer *trc, JSLocalRootStack *lrs);
1080
1081 /*
1082 * Report an exception, which is currently realized as a printf-style format
1083 * string and its arguments.
1084 */
1085 typedef enum JSErrNum {
1086 #define MSG_DEF(name, number, count, exception, format) \
1087 name = number,
1088 #include "js.msg"
1089 #undef MSG_DEF
1090 JSErr_Limit
1091 } JSErrNum;
1092
1093 extern JS_FRIEND_API(const JSErrorFormatString *)
1094 js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber);
1095
1096 #ifdef va_start
1097 extern JSBool
1098 js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap);
1099
1100 extern JSBool
1101 js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback,
1102 void *userRef, const uintN errorNumber,
1103 JSBool charArgs, va_list ap);
1104
1105 extern JSBool
1106 js_ExpandErrorArguments(JSContext *cx, JSErrorCallback callback,
1107 void *userRef, const uintN errorNumber,
1108 char **message, JSErrorReport *reportp,
1109 JSBool *warningp, JSBool charArgs, va_list ap);
1110 #endif
1111
1112 extern void
1113 js_ReportOutOfMemory(JSContext *cx);
1114
1115 /*
1116 * Report that cx->scriptStackQuota is exhausted.
1117 */
1118 extern void
1119 js_ReportOutOfScriptQuota(JSContext *cx);
1120
1121 extern void
1122 js_ReportOverRecursed(JSContext *cx);
1123
1124 extern void
1125 js_ReportAllocationOverflow(JSContext *cx);
1126
1127 #define JS_CHECK_RECURSION(cx, onerror) \
1128 JS_BEGIN_MACRO \
1129 int stackDummy_; \
1130 \
1131 if (!JS_CHECK_STACK_SIZE(cx, stackDummy_)) { \
1132 js_ReportOverRecursed(cx); \
1133 onerror; \
1134 } \
1135 JS_END_MACRO
1136
1137 /*
1138 * Report an exception using a previously composed JSErrorReport.
1139 * XXXbe remove from "friend" API
1140 */
1141 extern JS_FRIEND_API(void)
1142 js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *report);
1143
1144 extern void
1145 js_ReportIsNotDefined(JSContext *cx, const char *name);
1146
1147 /*
1148 * Report an attempt to access the property of a null or undefined value (v).
1149 */
1150 extern JSBool
1151 js_ReportIsNullOrUndefined(JSContext *cx, intN spindex, jsval v,
1152 JSString *fallback);
1153
1154 extern void
1155 js_ReportMissingArg(JSContext *cx, jsval *vp, uintN arg);
1156
1157 /*
1158 * Report error using js_DecompileValueGenerator(cx, spindex, v, fallback) as
1159 * the first argument for the error message. If the error message has less
1160 * then 3 arguments, use null for arg1 or arg2.
1161 */
1162 extern JSBool
1163 js_ReportValueErrorFlags(JSContext *cx, uintN flags, const uintN errorNumber,
1164 intN spindex, jsval v, JSString *fallback,
1165 const char *arg1, const char *arg2);
1166
1167 #define js_ReportValueError(cx,errorNumber,spindex,v,fallback) \
1168 ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber, \
1169 spindex, v, fallback, NULL, NULL))
1170
1171 #define js_ReportValueError2(cx,errorNumber,spindex,v,fallback,arg1) \
1172 ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber, \
1173 spindex, v, fallback, arg1, NULL))
1174
1175 #define js_ReportValueError3(cx,errorNumber,spindex,v,fallback,arg1,arg2) \
1176 ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber, \
1177 spindex, v, fallback, arg1, arg2))
1178
1179 extern JSErrorFormatString js_ErrorFormatString[JSErr_Limit];
1180
1181 /*
1182 * See JS_SetThreadStackLimit in jsapi.c, where we check that the stack grows
1183 * in the expected direction. On Unix-y systems, JS_STACK_GROWTH_DIRECTION is
1184 * computed on the build host by jscpucfg.c and written into jsautocfg.h. The
1185 * macro is hardcoded in jscpucfg.h on Windows and Mac systems (for historical
1186 * reasons pre-dating autoconf usage).
1187 */
1188 #if JS_STACK_GROWTH_DIRECTION > 0
1189 # define JS_CHECK_STACK_SIZE(cx, lval) ((jsuword)&(lval) < (cx)->stackLimit)
1190 #else
1191 # define JS_CHECK_STACK_SIZE(cx, lval) ((jsuword)&(lval) > (cx)->stackLimit)
1192 #endif
1193
1194 /*
1195 * Update the operation counter according to the given weight and call the
1196 * operation callback when we reach the operation limit. To make this
1197 * frequently executed macro faster we decrease the counter from
1198 * JSContext.operationLimit and compare against zero to check the limit.
1199 *
1200 * This macro can run the full GC. Return true if it is OK to continue and
1201 * false otherwise.
1202 */
1203 #define JS_CHECK_OPERATION_LIMIT(cx, weight) \
1204 (JS_CHECK_OPERATION_WEIGHT(weight), \
1205 (((cx)->operationCount -= (weight)) > 0 || js_ResetOperationCount(cx)))
1206
1207 /*
1208 * A version of JS_CHECK_OPERATION_LIMIT that just updates the operation count
1209 * without calling the operation callback or any other API. This macro resets
1210 * the count to 0 when it becomes negative to prevent a wrap-around when the
1211 * macro is called repeatably.
1212 */
1213 #define JS_COUNT_OPERATION(cx, weight) \
1214 ((void)(JS_CHECK_OPERATION_WEIGHT(weight), \
1215 (cx)->operationCount = ((cx)->operationCount > 0) \
1216 ? (cx)->operationCount - (weight) \
1217 : 0))
1218
1219 /*
1220 * The implementation of the above macros assumes that subtracting weights
1221 * twice from a positive number does not wrap-around INT32_MIN.
1222 */
1223 #define JS_CHECK_OPERATION_WEIGHT(weight) \
1224 (JS_ASSERT((uint32) (weight) > 0), \
1225 JS_ASSERT((uint32) (weight) < JS_BIT(30)))
1226
1227 /* Relative operations weights. */
1228 #define JSOW_JUMP 1
1229 #define JSOW_ALLOCATION 100
1230 #define JSOW_LOOKUP_PROPERTY 5
1231 #define JSOW_GET_PROPERTY 10
1232 #define JSOW_SET_PROPERTY 20
1233 #define JSOW_NEW_PROPERTY 200
1234 #define JSOW_DELETE_PROPERTY 30
1235 #define JSOW_ENTER_SHARP JS_OPERATION_WEIGHT_BASE
1236 #define JSOW_SCRIPT_JUMP JS_OPERATION_WEIGHT_BASE
1237
1238 /*
1239 * Reset the operation count and call the operation callback assuming that the
1240 * operation limit is reached.
1241 */
1242 extern JSBool
1243 js_ResetOperationCount(JSContext *cx);
1244
1245 JS_END_EXTERN_C
1246
1247 #endif /* jscntxt_h___ */

  ViewVC Help
Powered by ViewVC 1.1.24