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

Annotation of /trunk/js/jscntxt.h

Parent Directory Parent Directory | Revision Log Revision Log


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

1 siliconforks 332 /* -*- 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 siliconforks 399
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 siliconforks 332 } 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 siliconforks 399 /* Client opaque pointers */
337 siliconforks 332 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 siliconforks 399 * 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 siliconforks 332 * 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 siliconforks 399 /* Client opaque pointers. */
859 siliconforks 332 void *data;
860 siliconforks 399 void *data2;
861 siliconforks 332
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 siliconforks 399 protected:
930     JSContext *mContext;
931    
932 siliconforks 332 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