The Tor Browser: js/src/vm/Shape-inl.h@6474c204b198 (annotated)

js/src/vm/Shape-inl.h@6474c204b198 (annotated)

js/src/vm/Shape-inl.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef vm_Shape_inl_h
 #define vm_Shape_inl_h
 #include "vm/Shape.h"
 #include "mozilla/TypeTraits.h"
 #include "jsobj.h"
 #include "vm/Interpreter.h"
 #include "vm/ScopeObject.h"
 #include "vm/TypedArrayObject.h"
 #include "jsatominlines.h"
 #include "jscntxtinlines.h"
 #include "jsgcinlines.h"
 namespace js {
 inline
 StackBaseShape::StackBaseShape(ThreadSafeContext *cx, const Class *clasp,
                                JSObject *parent, JSObject *metadata, uint32_t objectFlags)
   : flags(objectFlags),
     clasp(clasp),
     parent(parent),
     metadata(metadata),
     rawGetter(nullptr),
     rawSetter(nullptr),
     compartment(cx->compartment_)
 {}
 inline bool
 Shape::get(JSContext* cx, HandleObject receiver, JSObject* obj, JSObject *pobj,
            MutableHandleValue vp)
 {
     JS_ASSERT(!hasDefaultGetter());
     if (hasGetterValue()) {
         Value fval = getterValue();
         return InvokeGetterOrSetter(cx, receiver, fval, 0, 0, vp);
     }
     RootedId id(cx, propid());
     return CallJSPropertyOp(cx, getterOp(), receiver, id, vp);
 }
 inline Shape *
 Shape::search(ExclusiveContext *cx, jsid id)
 {
     Shape **_;
     return search(cx, this, id, &_);
 }
 inline Shape *
 Shape::searchThreadLocal(ThreadSafeContext *cx, Shape *start, jsid id,
                          Shape ***pspp, bool adding)
 {
     /*
      * Note that adding is a best-effort attempt to claim an entry in a shape
      * table. In the sequential case, this can be done either when the object
      * is in dictionary mode, or when it has been hashified.
      *
      * In parallel, an object that is in dictionary mode may be thread
      * local. That is, it was converted to a dictionary in the current thread,
      * with all its shapes cloned into the current thread, and its shape table
      * allocated thread locally. In that case, we may add to the
      * table. Otherwise it is not allowed.
      */
     JS_ASSERT_IF(adding, cx->isThreadLocal(start) && start->inDictionary());
     if (start->inDictionary()) {
         *pspp = start->table().search(id, adding);
         return SHAPE_FETCH(*pspp);
     }
     *pspp = nullptr;
     return searchNoHashify(start, id);
 }
 inline bool
 Shape::set(JSContext* cx, HandleObject obj, HandleObject receiver, bool strict,
            MutableHandleValue vp)
 {
     JS_ASSERT_IF(hasDefaultSetter(), hasGetterValue());
     if (attrs & JSPROP_SETTER) {
         Value fval = setterValue();
         return InvokeGetterOrSetter(cx, receiver, fval, 1, vp.address(), vp);
     }
     if (attrs & JSPROP_GETTER)
         return js_ReportGetterOnlyAssignment(cx, strict);
     RootedId id(cx, propid());
     /*
      * |with (it) color='red';| ends up here.
      * Avoid exposing the With object to native setters.
      */
     if (obj->is<DynamicWithObject>()) {
         RootedObject nobj(cx, &obj->as<DynamicWithObject>().object());
         return CallJSPropertyOpSetter(cx, setterOp(), nobj, id, strict, vp);
     }
     return CallJSPropertyOpSetter(cx, setterOp(), obj, id, strict, vp);
 }
 /* static */ inline Shape *
 Shape::search(ExclusiveContext *cx, Shape *start, jsid id, Shape ***pspp, bool adding)
 {
     if (start->inDictionary()) {
         *pspp = start->table().search(id, adding);
         return SHAPE_FETCH(*pspp);
     }
     *pspp = nullptr;
     if (start->hasTable()) {
         Shape **spp = start->table().search(id, adding);
         return SHAPE_FETCH(spp);
     }
     if (start->numLinearSearches() == LINEAR_SEARCHES_MAX) {
         if (start->isBigEnoughForAShapeTable()) {
             if (Shape::hashify(cx, start)) {
                 Shape **spp = start->table().search(id, adding);
                 return SHAPE_FETCH(spp);
             } else {
                 cx->recoverFromOutOfMemory();
             }
         }
         /*
          * No table built -- there weren't enough entries, or OOM occurred.
          * Don't increment numLinearSearches, to keep hasTable() false.
          */
         JS_ASSERT(!start->hasTable());
     } else {
         start->incrementNumLinearSearches();
     }
     for (Shape *shape = start; shape; shape = shape->parent) {
         if (shape->propidRef() == id)
             return shape;
     }
     return nullptr;
 }
 template<class ObjectSubclass>
 /* static */ inline bool
 EmptyShape::ensureInitialCustomShape(ExclusiveContext *cx, Handle<ObjectSubclass*> obj)
 {
     static_assert(mozilla::IsBaseOf<JSObject, ObjectSubclass>::value,
                   "ObjectSubclass must be a subclass of JSObject");
     // If the provided object has a non-empty shape, it was given the cached
     // initial shape when created: nothing to do.
     if (!obj->nativeEmpty())
         return true;
     // If no initial shape was assigned, do so.
     RootedShape shape(cx, ObjectSubclass::assignInitialShape(cx, obj));
     if (!shape)
         return false;
     MOZ_ASSERT(!obj->nativeEmpty());
     // If the object is a standard prototype -- |RegExp.prototype|,
     // |String.prototype|, |RangeError.prototype|, &c. -- GlobalObject.cpp's
     // |CreateBlankProto| marked it as a delegate.  These are the only objects
     // of this class that won't use the standard prototype, and there's no
     // reason to pollute the initial shape cache with entries for them.
     if (obj->isDelegate())
         return true;
     // Cache the initial shape for non-prototype objects, however, so that
     // future instances will begin life with that shape.
     RootedObject proto(cx, obj->getProto());
     EmptyShape::insertInitialShape(cx, shape, proto);
     return true;
 }
 inline
 AutoRooterGetterSetter::Inner::Inner(ThreadSafeContext *cx, uint8_t attrs,
                                      PropertyOp *pgetter_, StrictPropertyOp *psetter_)
   : CustomAutoRooter(cx), attrs(attrs),
     pgetter(pgetter_), psetter(psetter_)
 {
     JS_ASSERT_IF(attrs & JSPROP_GETTER, !IsPoisonedPtr(*pgetter));
     JS_ASSERT_IF(attrs & JSPROP_SETTER, !IsPoisonedPtr(*psetter));
 }
 inline
 AutoRooterGetterSetter::AutoRooterGetterSetter(ThreadSafeContext *cx, uint8_t attrs,
                                                PropertyOp *pgetter, StrictPropertyOp *psetter
                                                MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
 {
     if (attrs & (JSPROP_GETTER | JSPROP_SETTER))
         inner.construct(cx, attrs, pgetter, psetter);
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
 }
 static inline uint8_t
 GetShapeAttributes(JSObject *obj, Shape *shape)
 {
     JS_ASSERT(obj->isNative());
     if (IsImplicitDenseOrTypedArrayElement(shape)) {
         if (obj->is<TypedArrayObject>())
             return JSPROP_ENUMERATE | JSPROP_PERMANENT;
         return JSPROP_ENUMERATE;
     }
     return shape->attributes();
 }
 } /* namespace js */
 #endif /* vm_Shape_inl_h */

The Tor Browser / annotate

js/src/vm/Shape-inl.h@6474c204b198 (annotated)

js/src/vm/Shape-inl.h