/js/lib/Socket.IO-node/support/expresso/deps/jscoverage/js/jscntxt.h
C++ Header | 1247 lines | 611 code | 199 blank | 437 comment | 10 complexity | af93b785bab04c6f2f80b2c3388dfb27 MD5 | raw file
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 60JS_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 */ 68typedef 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 97namespace nanojit { 98 class Fragment; 99 class Fragmento; 100} 101class TraceRecorder; 102extern "C++" { template<typename T> class Queue; } 103typedef Queue<uint16> SlotList; 104class 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 */ 116typedef 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 */ 153struct 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 190extern void 191js_ThreadDestructorCB(void *ptr); 192 193extern JSBool 194js_SetContextThread(JSContext *cx); 195 196extern void 197js_ClearContextThread(JSContext *cx); 198 199extern JSThread * 200js_GetCurrentThread(JSRuntime *rt); 201 202#endif /* JS_THREADSAFE */ 203 204typedef enum JSDestroyContextMode { 205 JSDCM_NO_GC, 206 JSDCM_MAYBE_GC, 207 JSDCM_FORCE_GC, 208 JSDCM_NEW_FAILED 209} JSDestroyContextMode; 210 211typedef enum JSRuntimeState { 212 JSRTS_DOWN, 213 JSRTS_LAUNCHING, 214 JSRTS_UP, 215 JSRTS_LANDING 216} JSRuntimeState; 217 218typedef struct JSPropertyTreeEntry { 219 JSDHashEntryHdr hdr; 220 JSScopeProperty *child; 221} JSPropertyTreeEntry; 222 223typedef struct JSSetSlotRequest JSSetSlotRequest; 224 225struct 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 233struct 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 */ 589struct JSArgumentFormatMap { 590 const char *format; 591 size_t length; 592 JSArgumentFormatter formatter; 593 JSArgumentFormatMap *next; 594}; 595#endif 596 597struct 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 */ 610typedef struct JSResolvingKey { 611 JSObject *obj; 612 jsid id; 613} JSResolvingKey; 614 615typedef 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 624typedef 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 630struct JSLocalRootChunk { 631 jsval roots[JSLRS_CHUNK_SIZE]; 632 JSLocalRootChunk *down; 633}; 634 635typedef 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 */ 680JS_STATIC_ASSERT(sizeof(JSTempValueUnion) == sizeof(jsval)); 681JS_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 734struct 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. */ 913class 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 941class 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 */ 1003extern JSBool 1004js_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 */ 1010extern void 1011js_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 */ 1017extern void 1018js_SetVersion(JSContext *cx, JSVersion version); 1019 1020/* 1021 * Create and destroy functions for JSContext, which is manually allocated 1022 * and exclusively owned. 1023 */ 1024extern JSContext * 1025js_NewContext(JSRuntime *rt, size_t stackChunkSize); 1026 1027extern void 1028js_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 */ 1034extern JSBool 1035js_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 */ 1041extern JSContext * 1042js_ContextIterator(JSRuntime *rt, JSBool unlocked, JSContext **iterp); 1043 1044/* 1045 * JSClass.resolve and watchpoint recursion damping machinery. 1046 */ 1047extern JSBool 1048js_StartResolving(JSContext *cx, JSResolvingKey *key, uint32 flag, 1049 JSResolvingEntry **entryp); 1050 1051extern void 1052js_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 */ 1063extern JSBool 1064js_EnterLocalRootScope(JSContext *cx); 1065 1066#define js_LeaveLocalRootScope(cx) \ 1067 js_LeaveLocalRootScopeWithResult(cx, JSVAL_NULL) 1068 1069extern void 1070js_LeaveLocalRootScopeWithResult(JSContext *cx, jsval rval); 1071 1072extern void 1073js_ForgetLocalRoot(JSContext *cx, jsval v); 1074 1075extern int 1076js_PushLocalRoot(JSContext *cx, JSLocalRootStack *lrs, jsval v); 1077 1078extern void 1079js_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 */ 1085typedef 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 1093extern JS_FRIEND_API(const JSErrorFormatString *) 1094js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber); 1095 1096#ifdef va_start 1097extern JSBool 1098js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap); 1099 1100extern JSBool 1101js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback, 1102 void *userRef, const uintN errorNumber, 1103 JSBool charArgs, va_list ap); 1104 1105extern JSBool 1106js_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 1112extern void 1113js_ReportOutOfMemory(JSContext *cx); 1114 1115/* 1116 * Report that cx->scriptStackQuota is exhausted. 1117 */ 1118extern void 1119js_ReportOutOfScriptQuota(JSContext *cx); 1120 1121extern void 1122js_ReportOverRecursed(JSContext *cx); 1123 1124extern void 1125js_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 */ 1141extern JS_FRIEND_API(void) 1142js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *report); 1143 1144extern void 1145js_ReportIsNotDefined(JSContext *cx, const char *name); 1146 1147/* 1148 * Report an attempt to access the property of a null or undefined value (v). 1149 */ 1150extern JSBool 1151js_ReportIsNullOrUndefined(JSContext *cx, intN spindex, jsval v, 1152 JSString *fallback); 1153 1154extern void 1155js_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 */ 1162extern JSBool 1163js_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 1179extern 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 */ 1242extern JSBool 1243js_ResetOperationCount(JSContext *cx); 1244 1245JS_END_EXTERN_C 1246 1247#endif /* jscntxt_h___ */