/[jscoverage]/trunk/js/jsinterp.cpp

Diff of /trunk/js/jsinterp.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 459 by siliconforks,
Tue Dec  9 03:37:47 2008 UTC
+revision 460 by siliconforks,
Sat Sep 26 23:15:22 2009 UTC
 Line 1
- /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   * vim: set ts=8 sw=4 et tw=79:
   *
   * ***** BEGIN LICENSE BLOCK *****
 Line 54
  #include "jsatom.h"
  #include "jsbool.h"
  #include "jscntxt.h"
+ #include "jsdate.h"
  #include "jsversion.h"
  #include "jsdbgapi.h"
  #include "jsfun.h"
-Line 85
+Line 86
  #if !JS_LONE_INTERPRET ^ defined jsinvoke_cpp___
  uint32
- js_GenerateShape(JSContext *cx, JSBool gcLocked, JSScopeProperty *sprop)
+ js_GenerateShape(JSContext *cx, JSBool gcLocked)
  {
      JSRuntime *rt;
      uint32 shape;
-     JSTempValueRooter tvr;
      rt = cx->runtime;
      shape = JS_ATOMIC_INCREMENT(&rt->shapeGen);
      JS_ASSERT(shape != 0);
-     if (shape & SHAPE_OVERFLOW_BIT) {
+     if (shape >= SHAPE_OVERFLOW_BIT) {
-         rt->gcPoke = JS_TRUE;
+         /*
-         if (sprop)
+          * FIXME bug 440834: The shape id space has overflowed. Currently we
-             JS_PUSH_TEMP_ROOT_SPROP(cx, sprop, &tvr);
+          * cope badly with this and schedule the GC on the every call. But
-         js_GC(cx, gcLocked ? GC_LOCK_HELD : GC_NORMAL);
+          * first we make sure that increments from other threads would not
-         if (sprop)
+          * have a chance to wrap around shapeGen to zero.
-             JS_POP_TEMP_ROOT(cx, &tvr);
+          */
-         shape = JS_ATOMIC_INCREMENT(&rt->shapeGen);
+         rt->shapeGen = SHAPE_OVERFLOW_BIT;
-         JS_ASSERT(shape != 0);
+         js_TriggerGC(cx, gcLocked);
-         JS_ASSERT_IF(shape & SHAPE_OVERFLOW_BIT,
-                      JS_PROPERTY_CACHE(cx).disabled);
      }
      return shape;
  }
- void
+ JS_REQUIRES_STACK JSPropCacheEntry *
- js_FillPropertyCache(JSContext *cx, JSObject *obj, jsuword kshape,
+ js_FillPropertyCache(JSContext *cx, JSObject *obj,
-                      uintN scopeIndex, uintN protoIndex,
+                      uintN scopeIndex, uintN protoIndex, JSObject *pobj,
-                      JSObject *pobj, JSScopeProperty *sprop,
+                      JSScopeProperty *sprop, JSBool adding)
-                      JSPropCacheEntry **entryp)
  {
      JSPropertyCache *cache;
      jsbytecode *pc;
      JSScope *scope;
+     jsuword kshape, vshape, khash;
      JSOp op;
      const JSCodeSpec *cs;
      jsuword vword;
      ptrdiff_t pcoff;
-     jsuword khash;
      JSAtom *atom;
      JSPropCacheEntry *entry;
      JS_ASSERT(!cx->runtime->gcRunning);
      cache = &JS_PROPERTY_CACHE(cx);
-     pc = cx->fp->regs->pc;
-     if (cache->disabled || (cx->fp->flags & JSFRAME_EVAL)) {
+     /* FIXME bug 489098: consider enabling the property cache for eval. */
+     if (js_IsPropertyCacheDisabled(cx) || (cx->fp->flags & JSFRAME_EVAL)) {
          PCMETER(cache->disfills++);
-         *entryp = NULL;
+         return JS_NO_PROP_CACHE_FILL;
-         return;
      }
      /*
-Line 143
+Line 140
      JS_ASSERT(scope->object == pobj);
      if (!SCOPE_HAS_PROPERTY(scope, sprop)) {
          PCMETER(cache->oddfills++);
-         *entryp = NULL;
+         return JS_NO_PROP_CACHE_FILL;
-         return;
      }
      /*
-Line 161
+Line 157
       * but vcap vs. scope shape tests ensure nothing malfunctions.
       */
      JS_ASSERT_IF(scopeIndex == 0 && protoIndex == 0, obj == pobj);
      if (protoIndex != 0) {
-         JSObject *tmp;
+         JSObject *tmp = obj;
+         for (uintN i = 0; i != scopeIndex; i++)
+             tmp = OBJ_GET_PARENT(cx, tmp);
+         JS_ASSERT(tmp != pobj);
-         JS_ASSERT(pobj != obj);
          protoIndex = 1;
-         tmp = obj;
          for (;;) {
              tmp = OBJ_GET_PROTO(cx, tmp);
-             if (!tmp) {
+             /*
+              * We cannot cache properties coming from native objects behind
+              * non-native ones on the prototype chain. The non-natives can
+              * mutate in arbitrary way without changing any shapes.
+              */
+             if (!tmp || !OBJ_IS_NATIVE(tmp)) {
                  PCMETER(cache->noprotos++);
-                 *entryp = NULL;
+                 return JS_NO_PROP_CACHE_FILL;
-                 return;
              }
              if (tmp == pobj)
                  break;
              ++protoIndex;
          }
      }
      if (scopeIndex > PCVCAP_SCOPEMASK || protoIndex > PCVCAP_PROTOMASK) {
          PCMETER(cache->longchains++);
-         *entryp = NULL;
+         return JS_NO_PROP_CACHE_FILL;
-         return;
      }
      /*
       * Optimize the cached vword based on our parameters and the current pc's
       * opcode format flags.
       */
-     op = (JSOp) *pc;
+     pc = cx->fp->regs->pc;
+     op = js_GetOpcode(cx, cx->fp->script, pc);
      cs = &js_CodeSpec[op];
+     kshape = 0;
      do {
          /*
-Line 214
+Line 220
                       *
                       * So here, on first cache fill for this method, we brand
                       * the scope with a new shape and set the SCOPE_BRANDED
-                      * flag.  Once this scope flag is set, any write that adds
+                      * flag. Once this scope flag is set, any write that adds
                       * or deletes a function-valued plain old property in
                       * scope->object will result in shape being regenerated.
                       */
-Line 222
+Line 228
                          PCMETER(cache->brandfills++);
  #ifdef DEBUG_notme
                          fprintf(stderr,
-                             "branding %p (%s) for funobj %p (%s), kshape %lu\n",
+                             "branding %p (%s) for funobj %p (%s), shape %lu\n",
                              pobj, LOCKED_OBJ_GET_CLASS(pobj)->name,
                              JSVAL_TO_OBJECT(v),
                              JS_GetFunctionName(GET_FUNCTION_PRIVATE(cx,
                                                   JSVAL_TO_OBJECT(v))),
-                             kshape);
+                             OBJ_SHAPE(obj));
  #endif
-                         SCOPE_MAKE_UNIQUE_SHAPE(cx, scope);
+                         js_MakeScopeShapeUnique(cx, scope);
+                         if (js_IsPropertyCacheDisabled(cx)) {
+                             /*
+                              * js_GenerateShape could not recover from
+                              * rt->shapeGen's overflow.
+                              */
+                             return JS_NO_PROP_CACHE_FILL;
+                         }
                          SCOPE_SET_BRANDED(scope);
-                         kshape = scope->shape;
                      }
                      vword = JSVAL_OBJECT_TO_PCVAL(v);
                      break;
-Line 240
+Line 252
          }
          /* If getting a value via a stub getter, we can cache the slot. */
-         if (!(cs->format & JOF_SET) &&
+         if (!(cs->format & (JOF_SET | JOF_INCDEC | JOF_FOR)) &&
              SPROP_HAS_STUB_GETTER(sprop) &&
              SPROP_HAS_VALID_SLOT(sprop, scope)) {
              /* Great, let's cache sprop's slot and use it on cache hit. */
-Line 248
+Line 260
          } else {
              /* Best we can do is to cache sprop (still a nice speedup). */
              vword = SPROP_TO_PCVAL(sprop);
+             if (adding &&
+                 sprop == scope->lastProp &&
+                 scope->shape == sprop->shape) {
+                 /*
+                  * Our caller added a new property. We also know that a setter
+                  * that js_NativeSet could have run has not mutated the scope
+                  * so the added property is still the last one added and the
+                  * scope is not branded.
+                  *
+                  * We want to cache under scope's shape before the property
+                  * addition to bias for the case when the mutator opcode
+                  * always adds the same property. It allows to optimize
+                  * periodic execution of object initializers or explicit
+                  * initialization sequences like
+                  *
+                  *   obj = {}; obj.x = 1; obj.y = 2;
+                  *
+                  * We assume that on average the win from this optimization is
+                  * bigger that the cost of an extra mismatch per loop due to
+                  * the bias for the following case:
+                  *
+                  *   obj = {}; ... for (...) { ... obj.x = ... }
+                  *
+                  * On the first iteration JSOP_SETPROP fills the cache with
+                  * the shape of newly created object, not the shape after
+                  * obj.x is assigned. That mismatches obj's shape on the
+                  * second iteration. Note that on third and the following
+                  * iterations the cache will be hit since the shape no longer
+                  * mutates.
+                  */
+                 JS_ASSERT(scope->object == obj);
+                 if (sprop->parent) {
+                     kshape = sprop->parent->shape;
+                 } else {
+                     JSObject *proto = STOBJ_GET_PROTO(obj);
+                     if (proto && OBJ_IS_NATIVE(proto))
+                         kshape = OBJ_SHAPE(proto);
+                 }
+                 /*
+                  * When adding we predict no prototype object will later gain a
+                  * readonly property or setter.
+                  */
+                 vshape = cx->runtime->protoHazardShape;
+             }
          }
      } while (0);
-     /*
+     if (kshape == 0) {
-      * Our caller preserved the scope shape prior to the js_GetPropertyHelper
+         kshape = OBJ_SHAPE(obj);
-      * or similar call out of the interpreter. We want to cache under that
+         vshape = scope->shape;
-      * shape if op is overtly mutating, to bias for the case where the mutator
+     }
-      * udpates shape predictably.
-      *
-      * Note that an apparently non-mutating op such as JSOP_NAME may still
-      * mutate the base object via, e.g., lazy standard class initialization,
-      * but that is a one-time event and we'll have to miss the old shape and
-      * re-fill under the new one.
-      */
-     if (!(cs->format & (JOF_SET | JOF_INCDEC)) && obj == pobj)
-         kshape = scope->shape;
      khash = PROPERTY_CACHE_HASH_PC(pc, kshape);
      if (obj == pobj) {
-         JS_ASSERT(kshape != 0 || scope->shape != 0);
          JS_ASSERT(scopeIndex == 0 && protoIndex == 0);
          JS_ASSERT(OBJ_SCOPE(obj)->object == obj);
+         JS_ASSERT(kshape != 0);
      } else {
          if (op == JSOP_LENGTH) {
              atom = cx->runtime->atomState.lengthAtom;
          } else {
-             pcoff = (JOF_TYPE(cs->format) == JOF_SLOTATOM) ? 2 : 0;
+             pcoff = (JOF_TYPE(cs->format) == JOF_SLOTATOM) ? SLOTNO_LEN : 0;
              GET_ATOM_FROM_BYTECODE(cx->fp->script, pc, pcoff, atom);
          }
-         JS_ASSERT_IF(scopeIndex == 0,
-                      protoIndex != 1 || OBJ_GET_PROTO(cx, obj) == pobj);
+ #ifdef DEBUG
+         if (scopeIndex == 0) {
+             JS_ASSERT(protoIndex != 0);
+             JS_ASSERT((protoIndex == 1) == (OBJ_GET_PROTO(cx, obj) == pobj));
+         }
+ #endif
          if (scopeIndex != 0 || protoIndex != 1) {
              khash = PROPERTY_CACHE_HASH_ATOM(atom, obj, pobj);
              PCMETER(if (PCVCAP_TAG(cache->table[khash].vcap) <= 1)
                          cache->pcrecycles++);
              pc = (jsbytecode *) atom;
              kshape = (jsuword) obj;
+             /*
+              * Make sure that a later shadowing assignment will enter
+              * PurgeProtoChain and invalidate this entry, bug 479198.
+              *
+              * This is thread-safe even though obj is not locked. Only the
+              * DELEGATE bit of obj->classword can change at runtime, given that
+              * obj is native; and the bit is only set, never cleared. And on
+              * platforms where another CPU can fail to see this write, it's OK
+              * because the property cache and JIT cache are thread-local.
+              */
+             OBJ_SET_DELEGATE(cx, obj);
          }
      }
      entry = &cache->table[khash];
-     PCMETER(if (entry != *entryp) cache->modfills++);
+     PCMETER(PCVAL_IS_NULL(entry->vword) || cache->recycles++);
-     PCMETER(if (!PCVAL_IS_NULL(entry->vword)) cache->recycles++);
      entry->kpc = pc;
      entry->kshape = kshape;
-     entry->vcap = PCVCAP_MAKE(scope->shape, scopeIndex, protoIndex);
+     entry->vcap = PCVCAP_MAKE(vshape, scopeIndex, protoIndex);
      entry->vword = vword;
-     *entryp = entry;
      cache->empty = JS_FALSE;
      PCMETER(cache->fills++);
+     /*
+      * The modfills counter is not exact. It increases if a getter or setter
+      * recurse into the interpreter.
+      */
+     PCMETER(entry == cache->pctestentry || cache->modfills++);
+     PCMETER(cache->pctestentry = NULL);
+     return entry;
  }
- JSAtom *
+ JS_REQUIRES_STACK JSAtom *
  js_FullTestPropertyCache(JSContext *cx, jsbytecode *pc,
                           JSObject **objp, JSObject **pobjp,
                           JSPropCacheEntry **entryp)
-Line 317
+Line 389
      JS_ASSERT(uintN((cx->fp->imacpc ? cx->fp->imacpc : pc) - cx->fp->script->code)
                < cx->fp->script->length);
-     op = (JSOp) *pc;
+     op = js_GetOpcode(cx, cx->fp->script, pc);
      cs = &js_CodeSpec[op];
      if (op == JSOP_LENGTH) {
          atom = cx->runtime->atomState.lengthAtom;
      } else {
-         pcoff = (JOF_TYPE(cs->format) == JOF_SLOTATOM) ? 2 : 0;
+         pcoff = (JOF_TYPE(cs->format) == JOF_SLOTATOM) ? SLOTNO_LEN : 0;
          GET_ATOM_FROM_BYTECODE(cx->fp->script, pc, pcoff, atom);
      }
-Line 424
+Line 496
  JS_STATIC_ASSERT(PCVAL_NULL == 0);
  void
- js_FlushPropertyCache(JSContext *cx)
+ js_PurgePropertyCache(JSContext *cx, JSPropertyCache *cache)
  {
-     JSPropertyCache *cache;
-     cache = &JS_PROPERTY_CACHE(cx);
      if (cache->empty) {
          ASSERT_CACHE_IS_EMPTY(cache);
          return;
-Line 496
+Line 565
  }
  void
- js_FlushPropertyCacheForScript(JSContext *cx, JSScript *script)
+ js_PurgePropertyCacheForScript(JSContext *cx, JSScript *script)
  {
      JSPropertyCache *cache;
      JSPropCacheEntry *entry;
-Line 514
+Line 583
      }
  }
- void
- js_DisablePropertyCache(JSContext *cx)
- {
-     JS_ASSERT(JS_PROPERTY_CACHE(cx).disabled >= 0);
-     ++JS_PROPERTY_CACHE(cx).disabled;
- }
- void
- js_EnablePropertyCache(JSContext *cx)
- {
-     --JS_PROPERTY_CACHE(cx).disabled;
-     JS_ASSERT(JS_PROPERTY_CACHE(cx).disabled >= 0);
- }
  /*
   * Check if the current arena has enough space to fit nslots after sp and, if
   * so, reserve the necessary space.
   */
- static JSBool
+ static JS_REQUIRES_STACK JSBool
  AllocateAfterSP(JSContext *cx, jsval *sp, uintN nslots)
  {
      uintN surplus;
-Line 557
+Line 612
      return JS_TRUE;
  }
- JS_STATIC_INTERPRET jsval *
+ JS_STATIC_INTERPRET JS_REQUIRES_STACK jsval *
  js_AllocRawStack(JSContext *cx, uintN nslots, void **markp)
  {
      jsval *sp;
+     JS_ASSERT(nslots != 0);
+     js_LeaveTrace(cx);
      if (!cx->stackPool.first.next) {
          int64 *timestamp;
-Line 582
+Line 640
      return sp;
  }
- JS_STATIC_INTERPRET void
+ JS_STATIC_INTERPRET JS_REQUIRES_STACK void
  js_FreeRawStack(JSContext *cx, void *mark)
  {
      JS_ARENA_RELEASE(&cx->stackPool, mark);
  }
- JS_FRIEND_API(jsval *)
+ JS_REQUIRES_STACK JS_FRIEND_API(jsval *)
  js_AllocStack(JSContext *cx, uintN nslots, void **markp)
  {
      jsval *sp;
-Line 634
+Line 692
      return sp;
  }
- JS_FRIEND_API(void)
+ JS_REQUIRES_STACK JS_FRIEND_API(void)
  js_FreeStack(JSContext *cx, void *mark)
  {
      JSStackHeader *sh;
-Line 662
+Line 720
  JSObject *
  js_GetScopeChain(JSContext *cx, JSStackFrame *fp)
  {
-     JSObject *obj, *cursor, *clonedChild, *parent;
+     JSObject *sharedBlock = fp->blockChain;
-     JSTempValueRooter tvr;
-     obj = fp->blockChain;
+     if (!sharedBlock) {
-     if (!obj) {
          /*
           * Don't force a call object for a lightweight function call, but do
           * insist that there is a call object for a heavyweight function call.
-Line 678
+Line 734
          return fp->scopeChain;
      }
+     /* We don't handle cloning blocks on trace.  */
+     js_LeaveTrace(cx);
      /*
       * We have one or more lexical scopes to reflect into fp->scopeChain, so
       * make sure there's a call object at the current head of the scope chain,
       * if this frame is a call frame.
+      *
+      * Also, identify the innermost compiler-allocated block we needn't clone.
       */
+     JSObject *limitBlock, *limitClone;
      if (fp->fun && !fp->callobj) {
          JS_ASSERT(OBJ_GET_CLASS(cx, fp->scopeChain) != &js_BlockClass ||
                    OBJ_GET_PRIVATE(cx, fp->scopeChain) != fp);
-         if (!js_GetCallObject(cx, fp, fp->scopeChain))
+         if (!js_GetCallObject(cx, fp))
              return NULL;
+         /* We know we must clone everything on blockChain. */
+         limitBlock = limitClone = NULL;
+     } else {
+         /*
+          * scopeChain includes all blocks whose static scope we're within that
+          * have already been cloned.  Find the innermost such block.  Its
+          * prototype should appear on blockChain; we'll clone blockChain up
+          * to, but not including, that prototype.
+          */
+         limitClone = fp->scopeChain;
+         while (OBJ_GET_CLASS(cx, limitClone) == &js_WithClass)
+             limitClone = OBJ_GET_PARENT(cx, limitClone);
+         JS_ASSERT(limitClone);
+         /*
+          * It may seem like we don't know enough about limitClone to be able
+          * to just grab its prototype as we do here, but it's actually okay.
+          *
+          * If limitClone is a block object belonging to this frame, then its
+          * prototype is the innermost entry in blockChain that we have already
+          * cloned, and is thus the place to stop when we clone below.
+          *
+          * Otherwise, there are no blocks for this frame on scopeChain, and we
+          * need to clone the whole blockChain.  In this case, limitBlock can
+          * point to any object known not to be on blockChain, since we simply
+          * loop until we hit limitBlock or NULL.  If limitClone is a block, it
+          * isn't a block from this function, since blocks can't be nested
+          * within themselves on scopeChain (recursion is dynamic nesting, not
+          * static nesting).  If limitClone isn't a block, its prototype won't
+          * be a block either.  So we can just grab limitClone's prototype here
+          * regardless of its type or which frame it belongs to.
+          */
+         limitBlock = OBJ_GET_PROTO(cx, limitClone);
+         /* If the innermost block has already been cloned, we are done. */
+         if (limitBlock == sharedBlock)
+             return fp->scopeChain;
      }
      /*
-      * Clone the block chain. To avoid recursive cloning we set the parent of
+      * Special-case cloning the innermost block; this doesn't have enough in
-      * the cloned child after we clone the parent. In the following loop when
+      * common with subsequent steps to include in the loop.
-      * clonedChild is null it indicates the first iteration when no special GC
+      *
-      * rooting is necessary. On the second and the following iterations we
+      * We pass fp->scopeChain and not null even if we override the parent slot
-      * have to protect cloned so far chain against the GC during cloning of
+      * later as null triggers useless calculations of slot's value in
-      * the cursor object.
+      * js_NewObject that js_CloneBlockObject calls.
       */
-     cursor = obj;
+     JSObject *innermostNewChild
-     clonedChild = NULL;
+         = js_CloneBlockObject(cx, sharedBlock, fp->scopeChain, fp);
+     if (!innermostNewChild)
+         return NULL;
+     JSAutoTempValueRooter tvr(cx, innermostNewChild);
+     /*
+      * Clone our way towards outer scopes until we reach the innermost
+      * enclosing function, or the innermost block we've already cloned.
+      */
+     JSObject *newChild = innermostNewChild;
      for (;;) {
-         parent = OBJ_GET_PARENT(cx, cursor);
+         JS_ASSERT(OBJ_GET_PROTO(cx, newChild) == sharedBlock);
+         sharedBlock = OBJ_GET_PARENT(cx, sharedBlock);
+         /* Sometimes limitBlock will be NULL, so check that first.  */
+         if (sharedBlock == limitBlock || !sharedBlock)
+             break;
+         /* As in the call above, we don't know the real parent yet.  */
+         JSObject *clone
+             = js_CloneBlockObject(cx, sharedBlock, fp->scopeChain, fp);
+         if (!clone)
+             return NULL;
          /*
-          * We pass fp->scopeChain and not null even if we override the parent
+          * Avoid OBJ_SET_PARENT overhead as newChild cannot escape to
-          * slot later as null triggers useless calculations of slot's value in
+          * other threads.
-          * js_NewObject that js_CloneBlockObject calls.
           */
-         cursor = js_CloneBlockObject(cx, cursor, fp->scopeChain, fp);
+         STOBJ_SET_PARENT(newChild, clone);
-         if (!cursor) {
+         newChild = clone;
-             if (clonedChild)
-                 JS_POP_TEMP_ROOT(cx, &tvr);
-             return NULL;
-         }
-         if (!clonedChild) {
-             /*
-              * The first iteration. Check if other follow and root obj if so
-              * to protect the whole cloned chain against GC.
-              */
-             obj = cursor;
-             if (!parent)
-                 break;
-             JS_PUSH_TEMP_ROOT_OBJECT(cx, obj, &tvr);
-         } else {
-             /*
-              * Avoid OBJ_SET_PARENT overhead as clonedChild cannot escape to
-              * other threads.
-              */
-             STOBJ_SET_PARENT(clonedChild, cursor);
-             if (!parent) {
-                 JS_ASSERT(tvr.u.value == OBJECT_TO_JSVAL(obj));
-                 JS_POP_TEMP_ROOT(cx, &tvr);
-                 break;
-             }
-         }
-         clonedChild = cursor;
-         cursor = parent;
      }
-     fp->flags |= JSFRAME_POP_BLOCKS;
-     fp->scopeChain = obj;
+     /*
-     fp->blockChain = NULL;
+      * If we found a limit block belonging to this frame, then we should have
-     return obj;
+      * found it in blockChain.
+      */
+     JS_ASSERT_IF(limitBlock &&
+                  OBJ_GET_CLASS(cx, limitBlock) == &js_BlockClass &&
+                  OBJ_GET_PRIVATE(cx, limitClone) == fp,
+                  sharedBlock);
+     /* Place our newly cloned blocks at the head of the scope chain.  */
+     fp->scopeChain = innermostNewChild;
+     return fp->scopeChain;
  }
  JSBool
-Line 802
+Line 903
           * imposes a performance penalty on all js_ComputeGlobalThis calls,
           * and it represents a maintenance hazard.
           */
-         fp = cx->fp;    /* quell GCC overwarning */
+         fp = js_GetTopStackFrame(cx);    /* quell GCC overwarning */
          if (lazy) {
              JS_ASSERT(fp->argv == argv);
              fp->dormantNext = cx->dormantFrameChain;
-Line 830
+Line 931
              thisp = parent;
      }
-     OBJ_TO_OUTER_OBJECT(cx, thisp);
+     /* Some objects (e.g., With) delegate 'this' to another object. */
+     thisp = OBJ_THIS_OBJECT(cx, thisp);
      if (!thisp)
          return NULL;
      argv[-1] = OBJECT_TO_JSVAL(thisp);
-Line 849
+Line 951
          thisp = JSVAL_TO_OBJECT(argv[-1]);
      } else {
          thisp = JSVAL_TO_OBJECT(argv[-1]);
-         if (OBJ_GET_CLASS(cx, thisp) == &js_CallClass)
+         if (OBJ_GET_CLASS(cx, thisp) == &js_CallClass ||
+             OBJ_GET_CLASS(cx, thisp) == &js_BlockClass) {
              return js_ComputeGlobalThis(cx, lazy, argv);
-         if (thisp->map->ops->thisObject) {
-             /* Some objects (e.g., With) delegate 'this' to another object. */
-             thisp = thisp->map->ops->thisObject(cx, thisp);
-             if (!thisp)
-                 return NULL;
          }
-         OBJ_TO_OUTER_OBJECT(cx, thisp);
+         /* Some objects (e.g., With) delegate 'this' to another object. */
+         thisp = OBJ_THIS_OBJECT(cx, thisp);
          if (!thisp)
              return NULL;
          argv[-1] = OBJECT_TO_JSVAL(thisp);
-Line 881
+Line 980
  JSClass js_NoSuchMethodClass = {
      "NoSuchMethod",
-     JSCLASS_HAS_RESERVED_SLOTS(2) | JSCLASS_IS_ANONYMOUS |
+     JSCLASS_HAS_RESERVED_SLOTS(2) | JSCLASS_IS_ANONYMOUS,
-     JSCLASS_HAS_CACHED_PROTO(JSProto_NoSuchMethod),
      JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,   JS_PropertyStub,
      JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,    JS_FinalizeStub,
      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  };
- JS_BEGIN_EXTERN_C
- JSObject*
- js_InitNoSuchMethodClass(JSContext *cx, JSObject* obj);
- JS_END_EXTERN_C
- JSObject*
- js_InitNoSuchMethodClass(JSContext *cx, JSObject* obj)
- {
-     JSObject *proto;
-     proto = JS_InitClass(cx, obj, NULL, &js_NoSuchMethodClass, NULL, 0, NULL,
-                          NULL, NULL, NULL);
-     if (!proto)
-         return NULL;
-     OBJ_CLEAR_PROTO(cx, proto);
-     return proto;
- }
  /*
   * When JSOP_CALLPROP or JSOP_CALLELEM does not find the method property of
   * the base object, we search for the __noSuchMethod__ method in the base.
-Line 937
+Line 1014
      MUST_FLOW_THROUGH("out");
      id = ATOM_TO_JSID(cx->runtime->atomState.noSuchMethodAtom);
- #if JS_HAS_XML_SUPPORT
+     ok = js_GetMethod(cx, obj, id, false, &tvr.u.value);
-     if (OBJECT_IS_XML(cx, obj)) {
+     if (!ok)
-         JSXMLObjectOps *ops;
+         goto out;
-         ops = (JSXMLObjectOps *) obj->map->ops;
-         obj = ops->getMethod(cx, obj, id, &tvr.u.value);
-         if (!obj) {
-             ok = JS_FALSE;
-             goto out;
-         }
-         vp[1] = OBJECT_TO_JSVAL(obj);
-     } else
- #endif
-     {
-         ok = OBJ_GET_PROPERTY(cx, obj, id, &tvr.u.value);
-         if (!ok)
-             goto out;
-     }
      if (JSVAL_IS_PRIMITIVE(tvr.u.value)) {
          vp[0] = tvr.u.value;
      } else {
-Line 969
+Line 1031
                  vp[0] = ID_TO_VALUE(id);
          }
  #endif
-         obj = js_NewObject(cx, &js_NoSuchMethodClass, NULL, NULL, 0);
+         obj = js_NewObjectWithGivenProto(cx, &js_NoSuchMethodClass,
+                                          NULL, NULL, 0);
          if (!obj) {
              ok = JS_FALSE;
              goto out;
-Line 985
+Line 1048
      return ok;
  }
- static JSBool
+ static JS_REQUIRES_STACK JSBool
  NoSuchMethod(JSContext *cx, uintN argc, jsval *vp, uint32 flags)
  {
      jsval *invokevp;
-Line 1046
+Line 1109
   * required arguments, allocate declared local variables, and pop everything
   * when done.  Then push the return value.
   */
- JS_FRIEND_API(JSBool)
+ JS_REQUIRES_STACK JS_FRIEND_API(JSBool)
  js_Invoke(JSContext *cx, uintN argc, jsval *vp, uintN flags)
  {
      void *mark;
-Line 1069
+Line 1132
      JS_ASSERT((jsval *) cx->stackPool.current->base <= vp);
      JS_ASSERT(vp + 2 + argc <= (jsval *) cx->stackPool.current->avail);
-     /*
+     /* Mark the top of stack and load frequently-used registers. */
-      * Mark the top of stack and load frequently-used registers. After this
-      * point the control should flow through label out2: to return.
-      */
      mark = JS_ARENA_MARK(&cx->stackPool);
+     MUST_FLOW_THROUGH("out2");
      v = *vp;
      if (JSVAL_IS_PRIMITIVE(v))
-Line 1098
+Line 1159
           * XXX better to call that hook without converting
           * XXX the only thing that needs fixing is liveconnect
           *
-          * Try converting to function, for closure and API compatibility.
+          * FIXME bug 408416: try converting to function, for API compatibility
-          * We attempt the conversion under all circumstances for 1.2, but
+          * if there is a call op defined.
-          * only if there is a call op defined otherwise.
           */
          if ((ops == &js_ObjectOps) ? clasp->call : ops->call) {
              ok = clasp->convert(cx, funobj, JSTYPE_FUNCTION, &v);
-Line 1141
+Line 1201
          if (FUN_INTERPRETED(fun)) {
              native = NULL;
              script = fun->u.i.script;
+             JS_ASSERT(script);
          } else {
              native = fun->u.n.native;
              script = NULL;
-Line 1265
+Line 1326
      frame.down = cx->fp;
      frame.annotation = NULL;
      frame.scopeChain = NULL;    /* set below for real, after cx->fp is set */
+     frame.blockChain = NULL;
      frame.regs = NULL;
      frame.imacpc = NULL;
      frame.slots = NULL;
-Line 1273
+Line 1335
      frame.flags = flags | rootedArgsFlag;
      frame.dormantNext = NULL;
      frame.xmlNamespace = NULL;
-     frame.blockChain = NULL;
+     frame.displaySave = NULL;
      MUST_FLOW_THROUGH("out");
      cx->fp = &frame;
-Line 1282
+Line 1344
      hook = cx->debugHooks->callHook;
      hookData = NULL;
-     /* call the hook if present */
-     if (hook && (native || script))
-         hookData = hook(cx, &frame, JS_TRUE, 0, cx->debugHooks->callHookData);
-     /* Call the function, either a native method or an interpreted script. */
      if (native) {
- #ifdef DEBUG_NOT_THROWING
-         JSBool alreadyThrowing = cx->throwing;
- #endif
- #if JS_HAS_LVALUE_RETURN
-         /* Set by JS_SetCallReturnValue2, used to return reference types. */
-         cx->rval2set = JS_FALSE;
- #endif
          /* If native, use caller varobj and scopeChain for eval. */
          JS_ASSERT(!frame.varobj);
          JS_ASSERT(!frame.scopeChain);
-Line 1308
+Line 1356
          /* But ensure that we have a scope chain. */
          if (!frame.scopeChain)
              frame.scopeChain = parent;
+     } else {
-         frame.displaySave = NULL;
-         ok = native(cx, frame.thisp, argc, frame.argv, &frame.rval);
-         JS_RUNTIME_METER(cx->runtime, nativeCalls);
- #ifdef DEBUG_NOT_THROWING
-         if (ok && !alreadyThrowing)
-             ASSERT_NOT_THROWING(cx);
- #endif
-     } else if (script) {
          /* Use parent scope so js_GetCallObject can find the right "Call". */
          frame.scopeChain = parent;
          if (JSFUN_HEAVYWEIGHT_TEST(fun->flags)) {
              /* Scope with a call object parented by the callee's parent. */
-             if (!js_GetCallObject(cx, &frame, parent)) {
+             if (!js_GetCallObject(cx, &frame)) {
                  ok = JS_FALSE;
                  goto out;
              }
          }
          frame.slots = sp - fun->u.i.nvars;
+     }
-         ok = js_Interpret(cx);
+     /* Call the hook if present after we fully initialized the frame. */
+     if (hook)
+         hookData = hook(cx, &frame, JS_TRUE, 0, cx->debugHooks->callHookData);
+     /* Call the function, either a native method or an interpreted script. */
+     if (native) {
+ #ifdef DEBUG_NOT_THROWING
+         JSBool alreadyThrowing = cx->throwing;
+ #endif
+ #if JS_HAS_LVALUE_RETURN
+         /* Set by JS_SetCallReturnValue2, used to return reference types. */
+         cx->rval2set = JS_FALSE;
+ #endif
+         ok = native(cx, frame.thisp, argc, frame.argv, &frame.rval);
+         JS_RUNTIME_METER(cx->runtime, nativeCalls);
+ #ifdef DEBUG_NOT_THROWING
+         if (ok && !alreadyThrowing)
+             ASSERT_NOT_THROWING(cx);
+ #endif
      } else {
-         /* fun might be onerror trying to report a syntax error in itself. */
+         JS_ASSERT(script);
-         frame.scopeChain = NULL;
+         ok = js_Interpret(cx);
-         frame.displaySave = NULL;
-         ok = JS_TRUE;
      }
  out:
-Line 1377
+Line 1435
      void *mark;
      JSBool ok;
+     js_LeaveTrace(cx);
      invokevp = js_AllocStack(cx, 2 + argc, &mark);
      if (!invokevp)
          return JS_FALSE;
-Line 1415
+Line 1474
  {
      JSSecurityCallbacks *callbacks;
+     js_LeaveTrace(cx);
      /*
       * js_InternalInvoke could result in another try to get or set the same id
       * again, see bug 355497.
-Line 1459
+Line 1520
      JSObject *obj, *tmp;
      JSBool ok;
+     js_LeaveTrace(cx);
  #ifdef INCLUDE_MOZILLA_DTRACE
      if (JAVASCRIPT_EXECUTE_START_ENABLED())
          jsdtrace_execute_start(script);
-Line 1466
+Line 1529
      hook = cx->debugHooks->executeHook;
      hookData = mark = NULL;
-     oldfp = cx->fp;
+     oldfp = js_GetTopStackFrame(cx);
      frame.script = script;
      if (down) {
          /* Propagate arg state for eval and the debugger API. */
-Line 1543
+Line 1606
      cx->fp = &frame;
      if (!down) {
-         OBJ_TO_OUTER_OBJECT(cx, frame.thisp);
+         frame.thisp = OBJ_THIS_OBJECT(cx, frame.thisp);
          if (!frame.thisp) {
              ok = JS_FALSE;
              goto out2;
-Line 1596
+Line 1659
      jsval value;
      const char *type, *name;
+     /*
+      * Both objp and propp must be either null or given. When given, *propp
+      * must be null. This way we avoid an extra "if (propp) *propp = NULL" for
+      * the common case of a non-existing property.
+      */
+     JS_ASSERT(!objp == !propp);
+     JS_ASSERT_IF(propp, !*propp);
+     /* The JSPROP_INITIALIZER case below may generate a warning. Since we must
+      * drop the property before reporting it, we insists on !propp to avoid
+      * looking up the property again after the reporting is done.
+      */
+     JS_ASSERT_IF(attrs & JSPROP_INITIALIZER, attrs == JSPROP_INITIALIZER);
+     JS_ASSERT_IF(attrs == JSPROP_INITIALIZER, !propp);
      if (!OBJ_LOOKUP_PROPERTY(cx, obj, id, &obj2, &prop))
          return JS_FALSE;
-     if (propp) {
-         *objp = obj2;
-         *propp = prop;
-     }
      if (!prop)
          return JS_TRUE;
-     /*
+     /* Use prop as a speedup hint to OBJ_GET_ATTRIBUTES. */
-      * Use prop as a speedup hint to OBJ_GET_ATTRIBUTES, but drop it on error.
-      * An assertion at label bad: will insist that it is null.
-      */
      if (!OBJ_GET_ATTRIBUTES(cx, obj2, id, prop, &oldAttrs)) {
          OBJ_DROP_PROPERTY(cx, obj2, prop);
- #ifdef DEBUG
+         return JS_FALSE;
-         prop = NULL;
- #endif
-         goto bad;
      }
      /*
-      * From here, return true, or else goto bad on failure to null out params.
       * If our caller doesn't want prop, drop it (we don't need it any longer).
       */
      if (!propp) {
          OBJ_DROP_PROPERTY(cx, obj2, prop);
          prop = NULL;
+     } else {
+         *objp = obj2;
+         *propp = prop;
      }
      if (attrs == JSPROP_INITIALIZER) {
          /* Allow the new object to override properties. */
          if (obj2 != obj)
              return JS_TRUE;
+         /* The property must be dropped already. */
+         JS_ASSERT(!prop);
          report = JSREPORT_WARNING | JSREPORT_STRICT;
      } else {
          /* We allow redeclaring some non-readonly properties. */
          if (((oldAttrs | attrs) & JSPROP_READONLY) == 0) {
-             /*
+             /* Allow redeclaration of variables and functions. */
-              * Allow redeclaration of variables and functions, but insist that
-              * the new value is not a getter if the old value was, ditto for
-              * setters -- unless prop is impermanent (in which case anyone
-              * could delete it and redefine it, willy-nilly).
-              */
              if (!(attrs & (JSPROP_GETTER | JSPROP_SETTER)))
                  return JS_TRUE;
+             /*
+              * Allow adding a getter only if a property already has a setter
+              * but no getter and similarly for adding a setter. That is, we
+              * allow only the following transitions:
+              *
+              *   no-property --> getter --> getter + setter
+              *   no-property --> setter --> getter + setter
+              */
              if ((~(oldAttrs ^ attrs) & (JSPROP_GETTER | JSPROP_SETTER)) == 0)
                  return JS_TRUE;
+             /*
+              * Allow redeclaration of an impermanent property (in which case
+              * anyone could delete it and redefine it, willy-nilly).
+              */
              if (!(oldAttrs & JSPROP_PERMANENT))
                  return JS_TRUE;
          }
+         if (prop)
+             OBJ_DROP_PROPERTY(cx, obj2, prop);
          report = JSREPORT_ERROR;
          isFunction = (oldAttrs & (JSPROP_GETTER | JSPROP_SETTER)) != 0;
          if (!isFunction) {
              if (!OBJ_GET_PROPERTY(cx, obj, id, &value))
-                 goto bad;
+                 return JS_FALSE;
              isFunction = VALUE_IS_FUNCTION(cx, value);
          }
      }
-Line 1670
+Line 1754
             : js_var_str;
      name = js_ValueToPrintableString(cx, ID_TO_VALUE(id));
      if (!name)
-         goto bad;
+         return JS_FALSE;
      return JS_ReportErrorFlagsAndNumber(cx, report,
                                          js_GetErrorMessage, NULL,
                                          JSMSG_REDECLARED_VAR,
                                          type, name);
- bad:
-     if (propp) {
-         *objp = NULL;
-         *propp = NULL;
-     }
-     JS_ASSERT(!prop);
-     return JS_FALSE;
  }
  JSBool
-Line 1728
+Line 1804
      return lval == rval;
  }
- JSBool
+ JS_REQUIRES_STACK JSBool
  js_InvokeConstructor(JSContext *cx, uintN argc, JSBool clampReturn, jsval *vp)
  {
      JSFunction *fun, *fun2;
-Line 1773
+Line 1849
          if (OBJ_GET_CLASS(cx, obj2) == &js_FunctionClass) {
              fun2 = GET_FUNCTION_PRIVATE(cx, obj2);
-             if (!FUN_INTERPRETED(fun2) &&
+             if (!FUN_INTERPRETED(fun2) && fun2->u.n.clasp)
-                 !(fun2->flags & JSFUN_TRACEABLE) &&
+                 clasp = fun2->u.n.clasp;
-                 fun2->u.n.u.clasp) {
-                 clasp = fun2->u.n.u.clasp;
-             }
          }
      }
      obj = js_NewObject(cx, clasp, proto, parent, 0);
-Line 1833
+Line 1906
   * Enter the new with scope using an object at sp[-1] and associate the depth
   * of the with block with sp + stackIndex.
   */
- JS_STATIC_INTERPRET JSBool
+ JS_STATIC_INTERPRET JS_REQUIRES_STACK JSBool
  js_EnterWith(JSContext *cx, jsint stackIndex)
  {
      JSStackFrame *fp;
-Line 1868
+Line 1941
          return JS_FALSE;
      fp->scopeChain = withobj;
-     js_DisablePropertyCache(cx);
      return JS_TRUE;
  }
- JS_STATIC_INTERPRET void
+ JS_STATIC_INTERPRET JS_REQUIRES_STACK void
  js_LeaveWith(JSContext *cx)
  {
      JSObject *withobj;
-Line 1883
+Line 1955
      JS_ASSERT(OBJ_BLOCK_DEPTH(cx, withobj) >= 0);
      cx->fp->scopeChain = OBJ_GET_PARENT(cx, withobj);
      JS_SetPrivate(cx, withobj, NULL);
-     js_EnablePropertyCache(cx);
  }
- JSClass *
+ JS_REQUIRES_STACK JSClass *
  js_IsActiveWithOrBlock(JSContext *cx, JSObject *obj, int stackDepth)
  {
      JSClass *clasp;
-Line 1900
+Line 1971
      return NULL;
  }
- JS_STATIC_INTERPRET jsint
- js_CountWithBlocks(JSContext *cx, JSStackFrame *fp)
- {
-     jsint n;
-     JSObject *obj;
-     JSClass *clasp;
-     n = 0;
-     for (obj = fp->scopeChain;
-          (clasp = js_IsActiveWithOrBlock(cx, obj, 0)) != NULL;
-          obj = OBJ_GET_PARENT(cx, obj)) {
-         if (clasp == &js_WithClass)
-             ++n;
-     }
-     return n;
- }
  /*
   * Unwind block and scope chains to match the given depth. The function sets
   * fp->sp on return to stackDepth.
   */
- JSBool
+ JS_REQUIRES_STACK JSBool
  js_UnwindScope(JSContext *cx, JSStackFrame *fp, jsint stackDepth,
                 JSBool normalUnwind)
  {
-Line 1989
+Line 2043
      return JS_TRUE;
  }
+ jsval&
+ js_GetUpvar(JSContext *cx, uintN level, uintN cookie)
+ {
+     level -= UPVAR_FRAME_SKIP(cookie);
+     JS_ASSERT(level < JS_DISPLAY_SIZE);
+     JSStackFrame *fp = cx->display[level];
+     JS_ASSERT(fp->script);
+     uintN slot = UPVAR_FRAME_SLOT(cookie);
+     jsval *vp;
+     if (!fp->fun) {
+         vp = fp->slots + fp->script->nfixed;
+     } else if (slot < fp->fun->nargs) {
+         vp = fp->argv;
+     } else if (slot == CALLEE_UPVAR_SLOT) {
+         vp = &fp->argv[-2];
+         slot = 0;
+     } else {
+         slot -= fp->fun->nargs;
+         JS_ASSERT(slot < fp->script->nslots);
+         vp = fp->slots;
+     }
+     return vp[slot];
+ }
  #ifdef DEBUG
- JS_STATIC_INTERPRET void
+ JS_STATIC_INTERPRET JS_REQUIRES_STACK void
- js_TraceOpcode(JSContext *cx, jsint len)
+ js_TraceOpcode(JSContext *cx)
  {
      FILE *tracefp;
      JSStackFrame *fp;
      JSFrameRegs *regs;
-     JSOp prevop;
      intN ndefs, n, nuses;
      jsval *siter;
      JSString *str;
-Line 2007
+Line 2088
      JS_ASSERT(tracefp);
      fp = cx->fp;
      regs = fp->regs;
-     if (len != 0) {
-         prevop = (JSOp) regs->pc[-len];
+     /*
-         ndefs = js_CodeSpec[prevop].ndefs;
+      * Operations in prologues don't produce interesting values, and
-         if (ndefs != 0) {
+      * js_DecompileValueGenerator isn't set up to handle them anyway.
+      */
+     if (cx->tracePrevPc && regs->pc >= fp->script->main) {
+         JSOp tracePrevOp = JSOp(*cx->tracePrevPc);
+         ndefs = js_GetStackDefs(cx, &js_CodeSpec[tracePrevOp], tracePrevOp,
+                                 fp->script, cx->tracePrevPc);
+         /*
+          * If there aren't that many elements on the stack, then
+          * we have probably entered a new frame, and printing output
+          * would just be misleading.
+          */
+         if (ndefs != 0 &&
+             ndefs < regs->sp - fp->slots) {
              for (n = -ndefs; n < 0; n++) {
                  char *bytes = js_DecompileValueGenerator(cx, n, regs->sp[n],
                                                           NULL);
-Line 2041
+Line 2135
                      PTRDIFF(regs->pc, fp->script->code, jsbytecode),
                      JS_FALSE, tracefp);
      op = (JSOp) *regs->pc;
-     nuses = js_CodeSpec[op].nuses;
+     nuses = js_GetStackUses(&js_CodeSpec[op], op, regs->pc);
      if (nuses != 0) {
          for (n = -nuses; n < 0; n++) {
              char *bytes = js_DecompileValueGenerator(cx, n, regs->sp[n],
-Line 2055
+Line 2149
          }
          fprintf(tracefp, " @ %u\n", (uintN) (regs->sp - StackBase(fp)));
      }
+     cx->tracePrevPc = regs->pc;
+     /* It's nice to have complete traces when debugging a crash.  */
+     fflush(tracefp);
  }
  #endif /* DEBUG */
-Line 2411
+Line 2509
  #endif
  /*
-  * Interpreter assumes the following to implement condition-free interrupt
+  * Deadlocks or else bad races are likely if JS_THREADSAFE, so we must rely on
-  * implementation when !JS_THREADED_INTERP.
+  * single-thread DEBUG js shell testing to verify property cache hits.
   */
- JS_STATIC_ASSERT(JSOP_INTERRUPT == 0);
+ #if defined DEBUG && !defined JS_THREADSAFE
+ # define ASSERT_VALID_PROPERTY_CACHE_HIT(pcoff,obj,pobj,entry)                \
+     JS_BEGIN_MACRO                                                            \
+         if (!AssertValidPropertyCacheHit(cx, script, regs, pcoff, obj, pobj,  \
+                                          entry)) {                            \
+             goto error;                                                       \
+         }                                                                     \
+     JS_END_MACRO
+ static bool
+ AssertValidPropertyCacheHit(JSContext *cx, JSScript *script, JSFrameRegs& regs,
+                             ptrdiff_t pcoff, JSObject *start, JSObject *found,
+                             JSPropCacheEntry *entry)
+ {
+     uint32 sample = cx->runtime->gcNumber;
+     JSAtom *atom;
+     if (pcoff >= 0)
+         GET_ATOM_FROM_BYTECODE(script, regs.pc, pcoff, atom);
+     else
+         atom = cx->runtime->atomState.lengthAtom;
+     JSObject *obj, *pobj;
+     JSProperty *prop;
+     bool ok;
+     if (JOF_OPMODE(*regs.pc) == JOF_NAME) {
+         ok = js_FindProperty(cx, ATOM_TO_JSID(atom), &obj, &pobj, &prop);
+     } else {
+         obj = start;
+         ok = js_LookupProperty(cx, obj, ATOM_TO_JSID(atom), &pobj, &prop);
+     }
+     if (!ok)
+         return false;
+     if (!prop)
+         return true;
+     if (cx->runtime->gcNumber != sample ||
+         PCVCAP_SHAPE(entry->vcap) != OBJ_SHAPE(pobj)) {
+         OBJ_DROP_PROPERTY(cx, pobj, prop);
+         return true;
+     }
+     JS_ASSERT(prop);
+     JS_ASSERT(pobj == found);
+     JSScopeProperty *sprop = (JSScopeProperty *) prop;
+     if (PCVAL_IS_SLOT(entry->vword)) {
+         JS_ASSERT(PCVAL_TO_SLOT(entry->vword) == sprop->slot);
+     } else if (PCVAL_IS_SPROP(entry->vword)) {
+         JS_ASSERT(PCVAL_TO_SPROP(entry->vword) == sprop);
+     } else {
+         jsval v;
+         JS_ASSERT(PCVAL_IS_OBJECT(entry->vword));
+         JS_ASSERT(entry->vword != PCVAL_NULL);
+         JS_ASSERT(SCOPE_IS_BRANDED(OBJ_SCOPE(pobj)));
+         JS_ASSERT(SPROP_HAS_STUB_GETTER(sprop));
+         JS_ASSERT(SPROP_HAS_VALID_SLOT(sprop, OBJ_SCOPE(pobj)));
+         v = LOCKED_OBJ_GET_SLOT(pobj, sprop->slot);
+         JS_ASSERT(VALUE_IS_FUNCTION(cx, v));
+         JS_ASSERT(PCVAL_TO_OBJECT(entry->vword) == JSVAL_TO_OBJECT(v));
+     }
+     OBJ_DROP_PROPERTY(cx, pobj, prop);
+     return true;
+ }
+ #else
+ # define ASSERT_VALID_PROPERTY_CACHE_HIT(pcoff,obj,pobj,entry) ((void) 0)
+ #endif
  /*
   * Ensure that the intrepreter switch can close call-bytecode cases in the
-Line 2423
+Line 2589
  JS_STATIC_ASSERT(JSOP_NAME_LENGTH == JSOP_CALLNAME_LENGTH);
  JS_STATIC_ASSERT(JSOP_GETGVAR_LENGTH == JSOP_CALLGVAR_LENGTH);
  JS_STATIC_ASSERT(JSOP_GETUPVAR_LENGTH == JSOP_CALLUPVAR_LENGTH);
+ JS_STATIC_ASSERT(JSOP_GETUPVAR_DBG_LENGTH == JSOP_CALLUPVAR_DBG_LENGTH);
+ JS_STATIC_ASSERT(JSOP_GETUPVAR_DBG_LENGTH == JSOP_GETUPVAR_LENGTH);
+ JS_STATIC_ASSERT(JSOP_GETDSLOT_LENGTH == JSOP_CALLDSLOT_LENGTH);
  JS_STATIC_ASSERT(JSOP_GETARG_LENGTH == JSOP_CALLARG_LENGTH);
  JS_STATIC_ASSERT(JSOP_GETLOCAL_LENGTH == JSOP_CALLLOCAL_LENGTH);
  JS_STATIC_ASSERT(JSOP_XMLNAME_LENGTH == JSOP_CALLXMLNAME_LENGTH);
  /*
+  * Same for debuggable flat closures defined at top level in another function
+  * or program fragment.
+  */
+ JS_STATIC_ASSERT(JSOP_DEFFUN_FC_LENGTH == JSOP_DEFFUN_DBGFC_LENGTH);
+ /*
   * Same for JSOP_SETNAME and JSOP_SETPROP, which differ only slightly but
-  * remain distinct for the decompiler. Ditto for JSOP_NULL{,THIS}.
+  * remain distinct for the decompiler.
   */
  JS_STATIC_ASSERT(JSOP_SETNAME_LENGTH == JSOP_SETPROP_LENGTH);
- JS_STATIC_ASSERT(JSOP_NULL_LENGTH == JSOP_NULLTHIS_LENGTH);
  /* See TRY_BRANCH_AFTER_COND. */
  JS_STATIC_ASSERT(JSOP_IFNE_LENGTH == JSOP_IFEQ_LENGTH);
-Line 2443
+Line 2617
  JS_STATIC_ASSERT(JSOP_INCNAME_LENGTH == JSOP_NAMEINC_LENGTH);
  JS_STATIC_ASSERT(JSOP_INCNAME_LENGTH == JSOP_NAMEDEC_LENGTH);
- JSBool
+ #ifdef JS_TRACER
+ # define ABORT_RECORDING(cx, reason)                                          \
+     JS_BEGIN_MACRO                                                            \
+         if (TRACE_RECORDER(cx))                                               \
+             js_AbortRecording(cx, reason);                                    \
+     JS_END_MACRO
+ #else
+ # define ABORT_RECORDING(cx, reason)    ((void) 0)
+ #endif
+ JS_REQUIRES_STACK JSBool
  js_Interpret(JSContext *cx)
  {
      JSRuntime *rt;
-Line 2472
+Line 2656
      JSClass *clasp;
      JSFunction *fun;
      JSType type;
- #if JS_THREADED_INTERP
-     register void * const *jumpTable;
- #else
-     register uint32 switchMask;
-     uintN switchOp;
- #endif
      jsint low, high, off, npairs;
      JSBool match;
  #if JS_HAS_GETTER_SETTER
-Line 2493
+Line 2671
  # define JS_EXTENSION_(s) s
  #endif
+ # ifdef DEBUG
+     /*
+      * We call this macro from BEGIN_CASE in threaded interpreters,
+      * and before entering the switch in non-threaded interpreters.
+      * However, reaching such points doesn't mean we've actually
+      * fetched an OP from the instruction stream: some opcodes use
+      * 'op=x; DO_OP()' to let another opcode's implementation finish
+      * their work, and many opcodes share entry points with a run of
+      * consecutive BEGIN_CASEs.
+      *
+      * Take care to trace OP only when it is the opcode fetched from
+      * the instruction stream, so the trace matches what one would
+      * expect from looking at the code.  (We do omit POPs after SETs;
+      * unfortunate, but not worth fixing.)
+      */
+ #  define TRACE_OPCODE(OP)  JS_BEGIN_MACRO                                    \
+                                 if (JS_UNLIKELY(cx->tracefp != NULL) &&       \
+                                     (OP) == *regs.pc)                         \
+                                     js_TraceOpcode(cx);                       \
+                             JS_END_MACRO
+ # else
+ #  define TRACE_OPCODE(OP)  ((void) 0)
+ # endif
  #if JS_THREADED_INTERP
      static void *const normalJumpTable[] = {
  # define OPDEF(op,val,name,token,length,nuses,ndefs,prec,format) \
-Line 2501
+Line 2703
  # undef OPDEF
      };
- #ifdef JS_TRACER
-     static void *const recordingJumpTable[] = {
- # define OPDEF(op,val,name,token,length,nuses,ndefs,prec,format) \
-         JS_EXTENSION &&R_##op,
- # include "jsopcode.tbl"
- # undef OPDEF
-     };
- #endif /* JS_TRACER */
      static void *const interruptJumpTable[] = {
  # define OPDEF(op,val,name,token,length,nuses,ndefs,prec,format)              \
-         JS_EXTENSION &&L_JSOP_INTERRUPT,
+         JS_EXTENSION &&interrupt,
  # include "jsopcode.tbl"
  # undef OPDEF
      };
+     register void * const *jumpTable = normalJumpTable;
      METER_OP_INIT(op);      /* to nullify first METER_OP_PAIR */
+ # define ENABLE_INTERRUPTS() ((void) (jumpTable = interruptJumpTable))
  # ifdef JS_TRACER
- #  define CHECK_RECORDER()  JS_BEGIN_MACRO                                    \
+ #  define CHECK_RECORDER()                                                    \
-                                 JS_ASSERT(!TRACE_RECORDER(cx) ^               \
+     JS_ASSERT_IF(TRACE_RECORDER(cx), jumpTable == interruptJumpTable)
-                                           (jumpTable == recordingJumpTable)); \
-                             JS_END_MACRO
  # else
  #  define CHECK_RECORDER()  ((void)0)
  # endif
-Line 2538
+Line 2733
                                  DO_OP();                                      \
                              JS_END_MACRO
- # define BEGIN_CASE(OP)     L_##OP:                                           \
+ # define BEGIN_CASE(OP)     L_##OP: TRACE_OPCODE(OP); CHECK_RECORDER();
-                                 CHECK_RECORDER();
  # define END_CASE(OP)       DO_NEXT_OP(OP##_LENGTH);
  # define END_VARLEN_CASE    DO_NEXT_OP(len);
  # define ADD_EMPTY_CASE(OP) BEGIN_CASE(OP)                                    \
-Line 2551
+Line 2745
  #else /* !JS_THREADED_INTERP */
+     register intN switchMask = 0;
+     intN switchOp;
+ # define ENABLE_INTERRUPTS() ((void) (switchMask = -1))
+ # ifdef JS_TRACER
+ #  define CHECK_RECORDER()                                                    \
+     JS_ASSERT_IF(TRACE_RECORDER(cx), switchMask == -1)
+ # else
+ #  define CHECK_RECORDER()  ((void)0)
+ # endif
  # define DO_OP()            goto do_op
  # define DO_NEXT_OP(n)      JS_BEGIN_MACRO                                    \
                                  JS_ASSERT((n) == len);                        \
                                  goto advance_pc;                              \
                              JS_END_MACRO
- # define BEGIN_CASE(OP)     case OP:
+ # define BEGIN_CASE(OP)     case OP: CHECK_RECORDER();
  # define END_CASE(OP)       END_CASE_LEN(OP##_LENGTH)
  # define END_CASE_LEN(n)    END_CASE_LENX(n)
  # define END_CASE_LENX(n)   END_CASE_LEN##n
-Line 2579
+Line 2785
  #ifdef JS_TRACER
      /* We had better not be entering the interpreter from JIT-compiled code. */
-     TraceRecorder *tr = NULL;
+     TraceRecorder *tr = TRACE_RECORDER(cx);
-     if (JS_ON_TRACE(cx)) {
+     SET_TRACE_RECORDER(cx, NULL);
-         tr = TRACE_RECORDER(cx);
-         SET_TRACE_RECORDER(cx, NULL);
+     /* If a recorder is pending and we try to re-enter the interpreter, flag
-         JS_TRACE_MONITOR(cx).onTrace = JS_FALSE;
+        the recorder to be destroyed when we return. */
-         /*
+     if (tr) {
-          * ON_TRACE means either recording or coming from traced code.
+         if (tr->wasDeepAborted())
-          * If there's no recorder (the latter case), don't care.
+             tr->removeFragmentoReferences();
-          */
+         else
-         if (tr) {
+             tr->pushAbortStack();
-             if (tr->wasDeepAborted())
-                 tr->removeFragmentoReferences();
-             else
-                 tr->pushAbortStack();
-         }
      }
  #endif
-Line 2644
+Line 2845
  #define MONITOR_BRANCH()                                                      \
      JS_BEGIN_MACRO                                                            \
          if (TRACING_ENABLED(cx)) {                                            \
-             ENABLE_TRACER(js_MonitorLoopEdge(cx, inlineCallCount));           \
+             if (js_MonitorLoopEdge(cx, inlineCallCount)) {                    \
+                 JS_ASSERT(TRACE_RECORDER(cx));                                \
+                 ENABLE_INTERRUPTS();                                          \
+             }                                                                 \
              fp = cx->fp;                                                      \
              script = fp->script;                                              \
-             atoms = script->atomMap.vector;                                   \
+             atoms = FrameAtomBase(cx, fp);                                    \
              currentVersion = (JSVersion) script->version;                     \
              JS_ASSERT(fp->regs == &regs);                                     \
              if (cx->throwing)                                                 \
-Line 2667
+Line 2871
       */
  #define CHECK_BRANCH()                                                        \
      JS_BEGIN_MACRO                                                            \
-         if ((cx->operationCount -= JSOW_SCRIPT_JUMP) <= 0) {                  \
+         if (!JS_CHECK_OPERATION_LIMIT(cx))                                    \
-             if (!js_ResetOperationCount(cx))                                  \
+             goto error;                                                       \
-                 goto error;                                                   \
-         }                                                                     \
      JS_END_MACRO
+ #ifndef TRACE_RECORDER
+ #define TRACE_RECORDER(cx) (false)
+ #endif
  #define BRANCH(n)                                                             \
      JS_BEGIN_MACRO                                                            \
-         regs.pc += n;                                                         \
+         regs.pc += (n);                                                       \
-         if (n <= 0) {                                                         \
+         op = (JSOp) *regs.pc;                                                 \
+         if ((n) <= 0) {                                                       \
              CHECK_BRANCH();                                                   \
-             MONITOR_BRANCH();                                                 \
+             if (op == JSOP_NOP) {                                             \
+                 if (TRACE_RECORDER(cx)) {                                     \
+                     MONITOR_BRANCH();                                         \
+                     op = (JSOp) *regs.pc;                                     \
+                 } else {                                                      \
+                     op = (JSOp) *++regs.pc;                                   \
+                 }                                                             \
+             } else if (op == JSOP_LOOP) {                                     \
+                 MONITOR_BRANCH();                                             \
+                 op = (JSOp) *regs.pc;                                         \
+             }                                                                 \
          }                                                                     \
-         op = (JSOp) *regs.pc;                                                 \
          DO_OP();                                                              \
      JS_END_MACRO
-Line 2702
+Line 2918
          js_SetVersion(cx, currentVersion);
      /* Update the static-link display. */
-     if (script->staticDepth < JS_DISPLAY_SIZE) {
+     if (script->staticLevel < JS_DISPLAY_SIZE) {
-         JSStackFrame **disp = &cx->display[script->staticDepth];
+         JSStackFrame **disp = &cx->display[script->staticLevel];
          fp->displaySave = *disp;
          *disp = fp;
      }
- #ifdef DEBUG
-     fp->pcDisabledSave = JS_PROPERTY_CACHE(cx).disabled;
+ # define CHECK_INTERRUPT_HANDLER()                                            \
- #endif
+     JS_BEGIN_MACRO                                                            \
+         if (cx->debugHooks->interruptHandler)                                 \
+             ENABLE_INTERRUPTS();                                              \
+     JS_END_MACRO
      /*
       * Load the debugger's interrupt hook here and after calling out to native
-Line 2717
+Line 2936
       * not have to reload it each time through the interpreter loop -- we hope
       * the compiler can keep it in a register when it is non-null.
       */
- #if JS_THREADED_INTERP
+     CHECK_INTERRUPT_HANDLER();
- #ifdef JS_TRACER
- # define LOAD_INTERRUPT_HANDLER(cx)                                           \
-     ((void) (jumpTable = (cx)->debugHooks->interruptHandler                   \
-                          ? interruptJumpTable                                 \
-                          : TRACE_RECORDER(cx)                                 \
-                          ? recordingJumpTable                                 \
-                          : normalJumpTable))
- # define ENABLE_TRACER(flag)                                                  \
-     JS_BEGIN_MACRO                                                            \
-         bool flag_ = (flag);                                                  \
-         JS_ASSERT(flag_ == !!TRACE_RECORDER(cx));                             \
-         jumpTable = flag_ ? recordingJumpTable : normalJumpTable;             \
-     JS_END_MACRO
- #else /* !JS_TRACER */
- # define LOAD_INTERRUPT_HANDLER(cx)                                           \
-     ((void) (jumpTable = (cx)->debugHooks->interruptHandler                   \
-                          ? interruptJumpTable                                 \
-                          : normalJumpTable))
- # define ENABLE_TRACER(flag) ((void)0)
- #endif /* !JS_TRACER */
- #else /* !JS_THREADED_INTERP */
- #ifdef JS_TRACER
- # define LOAD_INTERRUPT_HANDLER(cx)                                           \
-     ((void) (switchMask = ((cx)->debugHooks->interruptHandler ||              \
-                            TRACE_RECORDER(cx)) ? 0 : 255))
- # define ENABLE_TRACER(flag)                                                  \
-     JS_BEGIN_MACRO                                                            \
-         bool flag_ = (flag);                                                  \
-         JS_ASSERT(flag_ == !!TRACE_RECORDER(cx));                             \
-         switchMask = flag_ ? 0 : 255;                                         \
-     JS_END_MACRO
- #else /* !JS_TRACER */
- # define LOAD_INTERRUPT_HANDLER(cx)                                           \
-     ((void) (switchMask = ((cx)->debugHooks->interruptHandler                 \
-                            ? 0 : 255)))
- # define ENABLE_TRACER(flag) ((void)0)
- #endif /* !JS_TRACER */
- #endif /* !JS_THREADED_INTERP */
-     LOAD_INTERRUPT_HANDLER(cx);
  #if !JS_HAS_GENERATORS
      JS_ASSERT(!fp->regs);
-Line 2780
+Line 2959
          fp->regs = &regs;
          JS_ASSERT((size_t) (regs.pc - script->code) <= script->length);
          JS_ASSERT((size_t) (regs.sp - StackBase(fp)) <= StackDepth(script));
-         JS_ASSERT(JS_PROPERTY_CACHE(cx).disabled >= 0);
-         JS_PROPERTY_CACHE(cx).disabled += js_CountWithBlocks(cx, fp);
          /*
           * To support generator_throw and to catch ignored exceptions,
-Line 2813
+Line 2990
       * This is a loop, but it does not look like a loop. The loop-closing
       * jump is distributed throughout goto *jumpTable[op] inside of DO_OP.
       * When interrupts are enabled, jumpTable is set to interruptJumpTable
-      * where all jumps point to the JSOP_INTERRUPT case. The latter, after
+      * where all jumps point to the interrupt label. The latter, after
       * calling the interrupt handler, dispatches through normalJumpTable to
       * continue the normal bytecode processing.
       */
- #else
+   interrupt:
+ #else /* !JS_THREADED_INTERP */
      for (;;) {
        advance_pc_by_one:
          JS_ASSERT(js_CodeSpec[op].length == 1);
-Line 2825
+Line 3003
        advance_pc:
          regs.pc += len;
          op = (JSOp) *regs.pc;
- #ifdef DEBUG
-         if (cx->tracefp)
-             js_TraceOpcode(cx, len);
- #endif
        do_op:
-         switchOp = op & switchMask;
+         CHECK_RECORDER();
+         TRACE_OPCODE(op);
+         switchOp = intN(op) | switchMask;
        do_switch:
          switch (switchOp) {
+           case -1:
+             JS_ASSERT(switchMask == -1);
  #endif /* !JS_THREADED_INTERP */
-           BEGIN_CASE(JSOP_INTERRUPT)
            {
-             JSTrapHandler handler;
+             bool moreInterrupts = false;
+             JSTrapHandler handler = cx->debugHooks->interruptHandler;
-             handler = cx->debugHooks->interruptHandler;
              if (handler) {
+ #ifdef JS_TRACER
+                 if (TRACE_RECORDER(cx))
+                     js_AbortRecording(cx, "interrupt handler");
+ #endif
                  switch (handler(cx, script, regs.pc, &rval,
                                  cx->debugHooks->interruptHandlerData)) {
                    case JSTRAP_ERROR:
-Line 2858
+Line 3037
                      goto error;
                    default:;
                  }
- #if !JS_THREADED_INTERP
+                 moreInterrupts = true;
-             } else {
-                 /* this was not a real interrupt, the tracer is trying to
-                    record a trace */
-                 switchOp = op + 256;
-                 goto do_switch;
- #endif
              }
-             LOAD_INTERRUPT_HANDLER(cx);
+ #ifdef JS_TRACER
+             TraceRecorder* tr = TRACE_RECORDER(cx);
+             if (tr) {
+                 JSRecordingStatus status = TraceRecorder::monitorRecording(cx, tr, op);
+                 switch (status) {
+                 case JSRS_CONTINUE:
+                     moreInterrupts = true;
+                     break;
+                 case JSRS_IMACRO:
+                     atoms = COMMON_ATOMS_START(&rt->atomState);
+                     op = JSOp(*regs.pc);
+                     DO_OP();    /* keep interrupting for op. */
+                     break;
+                 case JSRS_ERROR:
+                     // The code at 'error:' aborts the recording.
+                     goto error;
+                 case JSRS_STOP:
+                     break;
+                 default:
+                     JS_NOT_REACHED("Bad recording status");
+                 }
+             }
+ #endif /* !JS_TRACER */
  #if JS_THREADED_INTERP
+             jumpTable = moreInterrupts ? interruptJumpTable : normalJumpTable;
              JS_EXTENSION_(goto *normalJumpTable[op]);
  #else
-             switchOp = op;
+             switchMask = moreInterrupts ? -1 : 0;
+             switchOp = intN(op);
              goto do_switch;
  #endif
            }
-Line 2880
+Line 3078
            ADD_EMPTY_CASE(JSOP_NOP)
            ADD_EMPTY_CASE(JSOP_CONDSWITCH)
            ADD_EMPTY_CASE(JSOP_TRY)
-           ADD_EMPTY_CASE(JSOP_FINALLY)
  #if JS_HAS_XML_SUPPORT
            ADD_EMPTY_CASE(JSOP_STARTXML)
            ADD_EMPTY_CASE(JSOP_STARTXMLEXPR)
-Line 2951
+Line 3148
            END_CASE(JSOP_LEAVEWITH)
            BEGIN_CASE(JSOP_RETURN)
-             CHECK_BRANCH();
              fp->rval = POP_OPND();
              /* FALL THROUGH */
-Line 2962
+Line 3158
               * will be false after the inline_return label.
               */
              ASSERT_NOT_THROWING(cx);
+             CHECK_BRANCH();
              if (fp->imacpc) {
                  /*
-Line 2997
+Line 3194
                  JSInlineFrame *ifp = (JSInlineFrame *) fp;
                  void *hookData = ifp->hookData;
-                 JS_ASSERT(JS_PROPERTY_CACHE(cx).disabled == fp->pcDisabledSave);
                  JS_ASSERT(!fp->blockChain);
                  JS_ASSERT(!js_IsActiveWithOrBlock(cx, fp->scopeChain, 0));
-                 if (script->staticDepth < JS_DISPLAY_SIZE)
+                 if (script->staticLevel < JS_DISPLAY_SIZE)
-                     cx->display[script->staticDepth] = fp->displaySave;
+                     cx->display[script->staticLevel] = fp->displaySave;
                  if (hookData) {
                      JSInterpreterHook hook;
-Line 3017
+Line 3213
                          status = ok;
                          hook(cx, fp, JS_FALSE, &status, hookData);
                          ok = status;
-                         LOAD_INTERRUPT_HANDLER(cx);
+                         CHECK_INTERRUPT_HANDLER();
                      }
                  }
-Line 3074
+Line 3270
                  /* Restore the calling script's interpreter registers. */
                  script = fp->script;
-                 atoms = script->atomMap.vector;
+                 atoms = FrameAtomBase(cx, fp);
                  /* Resume execution in the calling frame. */
                  inlineCallCount--;
                  if (JS_LIKELY(ok)) {
                      TRACE_0(LeaveFrame);
-                     JS_ASSERT(js_CodeSpec[*regs.pc].length == JSOP_CALL_LENGTH);
+                     JS_ASSERT(js_CodeSpec[js_GetOpcode(cx, script, regs.pc)].length
+                               == JSOP_CALL_LENGTH);
                      len = JSOP_CALL_LENGTH;
                      DO_NEXT_OP(len);
                  }
-Line 3230
+Line 3427
              flags = regs.pc[1];
              if (!js_ValueToIterator(cx, flags, &regs.sp[-1]))
                  goto error;
-             LOAD_INTERRUPT_HANDLER(cx);
+             CHECK_INTERRUPT_HANDLER();
              JS_ASSERT(!JSVAL_IS_PRIMITIVE(regs.sp[-1]));
              PUSH(JSVAL_VOID);
            END_CASE(JSOP_ITER)
-Line 3240
+Line 3437
              JS_ASSERT(!JSVAL_IS_PRIMITIVE(regs.sp[-2]));
              if (!js_CallIteratorNext(cx, JSVAL_TO_OBJECT(regs.sp[-2]), &regs.sp[-1]))
                  goto error;
-             LOAD_INTERRUPT_HANDLER(cx);
+             CHECK_INTERRUPT_HANDLER();
              rval = BOOLEAN_TO_JSVAL(regs.sp[-1] != JSVAL_HOLE);
              PUSH(rval);
-             TRACE_0(IteratorNextComplete);
            END_CASE(JSOP_NEXTITER)
            BEGIN_CASE(JSOP_ENDITER)
-Line 3270
+Line 3466
              slot = GET_SLOTNO(regs.pc);
              JS_ASSERT(slot < fp->script->nslots);
              vp = &fp->slots[slot];
-             GC_POKE(cx, *vp);
              *vp = regs.sp[-1];
            END_CASE(JSOP_FORLOCAL)
-Line 3332
+Line 3527
              STORE_OPND(-2, rval);
            END_CASE(JSOP_SWAP)
+           BEGIN_CASE(JSOP_PICK)
+             i = regs.pc[1];
+             JS_ASSERT(regs.sp - (i+1) >= StackBase(fp));
+             lval = regs.sp[-(i+1)];
+             memmove(regs.sp - (i+1), regs.sp - i, sizeof(jsval)*i);
+             regs.sp[-1] = lval;
+           END_CASE(JSOP_PICK)
  #define PROPERTY_OP(n, call)                                                  \
      JS_BEGIN_MACRO                                                            \
          /* Fetch the left part and resolve it to a non-null object. */        \
-Line 3370
+Line 3573
          }                                                                     \
      JS_END_MACRO
- #define NATIVE_SET(cx,obj,sprop,vp)                                           \
+ #define NATIVE_SET(cx,obj,sprop,entry,vp)                                     \
      JS_BEGIN_MACRO                                                            \
+         TRACE_2(SetPropHit, entry, sprop);                                    \
          if (SPROP_HAS_STUB_SETTER(sprop) &&                                   \
              (sprop)->slot != SPROP_INVALID_SLOT) {                            \
              /* Fast path for, e.g., Object instance properties. */            \
-Line 3383
+Line 3587
      JS_END_MACRO
  /*
-  * Deadlocks or else bad races are likely if JS_THREADSAFE, so we must rely on
-  * single-thread DEBUG js shell testing to verify property cache hits.
-  */
- #if defined DEBUG && !defined JS_THREADSAFE
- # define ASSERT_VALID_PROPERTY_CACHE_HIT(pcoff,obj,pobj,entry)                \
-     do {                                                                      \
-         JSAtom *atom_;                                                        \
-         JSObject *obj_, *pobj_;                                               \
-         JSProperty *prop_;                                                    \
-         JSScopeProperty *sprop_;                                              \
-         uint32 sample_ = rt->gcNumber;                                        \
-         if (pcoff >= 0)                                                       \
-             GET_ATOM_FROM_BYTECODE(script, regs.pc, pcoff, atom_);            \
-         else                                                                  \
-             atom_ = rt->atomState.lengthAtom;                                 \
-         if (JOF_OPMODE(*regs.pc) == JOF_NAME) {                               \
-             ok = js_FindProperty(cx, ATOM_TO_JSID(atom_), &obj_, &pobj_,      \
-                                  &prop_);                                     \
-         } else {                                                              \
-             obj_ = obj;                                                       \
-             ok = js_LookupProperty(cx, obj, ATOM_TO_JSID(atom_), &pobj_,      \
-                                    &prop_);                                   \
-         }                                                                     \
-         if (!ok)                                                              \
-             goto error;                                                       \
-         if (rt->gcNumber != sample_)                                          \
-             break;                                                            \
-         JS_ASSERT(prop_);                                                     \
-         JS_ASSERT(pobj_ == pobj);                                             \
-         sprop_ = (JSScopeProperty *) prop_;                                   \
-         if (PCVAL_IS_SLOT(entry->vword)) {                                    \
-             JS_ASSERT(PCVAL_TO_SLOT(entry->vword) == sprop_->slot);           \
-         } else if (PCVAL_IS_SPROP(entry->vword)) {                            \
-             JS_ASSERT(PCVAL_TO_SPROP(entry->vword) == sprop_);                \
-         } else {                                                              \
-             jsval v_;                                                         \
-             JS_ASSERT(PCVAL_IS_OBJECT(entry->vword));                         \
-             JS_ASSERT(entry->vword != PCVAL_NULL);                            \
-             JS_ASSERT(SCOPE_IS_BRANDED(OBJ_SCOPE(pobj)));                     \
-             JS_ASSERT(SPROP_HAS_STUB_GETTER(sprop_));                         \
-             JS_ASSERT(SPROP_HAS_VALID_SLOT(sprop_, OBJ_SCOPE(pobj_)));        \
-             v_ = LOCKED_OBJ_GET_SLOT(pobj_, sprop_->slot);                    \
-             JS_ASSERT(VALUE_IS_FUNCTION(cx, v_));                             \
-             JS_ASSERT(PCVAL_TO_OBJECT(entry->vword) == JSVAL_TO_OBJECT(v_));  \
-         }                                                                     \
-         OBJ_DROP_PROPERTY(cx, pobj_, prop_);                                  \
-     } while (0)
- #else
- # define ASSERT_VALID_PROPERTY_CACHE_HIT(pcoff,obj,pobj,entry) ((void) 0)
- #endif
- /*
   * Skip the JSOP_POP typically found after a JSOP_SET* opcode, where oplen is
   * the constant length of the SET opcode sequence, and spdec is the constant
   * by which to decrease the stack pointer to pop all of the SET op's operands.
-Line 3497
+Line 3649
              do {
                  JSPropCacheEntry *entry;
+                 /*
+                  * We can skip the property lookup for the global object. If
+                  * the property does not exist anywhere on the scope chain,
+                  * JSOP_SETNAME adds the property to the global.
+                  *
+                  * As a consequence of this optimization for the global object
+                  * we run its JSRESOLVE_ASSIGNING-tolerant resolve hooks only
+                  * in JSOP_SETNAME, after the interpreter evaluates the right-
+                  * hand-side of the assignment, and not here.
+                  *
+                  * This should be transparent to the hooks because the script,
+                  * instead of name = rhs, could have used global.name = rhs
+                  * given a global object reference, which also calls the hooks
+                  * only after evaluating the rhs. We desire such resolve hook
+                  * equivalence between the two forms.
+                  */
                  obj = fp->scopeChain;
+                 if (!OBJ_GET_PARENT(cx, obj))
+                     break;
                  if (JS_LIKELY(OBJ_IS_NATIVE(obj))) {
                      PROPERTY_CACHE_TEST(cx, regs.pc, obj, obj2, entry, atom);
                      if (!atom) {
-Line 3510
+Line 3680
                      LOAD_ATOM(0);
                  }
                  id = ATOM_TO_JSID(atom);
-                 obj = js_FindIdentifierBase(cx, id, entry);
+                 obj = js_FindIdentifierBase(cx, fp->scopeChain, id);
                  if (!obj)
                      goto error;
              } while (0);
-Line 3583
+Line 3753
          (rtmp == JSVAL_OBJECT &&                                              \
           (obj2 = JSVAL_TO_OBJECT(rval)) &&                                    \
           OBJECT_IS_XML(cx, obj2))) {                                          \
-         JSXMLObjectOps *ops;                                                  \
+         if (JSVAL_IS_OBJECT(rval) && obj2 == JSVAL_TO_OBJECT(rval))           \
-                                                                               \
-         ops = (JSXMLObjectOps *) obj2->map->ops;                              \
-         if (obj2 == JSVAL_TO_OBJECT(rval))                                    \
              rval = lval;                                                      \
-         if (!ops->equality(cx, obj2, rval, &cond))                            \
+         if (!js_TestXMLEquality(cx, obj2, rval, &cond))                       \
              goto error;                                                       \
          cond = cond OP JS_TRUE;                                               \
      } else
-Line 3762
+Line 3929
              if (!JSVAL_IS_PRIMITIVE(lval) &&
                  (obj2 = JSVAL_TO_OBJECT(lval), OBJECT_IS_XML(cx, obj2)) &&
                  VALUE_IS_XML(cx, rval)) {
-                 JSXMLObjectOps *ops;
+                 if (!js_ConcatenateXML(cx, obj2, rval, &rval))
-                 ops = (JSXMLObjectOps *) obj2->map->ops;
-                 if (!ops->concatenate(cx, obj2, rval, &rval))
                      goto error;
                  regs.sp--;
                  STORE_OPND(-1, rval);
-Line 4008
+Line 4172
                      ASSERT_VALID_PROPERTY_CACHE_HIT(0, obj, obj2, entry);
                      if (obj == obj2 && PCVAL_IS_SLOT(entry->vword)) {
                          slot = PCVAL_TO_SLOT(entry->vword);
-                         JS_ASSERT(slot < obj->map->freeslot);
+                         JS_ASSERT(slot < OBJ_SCOPE(obj)->freeslot);
                          rval = LOCKED_OBJ_GET_SLOT(obj, slot);
                          if (JS_LIKELY(CAN_DO_FAST_INC_DEC(rval))) {
                              rtmp = rval;
-Line 4026
+Line 4190
                      LOAD_ATOM(0);
                  }
              } else {
-                 entry = NULL;
                  LOAD_ATOM(0);
              }
              id = ATOM_TO_JSID(atom);
-             if (js_FindPropertyHelper(cx, id, &obj, &obj2, &prop, &entry) < 0)
+             if (!js_FindPropertyHelper(cx, id, true, &obj, &obj2, &prop))
                  goto error;
              if (!prop)
                  goto atom_not_defined;
-Line 4210
+Line 4373
  #define COMPUTE_THIS(cx, fp, obj)                                             \
      JS_BEGIN_MACRO                                                            \
-         if (fp->flags & JSFRAME_COMPUTED_THIS) {                              \
+         if (!(obj = js_ComputeThisForFrame(cx, fp)))                          \
-             obj = fp->thisp;                                                  \
+             goto error;                                                       \
-         } else {                                                              \
-             obj = js_ComputeThis(cx, JS_TRUE, fp->argv);                      \
-             if (!obj)                                                         \
-                 goto error;                                                   \
-             fp->thisp = obj;                                                  \
-             fp->flags |= JSFRAME_COMPUTED_THIS;                               \
-         }                                                                     \
      JS_END_MACRO
            BEGIN_CASE(JSOP_THIS)
-Line 4263
+Line 4419
                  JSObject *aobj;
                  JSPropCacheEntry *entry;
-                 aobj = OBJ_IS_DENSE_ARRAY(cx, obj) ? OBJ_GET_PROTO(cx, obj) : obj;
+                 aobj = js_GetProtoIfDenseArray(cx, obj);
                  if (JS_LIKELY(aobj->map->ops->getProperty == js_GetProperty)) {
                      PROPERTY_CACHE_TEST(cx, regs.pc, aobj, obj2, entry, atom);
                      if (!atom) {
-Line 4272
+Line 4428
                              rval = PCVAL_OBJECT_TO_JSVAL(entry->vword);
                          } else if (PCVAL_IS_SLOT(entry->vword)) {
                              slot = PCVAL_TO_SLOT(entry->vword);
-                             JS_ASSERT(slot < obj2->map->freeslot);
+                             JS_ASSERT(slot < OBJ_SCOPE(obj2)->freeslot);
                              rval = LOCKED_OBJ_GET_SLOT(obj2, slot);
                          } else {
                              JS_ASSERT(PCVAL_IS_SPROP(entry->vword));
-Line 4291
+Line 4447
                  }
                  id = ATOM_TO_JSID(atom);
                  if (entry
-                     ? !js_GetPropertyHelper(cx, aobj, id, &rval, &entry)
+                     ? !js_GetPropertyHelper(cx, obj, id, true, &rval)
                      : !OBJ_GET_PROPERTY(cx, obj, id, &rval)) {
                      goto error;
                  }
-Line 4354
+Line 4510
                      goto error;
              }
-             aobj = OBJ_IS_DENSE_ARRAY(cx, obj) ? OBJ_GET_PROTO(cx, obj) : obj;
+             aobj = js_GetProtoIfDenseArray(cx, obj);
              if (JS_LIKELY(aobj->map->ops->getProperty == js_GetProperty)) {
                  PROPERTY_CACHE_TEST(cx, regs.pc, aobj, obj2, entry, atom);
                  if (!atom) {
-Line 4363
+Line 4519
                          rval = PCVAL_OBJECT_TO_JSVAL(entry->vword);
                      } else if (PCVAL_IS_SLOT(entry->vword)) {
                          slot = PCVAL_TO_SLOT(entry->vword);
-                         JS_ASSERT(slot < obj2->map->freeslot);
+                         JS_ASSERT(slot < OBJ_SCOPE(obj2)->freeslot);
                          rval = LOCKED_OBJ_GET_SLOT(obj2, slot);
                      } else {
                          JS_ASSERT(PCVAL_IS_SPROP(entry->vword));
-Line 4387
+Line 4543
              id = ATOM_TO_JSID(atom);
              PUSH(JSVAL_NULL);
              if (!JSVAL_IS_PRIMITIVE(lval)) {
- #if JS_HAS_XML_SUPPORT
+                 if (!js_GetMethod(cx, obj, id, !!entry, &rval))
-                 /* Special-case XML object method lookup, per ECMA-357. */
-                 if (OBJECT_IS_XML(cx, obj)) {
-                     JSXMLObjectOps *ops;
-                     ops = (JSXMLObjectOps *) obj->map->ops;
-                     obj = ops->getMethod(cx, obj, id, &rval);
-                     if (!obj)
-                         goto error;
-                 } else
- #endif
-                 if (entry
-                     ? !js_GetPropertyHelper(cx, aobj, id, &rval, &entry)
-                     : !OBJ_GET_PROPERTY(cx, obj, id, &rval)) {
                      goto error;
-                 }
                  STORE_OPND(-1, OBJECT_TO_JSVAL(obj));
                  STORE_OPND(-2, rval);
              } else {
                  JS_ASSERT(obj->map->ops->getProperty == js_GetProperty);
-                 if (!js_GetPropertyHelper(cx, obj, id, &rval, &entry))
+                 if (!js_GetPropertyHelper(cx, obj, id, true, &rval))
                      goto error;
                  STORE_OPND(-1, lval);
                  STORE_OPND(-2, rval);
-Line 4472
+Line 4614
                       * in native object o.
                       */
                      entry = &cache->table[PROPERTY_CACHE_HASH_PC(regs.pc, kshape)];
+                     PCMETER(cache->pctestentry = entry);
                      PCMETER(cache->tests++);
                      PCMETER(cache->settests++);
-                     if (entry->kpc == regs.pc && entry->kshape == kshape) {
+                     if (entry->kpc == regs.pc &&
-                         JSScope *scope;
+                         entry->kshape == kshape &&
+                         PCVCAP_SHAPE(entry->vcap) == rt->protoHazardShape) {
+                         JS_ASSERT(PCVCAP_TAG(entry->vcap) == 0);
                          JS_LOCK_OBJ(cx, obj);
-                         scope = OBJ_SCOPE(obj);
+                         JSScope *scope = OBJ_SCOPE(obj);
                          if (scope->shape == kshape) {
                              JS_ASSERT(PCVAL_IS_SPROP(entry->vword));
                              sprop = PCVAL_TO_SPROP(entry->vword);
                              JS_ASSERT(!(sprop->attrs & JSPROP_READONLY));
                              JS_ASSERT(!SCOPE_IS_SEALED(OBJ_SCOPE(obj)));
-                             if (scope->object == obj) {
+                             /*
-                                 /*
+                              * Fastest path: check whether the cached sprop is
-                                  * Fastest path: the cached sprop is already
+                              * already in scope and call NATIVE_GET and break
-                                  * in scope. Just NATIVE_SET and break to get
+                              * to get out of the do-while(0). But we can call
-                                  * out of the do-while(0).
+                              * NATIVE_GET only if obj owns scope or sprop is
-                                  */
+                              * shared.
+                              */
+                             bool checkForAdd;
+                             if (scope->object == obj ||
+                                 (sprop->attrs & JSPROP_SHARED)) {
                                  if (sprop == scope->lastProp ||
                                      SCOPE_HAS_PROPERTY(scope, sprop)) {
                                      PCMETER(cache->pchits++);
                                      PCMETER(cache->setpchits++);
-                                     NATIVE_SET(cx, obj, sprop, &rval);
+                                     NATIVE_SET(cx, obj, sprop, entry, &rval);
                                      JS_UNLOCK_SCOPE(cx, scope);
-                                     TRACE_2(SetPropHit, entry, sprop);
                                      break;
                                  }
+                                 checkForAdd =
+                                     !(sprop->attrs & JSPROP_SHARED) &&
+                                     sprop->parent == scope->lastProp &&
+                                     !SCOPE_HAD_MIDDLE_DELETE(scope);
                              } else {
                                  scope = js_GetMutableScope(cx, obj);
                                  if (!scope) {
                                      JS_UNLOCK_OBJ(cx, obj);
                                      goto error;
                                  }
+                                 checkForAdd = !sprop->parent;
                              }
-                             if (sprop->parent == scope->lastProp &&
+                             if (checkForAdd &&
-                                 !SCOPE_HAD_MIDDLE_DELETE(scope) &&
                                  SPROP_HAS_STUB_SETTER(sprop) &&
-                                 (slot = sprop->slot) == scope->map.freeslot) {
+                                 (slot = sprop->slot) == scope->freeslot) {
                                  /*
                                   * Fast path: adding a plain old property that
                                   * was once at the frontier of the property
-Line 4536
+Line 4689
                                   */
                                  if (slot < STOBJ_NSLOTS(obj) &&
                                      !OBJ_GET_CLASS(cx, obj)->reserveSlots) {
-                                     ++scope->map.freeslot;
+                                     ++scope->freeslot;
                                  } else {
                                      if (!js_AllocSlot(cx, obj, &slot)) {
                                          JS_UNLOCK_SCOPE(cx, scope);
-Line 4579
+Line 4732
                                      }
                                      sprop = sprop2;
                                  } else {
-                                     SCOPE_EXTEND_SHAPE(cx, scope, sprop);
+                                     js_ExtendScopeShape(cx, scope, sprop);
                                      ++scope->entryCount;
                                      scope->lastProp = sprop;
                                  }
-Line 4587
+Line 4740
                                  GC_WRITE_BARRIER(cx, scope,
                                                   LOCKED_OBJ_GET_SLOT(obj, slot),
                                                   rval);
+                                 TRACE_2(SetPropHit, entry, sprop);
                                  LOCKED_OBJ_SET_SLOT(obj, slot, rval);
                                  JS_UNLOCK_SCOPE(cx, scope);
-                                 TRACE_2(SetPropHit, entry, sprop);
+                                 /*
+                                  * Purge the property cache of the id we may
+                                  * have just shadowed in obj's scope and proto
+                                  * chains. We do this after unlocking obj's
+                                  * scope to avoid lock nesting.
+                                  */
+                                 js_PurgeScopeChain(cx, obj, sprop->id);
                                  break;
                              }
-Line 4613
+Line 4774
                              sprop = PCVAL_TO_SPROP(entry->vword);
                              JS_ASSERT(!(sprop->attrs & JSPROP_READONLY));
                              JS_ASSERT(!SCOPE_IS_SEALED(OBJ_SCOPE(obj2)));
-                             NATIVE_SET(cx, obj, sprop, &rval);
+                             NATIVE_SET(cx, obj, sprop, entry, &rval);
                          }
                          JS_UNLOCK_OBJ(cx, obj2);
-                         if (sprop) {
+                         if (sprop)
-                             TRACE_2(SetPropHit, entry, sprop);
                              break;
-                         }
                      }
                  }
-Line 4627
+Line 4786
                      LOAD_ATOM(0);
                  id = ATOM_TO_JSID(atom);
                  if (entry) {
-                     if (!js_SetPropertyHelper(cx, obj, id, &rval, &entry))
+                     if (!js_SetPropertyHelper(cx, obj, id, true, &rval))
                          goto error;
- #ifdef JS_TRACER
-                     if (entry)
-                         TRACE_1(SetPropMiss, entry);
- #endif
                  } else {
                      if (!OBJ_SET_PROPERTY(cx, obj, id, &rval))
                          goto error;
-                 }
+                     ABORT_RECORDING(cx, "Non-native set");
- #ifdef JS_TRACER
+                  }
-                 if (!entry && TRACE_RECORDER(cx)) {
-                     js_AbortRecording(cx, "SetPropUncached");
-                     ENABLE_TRACER(0);
-                 }
- #endif
              } while (0);
            END_SET_CASE_STORE_RVAL(JSOP_SETPROP, 2);
-Line 4667
+Line 4817
                  if (OBJ_IS_DENSE_ARRAY(cx, obj)) {
                      jsuint length;
-                     length = ARRAY_DENSE_LENGTH(obj);
+                     length = js_DenseArrayCapacity(obj);
                      i = JSVAL_TO_INT(rval);
                      if ((jsuint)i < length &&
                          i < obj->fslots[JSSLOT_ARRAY_LENGTH]) {
-Line 4693
+Line 4843
            END_CASE(JSOP_GETELEM)
            BEGIN_CASE(JSOP_CALLELEM)
-             /*
+             ELEMENT_OP(-1, js_GetMethod(cx, obj, id, false, &rval));
-              * FIXME: JSOP_CALLELEM should call getMethod on XML objects as
-              * CALLPROP does. See bug 362910.
-              */
-             ELEMENT_OP(-1, OBJ_GET_PROPERTY(cx, obj, id, &rval));
  #if JS_HAS_NO_SUCH_METHOD
              if (JS_UNLIKELY(JSVAL_IS_VOID(rval))) {
                  regs.sp[-2] = regs.sp[-1];
-Line 4720
+Line 4866
                  if (OBJ_IS_DENSE_ARRAY(cx, obj) && JSID_IS_INT(id)) {
                      jsuint length;
-                     length = ARRAY_DENSE_LENGTH(obj);
+                     length = js_DenseArrayCapacity(obj);
                      i = JSID_TO_INT(id);
                      if ((jsuint)i < length) {
                          if (obj->dslots[i] == JSVAL_HOLE) {
-                             if (rt->anyArrayProtoHasElement)
+                             if (js_PrototypeHasIndexedProperties(cx, obj))
                                  break;
                              if (i >= obj->fslots[JSSLOT_ARRAY_LENGTH])
                                  obj->fslots[JSSLOT_ARRAY_LENGTH] = i + 1;
-Line 4791
+Line 4937
              if (!js_InvokeConstructor(cx, argc, JS_FALSE, vp))
                  goto error;
              regs.sp = vp + 1;
-             LOAD_INTERRUPT_HANDLER(cx);
+             CHECK_INTERRUPT_HANDLER();
+             TRACE_0(NativeCallComplete);
            END_CASE(JSOP_NEW)
-           BEGIN_CASE(JSOP_APPLY)
-           {
-             argc = GET_ARGC(regs.pc);
-             vp = regs.sp - (argc + 2);
-             lval = *vp;
-             if (!VALUE_IS_FUNCTION(cx, lval))
-                 goto do_call;
-             obj = JSVAL_TO_OBJECT(lval);
-             fun = GET_FUNCTION_PRIVATE(cx, obj);
-             if (FUN_INTERPRETED(fun))
-                 goto do_call;
-             bool apply = (JSFastNative)fun->u.n.native == js_fun_apply;
-             if (!apply && (JSFastNative)fun->u.n.native != js_fun_call)
-                 goto do_call;
-             /*
-              * If the second arg to apply is null or void, treat it as an empty
-              * array.
-              */
-             jsuint applylen = 0;
-             if (apply && argc >= 2 &&
-                 !JSVAL_IS_VOID(vp[3]) && !JSVAL_IS_NULL(vp[3])) {
-                 /*
-                  * Fall back on js_Invoke when the array argument has a wrong
-                  * type or when it has too many elements to fit into the
-                  * current stack chunk.
-                  */
-                 if (!JSVAL_IS_OBJECT(vp[3]))
-                     goto do_call;
-                 JSBool arraylike;
-                 JSObject* aobj = JSVAL_TO_OBJECT(vp[3]);
-                 if (!js_IsArrayLike(cx, aobj, &arraylike, &applylen))
-                     goto error;
-                 if (!arraylike || applylen > ARGC_LIMIT)
-                     goto do_call;
-                 JSArena *a = cx->stackPool.current;
-                 JS_ASSERT(jsuword(vp + 2) <= a->limit);
-                 /*
-                  * We need space for applylen elements plus an extra slot to
-                  * temporary root the array object when we unpack its elements
-                  * using OBJ_GET_PROPERTY below.
-                  */
-                 if (a->limit - jsuword(vp + 2) < (applylen + 1) * sizeof(jsval))
-                     goto do_call;
-             }
-             if (!VALUE_IS_FUNCTION(cx, vp[1]))
-                 goto do_call;
-             vp[0] = vp[1];
-             if (argc == 0) {
-                 /*
-                  * Call fun with its global object as the 'this' param if
-                  * no args.
-                  */
-                 obj = NULL;
-             } else {
-                 /* Convert the first arg to 'this'. */
-                 if (!JSVAL_IS_PRIMITIVE(vp[2]))
-                     obj = JSVAL_TO_OBJECT(vp[2]);
-                 else if (!js_ValueToObject(cx, vp[2], &obj))
-                     goto error;
-             }
-             vp[1] = OBJECT_TO_JSVAL(obj);
-             if (!apply) {
-                 if (argc != 0) {
-                     --argc;
-                     memmove(vp + 2, vp + 3, argc * sizeof *vp);
-                 }
-             } else if (applylen == 0) {
-                 argc = 0;
-             } else {
-                 /*
-                  * Make room for missing arguments to the right including the
-                  * temporary root nulling any extra stack slots for GC safety.
-                  */
-                 jsval* newsp = vp + 2 + applylen + 1;
-                 if (newsp > regs.sp) {
-                     JSArena *a = cx->stackPool.current;
-                     JS_ASSERT(jsuword(newsp) <= a->limit); /* see above */
-                     if ((jsuword) newsp > a->avail)
-                         a->avail = (jsuword) newsp;
-                     memset(vp + 2 + argc, 0, (applylen - argc) * sizeof(jsval));
-                 }
-                 JSObject *aobj = JSVAL_TO_OBJECT(vp[3]);
-                 newsp[-1] = vp[3];
-                 regs.sp = newsp;
-                 /* Expand array content onto the stack. */
-                 for (i = 0; i < jsint(applylen); i++) {
-                     id = INT_TO_JSID(i);
-                     if (!OBJ_GET_PROPERTY(cx, aobj, id, &vp[2 + i])) {
-                         /*
-                          * There is no good way to restore the original stack
-                          * state here, but it is in a reasonable  state with
-                          * either original elements or nulls for all arguments
-                          * we didn't unpack yet, so we leave it at that.
-                          */
-                         goto error;
-                     }
-                 }
-                 argc = applylen;
-             }
-             regs.sp = vp + 2 + argc;
-             goto do_call_with_specified_vp_and_argc;
-           }
            BEGIN_CASE(JSOP_CALL)
            BEGIN_CASE(JSOP_EVAL)
-           do_call:
+           BEGIN_CASE(JSOP_APPLY)
              argc = GET_ARGC(regs.pc);
              vp = regs.sp - (argc + 2);
-           do_call_with_specified_vp_and_argc:
              lval = *vp;
              if (VALUE_IS_FUNCTION(cx, lval)) {
                  obj = JSVAL_TO_OBJECT(lval);
-Line 5015
+Line 5048
                      newifp->frame.dormantNext = NULL;
                      newifp->frame.xmlNamespace = NULL;
                      newifp->frame.blockChain = NULL;
-                     if (script->staticDepth < JS_DISPLAY_SIZE) {
+                     if (script->staticLevel < JS_DISPLAY_SIZE) {
-                         JSStackFrame **disp = &cx->display[script->staticDepth];
+                         JSStackFrame **disp = &cx->display[script->staticLevel];
                          newifp->frame.displaySave = *disp;
                          *disp = &newifp->frame;
                      }
- #ifdef DEBUG
-                     newifp->frame.pcDisabledSave =
-                         JS_PROPERTY_CACHE(cx).disabled;
- #endif
                      newifp->mark = newmark;
                      /* Compute the 'this' parameter now that argv is set. */
-Line 5040
+Line 5069
                      while (nvars--)
                          *newsp++ = JSVAL_VOID;
-                     /* Call the debugger hook if present. */
-                     hook = cx->debugHooks->callHook;
-                     if (hook) {
-                         newifp->hookData = hook(cx, &newifp->frame, JS_TRUE, 0,
-                                                 cx->debugHooks->callHookData);
-                         LOAD_INTERRUPT_HANDLER(cx);
-                     } else {
-                         newifp->hookData = NULL;
-                     }
                      /* Scope with a call object parented by callee's parent. */
                      if (JSFUN_HEAVYWEIGHT_TEST(fun->flags) &&
-                         !js_GetCallObject(cx, &newifp->frame, parent)) {
+                         !js_GetCallObject(cx, &newifp->frame)) {
                          goto bad_inline_call;
                      }
-Line 5072
+Line 5091
                      newifp->frame.regs = &regs;
                      cx->fp = fp = &newifp->frame;
+                     /* Call the debugger hook if present. */
+                     hook = cx->debugHooks->callHook;
+                     if (hook) {
+                         newifp->hookData = hook(cx, &newifp->frame, JS_TRUE, 0,
+                                                 cx->debugHooks->callHookData);
+                         CHECK_INTERRUPT_HANDLER();
+                     } else {
+                         newifp->hookData = NULL;
+                     }
                      TRACE_0(EnterFrame);
                      inlineCallCount++;
-Line 5125
+Line 5154
                      }
  #endif
                      regs.sp = vp + 1;
-                     if (!ok)
+                     if (!ok) {
-                         goto error;
+                         /*
-                     TRACE_0(FastNativeCallComplete);
+                          * If we are executing the JSOP_NEXTITER imacro and a Stopiteration
+                          * exception is raised, transform it into a JSVAL_HOLE return value.
+                          * The tracer generates equivalent code by calling CatchStopIteration_tn.
+                          */
+                         if (fp->imacpc && *fp->imacpc == JSOP_NEXTITER &&
+                             cx->throwing && js_ValueIsStopIteration(cx->exception)) {
+                             // pc may point to JSOP_DUP here due to bug 474854.
+                             JS_ASSERT(*regs.pc == JSOP_CALL || *regs.pc == JSOP_DUP);
+                             cx->throwing = JS_FALSE;
+                             cx->exception = JSVAL_VOID;
+                             regs.sp[-1] = JSVAL_HOLE;
+                         } else {
+                             goto error;
+                         }
+                     }
+                     TRACE_0(NativeCallComplete);
                      goto end_call;
                  }
              }
-Line 5143
+Line 5187
              }
  #endif
              regs.sp = vp + 1;
-             LOAD_INTERRUPT_HANDLER(cx);
+             CHECK_INTERRUPT_HANDLER();
              if (!ok)
                  goto error;
              JS_RUNTIME_METER(rt, nonInlineCalls);
+             TRACE_0(NativeCallComplete);
            end_call:
  #if JS_HAS_LVALUE_RETURN
-Line 5181
+Line 5226
              vp = regs.sp - argc - 2;
              ok = js_Invoke(cx, argc, vp, 0);
              regs.sp = vp + 1;
-             LOAD_INTERRUPT_HANDLER(cx);
+             CHECK_INTERRUPT_HANDLER();
              if (!ok)
                  goto error;
              if (!cx->rval2set) {
-                 op2 = (JSOp) regs.pc[JSOP_SETCALL_LENGTH];
+                 op2 = js_GetOpcode(cx, script, regs.pc + JSOP_SETCALL_LENGTH);
                  if (op2 != JSOP_DELELEM) {
-                     JS_ASSERT(!(js_CodeSpec[op2].format & JOF_DEL));
                      JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                                           JSMSG_BAD_LEFTSIDE_OF_ASS);
                      goto error;
-Line 5226
+Line 5270
                      if (PCVAL_IS_SLOT(entry->vword)) {
                          slot = PCVAL_TO_SLOT(entry->vword);
-                         JS_ASSERT(slot < obj2->map->freeslot);
+                         JS_ASSERT(slot < OBJ_SCOPE(obj2)->freeslot);
                          rval = LOCKED_OBJ_GET_SLOT(obj2, slot);
                          JS_UNLOCK_OBJ(cx, obj2);
                          goto do_push_rval;
-Line 5237
+Line 5281
                      goto do_native_get;
                  }
              } else {
-                 entry = NULL;
                  LOAD_ATOM(0);
              }
              id = ATOM_TO_JSID(atom);
-             if (js_FindPropertyHelper(cx, id, &obj, &obj2, &prop, &entry) < 0)
+             if (!js_FindPropertyHelper(cx, id, true, &obj, &obj2, &prop))
                  goto error;
              if (!prop) {
                  /* Kludge to allow (typeof foo == "undefined") tests. */
                  endpc = script->code + script->length;
-                 op2 = (JSOp) regs.pc[JSOP_NAME_LENGTH];
+                 op2 = js_GetOpcode(cx, script, regs.pc + JSOP_NAME_LENGTH);
                  if (op2 == JSOP_TYPEOF) {
                      PUSH_OPND(JSVAL_VOID);
                      len = JSOP_NAME_LENGTH;
-Line 5261
+Line 5304
                  OBJ_DROP_PROPERTY(cx, obj2, prop);
                  if (!OBJ_GET_PROPERTY(cx, obj, id, &rval))
                      goto error;
-                 entry = NULL;
              } else {
                  sprop = (JSScopeProperty *)prop;
            do_native_get:
-Line 5453
+Line 5495
            END_CASE(JSOP_ONE)
            BEGIN_CASE(JSOP_NULL)
-           BEGIN_CASE(JSOP_NULLTHIS)
              PUSH_OPND(JSVAL_NULL);
            END_CASE(JSOP_NULL)
-Line 5619
+Line 5660
                  break;
              }
              JS_ASSERT(status == JSTRAP_CONTINUE);
-             LOAD_INTERRUPT_HANDLER(cx);
+             CHECK_INTERRUPT_HANDLER();
              JS_ASSERT(JSVAL_IS_INT(rval));
              op = (JSOp) JSVAL_TO_INT(rval);
              JS_ASSERT((uintN)op < (uintN)JSOP_LIMIT);
-Line 5661
+Line 5702
              JS_ASSERT(slot < fp->fun->nargs);
              METER_SLOT_OP(op, slot);
              vp = &fp->argv[slot];
-             GC_POKE(cx, *vp);
              *vp = FETCH_OPND(-1);
            END_SET_CASE(JSOP_SETARG)
-Line 5682
+Line 5722
              slot = GET_SLOTNO(regs.pc);
              JS_ASSERT(slot < script->nslots);
              vp = &fp->slots[slot];
-             GC_POKE(cx, *vp);
              *vp = FETCH_OPND(-1);
            END_SET_CASE(JSOP_SETLOCAL)
            BEGIN_CASE(JSOP_GETUPVAR)
            BEGIN_CASE(JSOP_CALLUPVAR)
            {
-             JSUpvarArray *uva;
+             JSUpvarArray *uva = JS_SCRIPT_UPVARS(script);
-             uint32 skip;
-             JSStackFrame *fp2;
              index = GET_UINT16(regs.pc);
-             uva = JS_SCRIPT_UPVARS(script);
              JS_ASSERT(index < uva->length);
-             skip = UPVAR_FRAME_SKIP(uva->vector[index]);
-             fp2 = cx->display[script->staticDepth - skip];
-             JS_ASSERT(fp2->fun && fp2->script);
-             slot = UPVAR_FRAME_SLOT(uva->vector[index]);
-             if (slot < fp2->fun->nargs) {
-                 vp = fp2->argv;
-             } else {
-                 slot -= fp2->fun->nargs;
-                 JS_ASSERT(slot < fp2->script->nslots);
-                 vp = fp2->slots;
-             }
-             PUSH_OPND(vp[slot]);
+             rval = js_GetUpvar(cx, script->staticLevel, uva->vector[index]);
+             PUSH_OPND(rval);
              if (op == JSOP_CALLUPVAR)
                  PUSH_OPND(JSVAL_NULL);
            }
            END_CASE(JSOP_GETUPVAR)
+           BEGIN_CASE(JSOP_GETUPVAR_DBG)
+           BEGIN_CASE(JSOP_CALLUPVAR_DBG)
+             fun = fp->fun;
+             JS_ASSERT(FUN_KIND(fun) == JSFUN_INTERPRETED);
+             JS_ASSERT(fun->u.i.wrapper);
+             /* Scope for tempPool mark and local names allocation in it. */
+             {
+                 void *mark = JS_ARENA_MARK(&cx->tempPool);
+                 jsuword *names = js_GetLocalNameArray(cx, fun, &cx->tempPool);
+                 if (!names)
+                     goto error;
+                 index = fun->countArgsAndVars() + GET_UINT16(regs.pc);
+                 atom = JS_LOCAL_NAME_TO_ATOM(names[index]);
+                 id = ATOM_TO_JSID(atom);
+                 ok = js_FindProperty(cx, id, &obj, &obj2, &prop);
+                 JS_ARENA_RELEASE(&cx->tempPool, mark);
+                 if (!ok)
+                     goto error;
+             }
+             if (!prop)
+                 goto atom_not_defined;
+             /* Minimize footprint with generic code instead of NATIVE_GET. */
+             OBJ_DROP_PROPERTY(cx, obj2, prop);
+             vp = regs.sp;
+             PUSH_OPND(JSVAL_NULL);
+             if (!OBJ_GET_PROPERTY(cx, obj, id, vp))
+                 goto error;
+             if (op == JSOP_CALLUPVAR_DBG)
+                 PUSH_OPND(JSVAL_NULL);
+           END_CASE(JSOP_GETUPVAR_DBG)
+           BEGIN_CASE(JSOP_GETDSLOT)
+           BEGIN_CASE(JSOP_CALLDSLOT)
+             obj = fp->callee;
+             JS_ASSERT(obj);
+             JS_ASSERT(obj->dslots);
+             index = GET_UINT16(regs.pc);
+             JS_ASSERT(JS_INITIAL_NSLOTS + index < jsatomid(obj->dslots[-1]));
+             JS_ASSERT_IF(OBJ_SCOPE(obj)->object == obj,
+                          JS_INITIAL_NSLOTS + index < OBJ_SCOPE(obj)->freeslot);
+             PUSH_OPND(obj->dslots[index]);
+             if (op == JSOP_CALLDSLOT)
+                 PUSH_OPND(JSVAL_NULL);
+           END_CASE(JSOP_GETDSLOT)
            BEGIN_CASE(JSOP_GETGVAR)
            BEGIN_CASE(JSOP_CALLGVAR)
              slot = GET_SLOTNO(regs.pc);
-Line 5746
+Line 5825
                   * JSOP_SETGVAR has arity 1: [rval], not arity 2: [obj, rval]
                   * as JSOP_SETNAME does, where [obj] is due to JSOP_BINDNAME.
                   */
+ #ifdef JS_TRACER
+                 if (TRACE_RECORDER(cx))
+                     js_AbortRecording(cx, "SETGVAR with NULL slot");
+ #endif
                  LOAD_ATOM(0);
                  id = ATOM_TO_JSID(atom);
                  if (!OBJ_SET_PROPERTY(cx, obj, id, &rval))
-Line 5777
+Line 5860
              /* Lookup id in order to check for redeclaration problems. */
              id = ATOM_TO_JSID(atom);
+             prop = NULL;
              if (!js_CheckRedeclaration(cx, obj, id, attrs, &obj2, &prop))
                  goto error;
-Line 5799
+Line 5883
               */
              if (!fp->fun &&
                  index < GlobalVarCount(fp) &&
-                 (attrs & JSPROP_PERMANENT) &&
                  obj2 == obj &&
                  OBJ_IS_NATIVE(obj)) {
                  sprop = (JSScopeProperty *) prop;
-                 if (SPROP_HAS_VALID_SLOT(sprop, OBJ_SCOPE(obj)) &&
+                 if ((sprop->attrs & JSPROP_PERMANENT) &&
+                     SPROP_HAS_VALID_SLOT(sprop, OBJ_SCOPE(obj)) &&
                      SPROP_HAS_STUB_GETTER(sprop) &&
                      SPROP_HAS_STUB_SETTER(sprop)) {
                      /*
-Line 5821
+Line 5905
            END_CASE(JSOP_DEFVAR)
            BEGIN_CASE(JSOP_DEFFUN)
+           {
+             JSPropertyOp getter, setter;
+             bool doSet;
+             JSObject *pobj;
+             JSProperty *prop;
+             uint32 old;
              /*
               * A top-level function defined in Global or Eval code (see
               * ECMA-262 Ed. 3), or else a SpiderMonkey extension: a named
-Line 5829
+Line 5920
               * function body).
               */
              LOAD_FUNCTION(0);
+             obj = FUN_OBJECT(fun);
-             if (!fp->blockChain) {
+             if (FUN_NULL_CLOSURE(fun)) {
+                 /*
+                  * Even a null closure needs a parent for principals finding.
+                  * FIXME: bug 476950, although debugger users may also demand
+                  * some kind of scope link for debugger-assisted eval-in-frame.
+                  */
                  obj2 = fp->scopeChain;
              } else {
-                 obj2 = js_GetScopeChain(cx, fp);
+                 JS_ASSERT(!FUN_FLAT_CLOSURE(fun));
-                 if (!obj2)
-                     goto error;
+                 /*
+                  * Inline js_GetScopeChain a bit to optimize for the case of a
+                  * top-level function.
+                  */
+                 if (!fp->blockChain) {
+                     obj2 = fp->scopeChain;
+                 } else {
+                     obj2 = js_GetScopeChain(cx, fp);
+                     if (!obj2)
+                         goto error;
+                 }
              }
              /*
               * If static link is not current scope, clone fun's object to link
-              * to the current scope via parent. This clause exists to enable
+              * to the current scope via parent. We do this to enable sharing of
-              * sharing of compiled functions among multiple equivalent scopes,
+              * compiled functions among multiple equivalent scopes, amortizing
-              * splitting the cost of compilation evenly among the scopes and
+              * the cost of compilation over a number of executions.  Examples
-              * amortizing it over a number of executions. Examples include XUL
+              * include XUL scripts and event handlers shared among Firefox or
-              * scripts and event handlers shared among Mozilla chrome windows,
+              * other Mozilla app chrome windows, and user-defined JS functions
-              * and server-side JS user-defined functions shared among requests.
+              * precompiled and then shared among requests in server-side JS.
               */
-             obj = FUN_OBJECT(fun);
              if (OBJ_GET_PARENT(cx, obj) != obj2) {
                  obj = js_CloneFunctionObject(cx, fun, obj2);
                  if (!obj)
-Line 5859
+Line 5965
               * paths from here must flow through the "Restore fp->scopeChain"
               * code below the OBJ_DEFINE_PROPERTY call.
               */
-             MUST_FLOW_THROUGH("restore");
+             MUST_FLOW_THROUGH("restore_scope");
              fp->scopeChain = obj;
              rval = OBJECT_TO_JSVAL(obj);
              /*
-Line 5876
+Line 5983
               * and setters do not need a slot, their value is stored elsewhere
               * in the property itself, not in obj slots.
               */
+             setter = getter = JS_PropertyStub;
              flags = JSFUN_GSFLAG2ATTR(fun->flags);
              if (flags) {
+                 /* Function cannot be both getter a setter. */
+                 JS_ASSERT(flags == JSPROP_GETTER || flags == JSPROP_SETTER);
                  attrs |= flags | JSPROP_SHARED;
                  rval = JSVAL_VOID;
+                 if (flags == JSPROP_GETTER)
+                     getter = js_CastAsPropertyOp(obj);
+                 else
+                     setter = js_CastAsPropertyOp(obj);
              }
              /*
-Line 5898
+Line 6012
               * as well as multiple HTML script tags.
               */
              id = ATOM_TO_JSID(fun->atom);
+             prop = NULL;
+             ok = js_CheckRedeclaration(cx, parent, id, attrs, &pobj, &prop);
+             if (!ok)
+                 goto restore_scope;
+             /*
+              * We deviate from 10.1.2 in ECMA 262 v3 and under eval use for
+              * function declarations OBJ_SET_PROPERTY, not OBJ_DEFINE_PROPERTY,
+              * to preserve the JSOP_PERMANENT attribute of existing properties
+              * and make sure that such properties cannot be deleted.
+              *
+              * We also use OBJ_SET_PROPERTY for the existing properties of
+              * Call objects with matching attributes to preserve the native
+              * getters and setters that store the value of the property in the
+              * interpreter frame, see bug 467495.
+              */
+             doSet = (attrs == JSPROP_ENUMERATE);
+             JS_ASSERT_IF(doSet, fp->flags & JSFRAME_EVAL);
+             if (prop) {
+                 if (parent == pobj &&
+                     OBJ_GET_CLASS(cx, parent) == &js_CallClass &&
+                     (old = ((JSScopeProperty *) prop)->attrs,
+                      !(old & (JSPROP_GETTER|JSPROP_SETTER)) &&
+                      (old & (JSPROP_ENUMERATE|JSPROP_PERMANENT)) == attrs)) {
+                     /*
+                      * js_CheckRedeclaration must reject attempts to add a
+                      * getter or setter to an existing property without a
+                      * getter or setter.
+                      */
+                     JS_ASSERT(!(attrs & ~(JSPROP_ENUMERATE|JSPROP_PERMANENT)));
+                     JS_ASSERT(!(old & JSPROP_READONLY));
+                     doSet = JS_TRUE;
+                 }
+                 OBJ_DROP_PROPERTY(cx, pobj, prop);
+             }
+             ok = doSet
+                  ? OBJ_SET_PROPERTY(cx, parent, id, &rval)
+                  : OBJ_DEFINE_PROPERTY(cx, parent, id, rval, getter, setter,
+                                        attrs, NULL);
+           restore_scope:
+             /* Restore fp->scopeChain now that obj is defined in fp->varobj. */
+             fp->scopeChain = obj2;
+             if (!ok) {
+                 cx->weakRoots.newborn[GCX_OBJECT] = NULL;
+                 goto error;
+             }
+           }
+           END_CASE(JSOP_DEFFUN)
+           BEGIN_CASE(JSOP_DEFFUN_FC)
+           BEGIN_CASE(JSOP_DEFFUN_DBGFC)
+             LOAD_FUNCTION(0);
+             obj = (op == JSOP_DEFFUN_FC)
+                   ? js_NewFlatClosure(cx, fun)
+                   : js_NewDebuggableFlatClosure(cx, fun);
+             if (!obj)
+                 goto error;
+             rval = OBJECT_TO_JSVAL(obj);
+             attrs = (fp->flags & JSFRAME_EVAL)
+                     ? JSPROP_ENUMERATE
+                     : JSPROP_ENUMERATE | JSPROP_PERMANENT;
+             flags = JSFUN_GSFLAG2ATTR(fun->flags);
+             if (flags) {
+                 attrs |= flags | JSPROP_SHARED;
+                 rval = JSVAL_VOID;
+             }
+             parent = fp->varobj;
+             JS_ASSERT(parent);
+             id = ATOM_TO_JSID(fun->atom);
              ok = js_CheckRedeclaration(cx, parent, id, attrs, NULL, NULL);
              if (ok) {
                  if (attrs == JSPROP_ENUMERATE) {
-Line 5918
+Line 6107
                  }
              }
-             /* Restore fp->scopeChain now that obj is defined in fp->varobj. */
-             MUST_FLOW_LABEL(restore)
-             fp->scopeChain = obj2;
              if (!ok) {
                  cx->weakRoots.newborn[GCX_OBJECT] = NULL;
                  goto error;
              }
-           END_CASE(JSOP_DEFFUN)
+           END_CASE(JSOP_DEFFUN_FC)
            BEGIN_CASE(JSOP_DEFLOCALFUN)
-             LOAD_FUNCTION(SLOTNO_LEN);
              /*
               * Define a local function (i.e., one nested at the top level of
-              * another function), parented by the current scope chain, and
+              * another function), parented by the current scope chain, stored
-              * stored in a local variable slot that the compiler allocated.
+              * in a local variable slot that the compiler allocated.  This is
-              * This is an optimization over JSOP_DEFFUN that avoids requiring
+              * an optimization over JSOP_DEFFUN that avoids requiring a call
-              * a call object for the outer function's activation.
+              * object for the outer function's activation.
               */
-             slot = GET_SLOTNO(regs.pc);
+             LOAD_FUNCTION(SLOTNO_LEN);
+             JS_ASSERT(FUN_INTERPRETED(fun));
-             parent = js_GetScopeChain(cx, fp);
+             JS_ASSERT(!FUN_FLAT_CLOSURE(fun));
-             if (!parent)
-                 goto error;
              obj = FUN_OBJECT(fun);
-             if (OBJ_GET_PARENT(cx, obj) != parent) {
-                 obj = js_CloneFunctionObject(cx, fun, parent);
+             if (FUN_NULL_CLOSURE(fun)) {
+                 obj = js_CloneFunctionObject(cx, fun, fp->scopeChain);
                  if (!obj)
                      goto error;
+             } else {
+                 parent = js_GetScopeChain(cx, fp);
+                 if (!parent)
+                     goto error;
+                 if (OBJ_GET_PARENT(cx, obj) != parent) {
+ #ifdef JS_TRACER
+                     if (TRACE_RECORDER(cx))
+                         js_AbortRecording(cx, "DEFLOCALFUN for closure");
+ #endif
+                     obj = js_CloneFunctionObject(cx, fun, parent);
+                     if (!obj)
+                         goto error;
+                 }
              }
+             slot = GET_SLOTNO(regs.pc);
              TRACE_2(DefLocalFunSetSlot, slot, obj);
              fp->slots[slot] = OBJECT_TO_JSVAL(obj);
            END_CASE(JSOP_DEFLOCALFUN)
-           BEGIN_CASE(JSOP_ANONFUNOBJ)
+           BEGIN_CASE(JSOP_DEFLOCALFUN_FC)
-             /* Load the specified function object literal. */
+             LOAD_FUNCTION(SLOTNO_LEN);
-             LOAD_FUNCTION(0);
-             /* If re-parenting, push a clone of the function object. */
+             obj = js_NewFlatClosure(cx, fun);
-             parent = js_GetScopeChain(cx, fp);
+             if (!obj)
-             if (!parent)
                  goto error;
+             slot = GET_SLOTNO(regs.pc);
+             TRACE_2(DefLocalFunSetSlot, slot, obj);
+             fp->slots[slot] = OBJECT_TO_JSVAL(obj);
+           END_CASE(JSOP_DEFLOCALFUN_FC)
+           BEGIN_CASE(JSOP_DEFLOCALFUN_DBGFC)
+             LOAD_FUNCTION(SLOTNO_LEN);
+             obj = js_NewDebuggableFlatClosure(cx, fun);
+             if (!obj)
+                 goto error;
+             slot = GET_SLOTNO(regs.pc);
+             fp->slots[slot] = OBJECT_TO_JSVAL(obj);
+           END_CASE(JSOP_DEFLOCALFUN_DBGFC)
+           BEGIN_CASE(JSOP_LAMBDA)
+             /* Load the specified function object literal. */
+             LOAD_FUNCTION(0);
              obj = FUN_OBJECT(fun);
-             if (OBJ_GET_PARENT(cx, obj) != parent) {
-                 obj = js_CloneFunctionObject(cx, fun, parent);
+             if (FUN_NULL_CLOSURE(fun)) {
+                 obj = js_CloneFunctionObject(cx, fun, fp->scopeChain);
                  if (!obj)
                      goto error;
+             } else {
+                 parent = js_GetScopeChain(cx, fp);
+                 if (!parent)
+                     goto error;
+                 /* If re-parenting, push a clone of the function object. */
+                 if (OBJ_GET_PARENT(cx, obj) != parent) {
+                     obj = js_CloneFunctionObject(cx, fun, parent);
+                     if (!obj)
+                         goto error;
+                 }
              }
              PUSH_OPND(OBJECT_TO_JSVAL(obj));
-           END_CASE(JSOP_ANONFUNOBJ)
+           END_CASE(JSOP_LAMBDA)
-           BEGIN_CASE(JSOP_NAMEDFUNOBJ)
+           BEGIN_CASE(JSOP_LAMBDA_FC)
              LOAD_FUNCTION(0);
-             /*
+             obj = js_NewFlatClosure(cx, fun);
-              * ECMA ed. 3 FunctionExpression: function Identifier [etc.].
-              *
-              * 1. Create a new object as if by the expression new Object().
-              * 2. Add Result(1) to the front of the scope chain.
-              *
-              * Step 2 is achieved by making the new object's parent be the
-              * current scope chain, and then making the new object the parent
-              * of the Function object clone.
-              */
-             obj2 = js_GetScopeChain(cx, fp);
-             if (!obj2)
-                 goto error;
-             parent = js_NewObject(cx, &js_ObjectClass, NULL, obj2, 0);
-             if (!parent)
-                 goto error;
-             /*
-              * 3. Create a new Function object as specified in section 13.2
-              * with [parameters and body specified by the function expression
-              * that was parsed by the compiler into a Function object, and
-              * saved in the script's atom map].
-              *
-              * Protect parent from the GC.
-              */
-             fp->scopeChain = parent;
-             obj = js_CloneFunctionObject(cx, fun, parent);
              if (!obj)
                  goto error;
-             /*
+             PUSH_OPND(OBJECT_TO_JSVAL(obj));
-              * Protect obj from any GC hiding below OBJ_DEFINE_PROPERTY.  All
+           END_CASE(JSOP_LAMBDA_FC)
-              * paths from here must flow through the "Restore fp->scopeChain"
-              * code below the OBJ_DEFINE_PROPERTY call.
-              */
-             MUST_FLOW_THROUGH("restore2");
-             fp->scopeChain = obj;
-             rval = OBJECT_TO_JSVAL(obj);
-             /*
+           BEGIN_CASE(JSOP_LAMBDA_DBGFC)
-              * 4. Create a property in the object Result(1).  The property's
+             LOAD_FUNCTION(0);
-              * name is [fun->atom, the identifier parsed by the compiler],
-              * value is Result(3), and attributes are { DontDelete, ReadOnly }.
-              */
-             attrs = JSFUN_GSFLAG2ATTR(fun->flags);
-             if (attrs) {
-                 attrs |= JSPROP_SHARED;
-                 rval = JSVAL_VOID;
-             }
-             ok = OBJ_DEFINE_PROPERTY(cx, parent, ATOM_TO_JSID(fun->atom), rval,
-                                      (attrs & JSPROP_GETTER)
-                                      ? JS_EXTENSION (JSPropertyOp) obj
-                                      : JS_PropertyStub,
-                                      (attrs & JSPROP_SETTER)
-                                      ? JS_EXTENSION (JSPropertyOp) obj
-                                      : JS_PropertyStub,
-                                      attrs |
-                                      JSPROP_ENUMERATE | JSPROP_PERMANENT |
-                                      JSPROP_READONLY,
-                                      NULL);
-             /* Restore fp->scopeChain now that obj is defined in parent. */
+             obj = js_NewDebuggableFlatClosure(cx, fun);
-             MUST_FLOW_LABEL(restore2)
+             if (!obj)
-             fp->scopeChain = obj2;
-             if (!ok) {
-                 cx->weakRoots.newborn[GCX_OBJECT] = NULL;
                  goto error;
-             }
-             /*
-              * 5. Remove Result(1) from the front of the scope chain [no-op].
-              * 6. Return Result(3).
-              */
              PUSH_OPND(OBJECT_TO_JSVAL(obj));
-           END_CASE(JSOP_NAMEDFUNOBJ)
+           END_CASE(JSOP_LAMBDA_DBGFC)
+           BEGIN_CASE(JSOP_CALLEE)
+             PUSH_OPND(OBJECT_TO_JSVAL(fp->callee));
+           END_CASE(JSOP_CALLEE)
  #if JS_HAS_GETTER_SETTER
            BEGIN_CASE(JSOP_GETTER)
-Line 6157
+Line 6331
            END_CASE(JSOP_HOLE)
            BEGIN_CASE(JSOP_NEWARRAY)
-             len = GET_UINT24(regs.pc);
+             len = GET_UINT16(regs.pc);
-             JS_ASSERT(len <= regs.sp - StackBase(fp));
+             cx->fp->assertValidStackDepth(len);
              obj = js_NewArrayObject(cx, len, regs.sp - len, JS_TRUE);
              if (!obj)
                  goto error;
-Line 6176
+Line 6350
                  goto error;
              PUSH_OPND(OBJECT_TO_JSVAL(obj));
              fp->sharpDepth++;
-             LOAD_INTERRUPT_HANDLER(cx);
+             CHECK_INTERRUPT_HANDLER();
            END_CASE(JSOP_NEWINIT)
            BEGIN_CASE(JSOP_ENDINIT)
-Line 6215
+Line 6389
                  kshape = scope->shape;
                  cache = &JS_PROPERTY_CACHE(cx);
                  entry = &cache->table[PROPERTY_CACHE_HASH_PC(regs.pc, kshape)];
+                 PCMETER(cache->pctestentry = entry);
                  PCMETER(cache->tests++);
                  PCMETER(cache->initests++);
-                 if (entry->kpc == regs.pc && entry->kshape == kshape) {
+                 if (entry->kpc == regs.pc &&
+                     entry->kshape == kshape &&
+                     PCVCAP_SHAPE(entry->vcap) == rt->protoHazardShape) {
+                     JS_ASSERT(PCVCAP_TAG(entry->vcap) == 0);
                      PCMETER(cache->pchits++);
                      PCMETER(cache->inipchits++);
-Line 6251
+Line 6430
                      if (sprop->parent != scope->lastProp)
                          goto do_initprop_miss;
-                     TRACE_2(SetPropHit, entry, sprop);
                      /*
                       * Otherwise this entry must be for a direct property of
                       * obj, not a proto-property, and there cannot have been
                       * any deletions of prior properties.
                       */
-                     JS_ASSERT(PCVCAP_MAKE(sprop->shape, 0, 0) == entry->vcap);
                      JS_ASSERT(!SCOPE_HAD_MIDDLE_DELETE(scope));
                      JS_ASSERT(!scope->table ||
                                !SCOPE_HAS_PROPERTY(scope, sprop));
                      slot = sprop->slot;
-                     JS_ASSERT(slot == scope->map.freeslot);
+                     JS_ASSERT(slot == scope->freeslot);
                      if (slot < STOBJ_NSLOTS(obj)) {
-                         ++scope->map.freeslot;
+                         ++scope->freeslot;
                      } else {
                          if (!js_AllocSlot(cx, obj, &slot)) {
                              JS_UNLOCK_SCOPE(cx, scope);
-Line 6290
+Line 6466
                          }
                          JS_ASSERT(sprop2 == sprop);
                      } else {
+                         js_LeaveTraceIfGlobalObject(cx, scope->object);
                          scope->shape = sprop->shape;
                          ++scope->entryCount;
                          scope->lastProp = sprop;
-Line 6298
+Line 6475
                      GC_WRITE_BARRIER(cx, scope,
                                       LOCKED_OBJ_GET_SLOT(obj, slot),
                                       rval);
+                     TRACE_2(SetPropHit, entry, sprop);
                      LOCKED_OBJ_SET_SLOT(obj, slot, rval);
                      JS_UNLOCK_SCOPE(cx, scope);
                      break;
-Line 6316
+Line 6494
                                             NULL, NULL)) {
                      goto error;
                  }
-                 if (!js_SetPropertyHelper(cx, obj, id, &rval, &entry))
+                 if (!(JS_UNLIKELY(atom == cx->runtime->atomState.protoAtom)
+                       ? js_SetPropertyHelper(cx, obj, id, true, &rval)
+                       : js_DefineNativeProperty(cx, obj, id, rval, NULL, NULL,
+                                                 JSPROP_ENUMERATE, 0, 0, NULL,
+                                                 JSDNP_CACHE_RESULT)))
                      goto error;
- #ifdef JS_TRACER
-                 if (entry)
-                     TRACE_1(SetPropMiss, entry);
- #endif
              } while (0);
              /* Common tail for property cache hit and miss cases. */
-Line 6345
+Line 6524
               * Check for property redeclaration strict warning (we may be in
               * an object initialiser, not an array initialiser).
               */
-             if (!js_CheckRedeclaration(cx, obj, id, JSPROP_INITIALIZER, NULL,
+             if (!js_CheckRedeclaration(cx, obj, id, JSPROP_INITIALIZER, NULL, NULL))
-                                        NULL)) {
                  goto error;
-             }
              /*
-              * If rval is a hole, do not call OBJ_SET_PROPERTY. In this case,
+              * If rval is a hole, do not call OBJ_DEFINE_PROPERTY. In this case,
               * obj must be an array, so if the current op is the last element
               * initialiser, set the array length to one greater than id.
               */
-Line 6359
+Line 6536
                  JS_ASSERT(OBJ_IS_ARRAY(cx, obj));
                  JS_ASSERT(JSID_IS_INT(id));
                  JS_ASSERT((jsuint) JSID_TO_INT(id) < ARRAY_INIT_LIMIT);
-                 if ((JSOp) regs.pc[JSOP_INITELEM_LENGTH] == JSOP_ENDINIT &&
+                 if (js_GetOpcode(cx, script, regs.pc + JSOP_INITELEM_LENGTH) == JSOP_ENDINIT &&
-                     !js_SetLengthProperty(cx, obj,
+                     !js_SetLengthProperty(cx, obj, (jsuint) (JSID_TO_INT(id) + 1))) {
-                                           (jsuint) (JSID_TO_INT(id) + 1))) {
                      goto error;
                  }
              } else {
-                 if (!OBJ_SET_PROPERTY(cx, obj, id, &rval))
+                 if (!OBJ_DEFINE_PROPERTY(cx, obj, id, rval, NULL, NULL, JSPROP_ENUMERATE, NULL))
                      goto error;
              }
              regs.sp -= 2;
-Line 6455
+Line 6631
              JS_ASSERT(cx->throwing);
              PUSH(cx->exception);
              cx->throwing = JS_FALSE;
+             CHECK_BRANCH();
            END_CASE(JSOP_EXCEPTION)
+           BEGIN_CASE(JSOP_FINALLY)
+             CHECK_BRANCH();
+           END_CASE(JSOP_FINALLY)
            BEGIN_CASE(JSOP_THROWING)
              JS_ASSERT(!cx->throwing);
              cx->throwing = JS_TRUE;
-Line 6465
+Line 6646
            BEGIN_CASE(JSOP_THROW)
              JS_ASSERT(!cx->throwing);
+             CHECK_BRANCH();
              cx->throwing = JS_TRUE;
              cx->exception = POP_OPND();
              /* let the code at error try to catch the exception. */
-Line 6481
+Line 6663
              fp->slots[slot] = POP_OPND();
            END_CASE(JSOP_SETLOCALPOP)
+           BEGIN_CASE(JSOP_IFPRIMTOP)
+             /*
+              * If the top of stack is of primitive type, jump to our target.
+              * Otherwise advance to the next opcode.
+              */
+             JS_ASSERT(regs.sp > StackBase(fp));
+             rval = FETCH_OPND(-1);
+             if (JSVAL_IS_PRIMITIVE(rval)) {
+                 len = GET_JUMP_OFFSET(regs.pc);
+                 BRANCH(len);
+             }
+           END_CASE(JSOP_IFPRIMTOP)
+           BEGIN_CASE(JSOP_PRIMTOP)
+             JS_ASSERT(regs.sp > StackBase(fp));
+             lval = FETCH_OPND(-1);
+             i = GET_INT8(regs.pc);
+             if (!JSVAL_IS_PRIMITIVE(lval)) {
+                 lval = FETCH_OPND(-2);
+                 js_ReportValueError2(cx, JSMSG_CANT_CONVERT_TO,
+                                      -2, lval, NULL,
+                                      (i == JSTYPE_VOID)
+                                      ? "primitive type"
+                                      : JS_TYPE_STR(i));
+                 goto error;
+             }
+           END_CASE(JSOP_PRIMTOP)
+           BEGIN_CASE(JSOP_OBJTOP)
+             lval = FETCH_OPND(-1);
+             if (JSVAL_IS_PRIMITIVE(lval)) {
+                 js_ReportValueError(cx, GET_UINT16(regs.pc), -1, lval, NULL);
+                 goto error;
+             }
+           END_CASE(JSOP_OBJTOP)
            BEGIN_CASE(JSOP_INSTANCEOF)
              rval = FETCH_OPND(-1);
              if (JSVAL_IS_PRIMITIVE(rval) ||
-Line 6518
+Line 6736
                      goto error;
                    default:;
                  }
-                 LOAD_INTERRUPT_HANDLER(cx);
+                 CHECK_INTERRUPT_HANDLER();
              }
            }
            END_CASE(JSOP_DEBUGGER)
-Line 6771
+Line 6989
                  regs.sp++;
              }
+ #ifdef DEBUG
+             JS_ASSERT(fp->blockChain == OBJ_GET_PARENT(cx, obj));
              /*
-              * If this frame had to reflect the compile-time block chain into
+              * The young end of fp->scopeChain may omit blocks if we
-              * the runtime scope chain, we can't optimize block scopes out of
+              * haven't closed over them, but if there are any closure
-              * runtime any longer, because an outer block that parents obj has
+              * blocks on fp->scopeChain, they'd better be (clones of)
-              * been cloned onto the scope chain.  To avoid re-cloning such a
+              * ancestors of the block we're entering now; anything
-              * parent and accumulating redundant clones via js_GetScopeChain,
+              * else we should have popped off fp->scopeChain when we
-              * we must clone each block eagerly on entry, and push it on the
+              * left its static scope.
-              * scope chain, until this frame pops.
+              */
-              */
+             obj2 = fp->scopeChain;
-             if (fp->flags & JSFRAME_POP_BLOCKS) {
+             while ((clasp = OBJ_GET_CLASS(cx, obj2)) == &js_WithClass)
-                 JS_ASSERT(!fp->blockChain);
+                 obj2 = OBJ_GET_PARENT(cx, obj2);
-                 obj = js_CloneBlockObject(cx, obj, fp->scopeChain, fp);
+             if (clasp == &js_BlockClass &&
-                 if (!obj)
+                 OBJ_GET_PRIVATE(cx, obj2) == fp) {
-                     goto error;
+                 JSObject *youngestProto = OBJ_GET_PROTO(cx, obj2);
-                 fp->scopeChain = obj;
+                 JS_ASSERT(!OBJ_IS_CLONED_BLOCK(youngestProto));
-             } else {
+                 parent = obj;
-                 JS_ASSERT(!fp->blockChain ||
+                 while ((parent = OBJ_GET_PARENT(cx, parent)) != youngestProto)
-                           OBJ_GET_PARENT(cx, obj) == fp->blockChain);
+                     JS_ASSERT(parent);
-                 fp->blockChain = obj;
              }
+ #endif
+             fp->blockChain = obj;
            END_CASE(JSOP_ENTERBLOCK)