js/src/vm/JSObject-inl.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef vm_JSObject_inl_h
   8 #define vm_JSObject_inl_h
   9
  10 #include "vm/JSObject.h"
  11
  12 #include "js/Object.h"  // JS::GetBuiltinClass
  13 #include "vm/ArrayObject.h"
  14 #include "vm/BoundFunctionObject.h"
  15 #include "vm/EnvironmentObject.h"
  16 #include "vm/JSFunction.h"
  17 #include "vm/Probes.h"
  18 #include "vm/PropertyResult.h"
  19 #include "vm/TypedArrayObject.h"
  20
  21 #ifdef ENABLE_RECORD_TUPLE
  22 #  include "vm/TupleType.h"
  23 #endif
  24
  25 #include "gc/GCContext-inl.h"
  26 #include "gc/ObjectKind-inl.h"
  27 #include "vm/ObjectOperations-inl.h"  // js::MaybeHasInterestingSymbolProperty
  28
  29 namespace js {
  30
  31 #ifdef ENABLE_RECORD_TUPLE
  32 // Defined in vm/RecordTupleShared.{h,cpp}. We cannot include that file
  33 // because it causes circular dependencies.
  34 extern bool IsExtendedPrimitiveWrapper(const JSObject& obj);
  35 #endif
  36
  37 // Get the GC kind to use for scripted 'new', empty object literals ({}), and
  38 // the |Object| constructor.
  39 static inline gc::AllocKind NewObjectGCKind() { return gc::AllocKind::OBJECT4; }
  40
  41 }  // namespace js
  42
  43 MOZ_ALWAYS_INLINE uint32_t js::NativeObject::numDynamicSlots() const {
  44   uint32_t slots = getSlotsHeader()->capacity();
  45   MOZ_ASSERT(slots == calculateDynamicSlots());
  46   MOZ_ASSERT_IF(hasDynamicSlots() && !hasUniqueId(), slots != 0);
  47
  48   return slots;
  49 }
  50
  51 MOZ_ALWAYS_INLINE uint32_t js::NativeObject::calculateDynamicSlots() const {
  52   return calculateDynamicSlots(numFixedSlots(), slotSpan(), getClass());
  53 }
  54
  55 /* static */ MOZ_ALWAYS_INLINE uint32_t js::NativeObject::calculateDynamicSlots(
  56     uint32_t nfixed, uint32_t span, const JSClass* clasp) {
  57   if (span <= nfixed) {
  58     return 0;
  59   }
  60
  61   uint32_t ndynamic = span - nfixed;
  62
  63   // Increase the slots to SLOT_CAPACITY_MIN to decrease the likelihood
  64   // the dynamic slots need to get increased again. ArrayObjects ignore
  65   // this because slots are uncommon in that case.
  66   if (clasp != &ArrayObject::class_ && ndynamic <= SLOT_CAPACITY_MIN) {
  67     return SLOT_CAPACITY_MIN;
  68   }
  69
  70   uint32_t count =
  71       mozilla::RoundUpPow2(ndynamic + ObjectSlots::VALUES_PER_HEADER);
  72
  73   uint32_t slots = count - ObjectSlots::VALUES_PER_HEADER;
  74   MOZ_ASSERT(slots >= ndynamic);
  75   return slots;
  76 }
  77
  78 /* static */ MOZ_ALWAYS_INLINE uint32_t
  79 js::NativeObject::calculateDynamicSlots(SharedShape* shape) {
  80   return calculateDynamicSlots(shape->numFixedSlots(), shape->slotSpan(),
  81                                shape->getObjectClass());
  82 }
  83
  84 inline void JSObject::finalize(JS::GCContext* gcx) {
  85   js::probes::FinalizeObject(this);
  86
  87 #ifdef DEBUG
  88   MOZ_ASSERT(isTenured());
  89   if (!IsBackgroundFinalized(asTenured().getAllocKind())) {
  90     /* Assert we're on the main thread. */
  91     MOZ_ASSERT(CurrentThreadCanAccessZone(zone()));
  92   }
  93 #endif
  94
  95   js::Shape* objShape = shape();
  96
  97   const JSClass* clasp = objShape->getObjectClass();
  98   if (clasp->hasFinalize()) {
  99     clasp->doFinalize(gcx, this);
 100   }
 101
 102   if (!objShape->isNative()) {
 103     return;
 104   }
 105
 106   js::NativeObject* nobj = &as<js::NativeObject>();
 107   if (nobj->hasDynamicSlots()) {
 108     js::ObjectSlots* slotsHeader = nobj->getSlotsHeader();
 109     size_t size = js::ObjectSlots::allocSize(slotsHeader->capacity());
 110     gcx->free_(this, slotsHeader, size, js::MemoryUse::ObjectSlots);
 111   }
 112
 113   if (nobj->hasDynamicElements()) {
 114     js::ObjectElements* elements = nobj->getElementsHeader();
 115     size_t size = elements->numAllocatedElements() * sizeof(js::HeapSlot);
 116     gcx->free_(this, nobj->getUnshiftedElementsHeader(), size,
 117                js::MemoryUse::ObjectElements);
 118   }
 119 }
 120
 121 inline bool JSObject::isQualifiedVarObj() const {
 122   if (is<js::DebugEnvironmentProxy>()) {
 123     return as<js::DebugEnvironmentProxy>().environment().isQualifiedVarObj();
 124   }
 125   bool rv = hasFlag(js::ObjectFlag::QualifiedVarObj);
 126   MOZ_ASSERT_IF(rv, is<js::GlobalObject>() || is<js::CallObject>() ||
 127                         is<js::VarEnvironmentObject>() ||
 128                         is<js::ModuleEnvironmentObject>() ||
 129                         is<js::NonSyntacticVariablesObject>() ||
 130                         (is<js::WithEnvironmentObject>() &&
 131                          !as<js::WithEnvironmentObject>().isSyntactic()));
 132   return rv;
 133 }
 134
 135 inline bool JSObject::isUnqualifiedVarObj() const {
 136   if (is<js::DebugEnvironmentProxy>()) {
 137     return as<js::DebugEnvironmentProxy>().environment().isUnqualifiedVarObj();
 138   }
 139   return is<js::GlobalObject>() || is<js::NonSyntacticVariablesObject>();
 140 }
 141
 142 inline bool JSObject::canHaveFixedElements() const {
 143   return (is<js::ArrayObject>() || IF_RECORD_TUPLE(is<js::TupleType>(), false));
 144 }
 145
 146 namespace js {
 147
 148 #ifdef DEBUG
 149 inline bool ClassCanHaveFixedData(const JSClass* clasp) {
 150   // Normally, the number of fixed slots given an object is the maximum
 151   // permitted for its size class. For array buffers and typed arrays we only
 152   // use enough to cover the class reserved slots, so that the remaining space
 153   // in the object's allocation is available for the buffer's data.
 154   return !clasp->isNativeObject() ||
 155          clasp == &js::FixedLengthArrayBufferObject::class_ ||
 156          clasp == &js::ResizableArrayBufferObject::class_ ||
 157          js::IsTypedArrayClass(clasp);
 158 }
 159 #endif
 160
 161 class MOZ_RAII AutoSuppressAllocationMetadataBuilder {
 162   JS::Zone* zone;
 163   bool saved;
 164
 165  public:
 166   explicit AutoSuppressAllocationMetadataBuilder(JSContext* cx)
 167       : zone(cx->zone()), saved(zone->suppressAllocationMetadataBuilder) {
 168     zone->suppressAllocationMetadataBuilder = true;
 169   }
 170
 171   ~AutoSuppressAllocationMetadataBuilder() {
 172     zone->suppressAllocationMetadataBuilder = saved;
 173   }
 174 };
 175
 176 // This function is meant to be called from allocation fast paths.
 177 //
 178 // If we do have an allocation metadata builder, it can cause a GC, so the
 179 // object must be rooted. The usual way to do this would be to make our callers
 180 // pass a HandleObject, but that would require them to pay the cost of rooting
 181 // the object unconditionally, even though collecting metadata is rare. Instead,
 182 // SetNewObjectMetadata's contract is that the caller must use the pointer
 183 // returned in place of the pointer passed. If a GC occurs, the returned pointer
 184 // may be the passed pointer, relocated by GC. If no GC could occur, it's just
 185 // passed through. We root nothing unless necessary.
 186 template <typename T>
 187 [[nodiscard]] static inline T* SetNewObjectMetadata(JSContext* cx, T* obj) {
 188   MOZ_ASSERT(cx->realm()->hasAllocationMetadataBuilder());
 189   MOZ_ASSERT(!cx->realm()->hasObjectPendingMetadata());
 190
 191   // The metadata builder is invoked for each object created on the main thread,
 192   // except when it's suppressed or we're throwing over-recursion error.
 193   if (!cx->zone()->suppressAllocationMetadataBuilder &&
 194       !cx->isThrowingOverRecursed()) {
 195     // Don't collect metadata on objects that represent metadata, to avoid
 196     // recursion.
 197     AutoSuppressAllocationMetadataBuilder suppressMetadata(cx);
 198
 199     Rooted<T*> rooted(cx, obj);
 200     cx->realm()->setNewObjectMetadata(cx, rooted);
 201     return rooted;
 202   }
 203
 204   return obj;
 205 }
 206
 207 }  // namespace js
 208
 209 inline js::GlobalObject& JSObject::nonCCWGlobal() const {
 210   /*
 211    * The global is read-barriered so that it is kept live by access through
 212    * the Realm. When accessed through a JSObject, however, the global will be
 213    * already kept live by the black JSObject's group pointer, so does not
 214    * need to be read-barriered.
 215    */
 216   return *nonCCWRealm()->unsafeUnbarrieredMaybeGlobal();
 217 }
 218
 219 inline bool JSObject::nonProxyIsExtensible() const {
 220   MOZ_ASSERT(!uninlinedIsProxyObject());
 221
 222 #ifdef ENABLE_RECORD_TUPLE
 223   if (js::IsExtendedPrimitiveWrapper(*this)) {
 224     return false;
 225   }
 226 #endif
 227   // [[Extensible]] for ordinary non-proxy objects is an object flag.
 228   return !hasFlag(js::ObjectFlag::NotExtensible);
 229 }
 230
 231 inline bool JSObject::hasInvalidatedTeleporting() const {
 232   return hasFlag(js::ObjectFlag::InvalidatedTeleporting);
 233 }
 234
 235 inline bool JSObject::needsProxyGetSetResultValidation() const {
 236   return hasFlag(js::ObjectFlag::NeedsProxyGetSetResultValidation);
 237 }
 238
 239 MOZ_ALWAYS_INLINE bool JSObject::maybeHasInterestingSymbolProperty() const {
 240   if (is<js::NativeObject>()) {
 241     return as<js::NativeObject>().hasInterestingSymbol();
 242   }
 243   return true;
 244 }
 245
 246 inline bool JSObject::staticPrototypeIsImmutable() const {
 247   MOZ_ASSERT(hasStaticPrototype());
 248   return hasFlag(js::ObjectFlag::ImmutablePrototype);
 249 }
 250
 251 namespace js {
 252
 253 static MOZ_ALWAYS_INLINE bool IsFunctionObject(const js::Value& v) {
 254   return v.isObject() && v.toObject().is<JSFunction>();
 255 }
 256
 257 static MOZ_ALWAYS_INLINE bool IsFunctionObject(const js::Value& v,
 258                                                JSFunction** fun) {
 259   if (v.isObject() && v.toObject().is<JSFunction>()) {
 260     *fun = &v.toObject().as<JSFunction>();
 261     return true;
 262   }
 263   return false;
 264 }
 265
 266 static MOZ_ALWAYS_INLINE bool IsNativeFunction(const js::Value& v,
 267                                                JSNative native) {
 268   JSFunction* fun;
 269   return IsFunctionObject(v, &fun) && fun->maybeNative() == native;
 270 }
 271
 272 static MOZ_ALWAYS_INLINE bool IsNativeFunction(const JSObject* obj,
 273                                                JSNative native) {
 274   return obj->is<JSFunction>() && obj->as<JSFunction>().maybeNative() == native;
 275 }
 276
 277 // Return whether looking up a method on 'obj' definitely resolves to the
 278 // original specified native function. The method may conservatively return
 279 // 'false' in the case of proxies or other non-native objects.
 280 static MOZ_ALWAYS_INLINE bool HasNativeMethodPure(JSObject* obj,
 281                                                   PropertyName* name,
 282                                                   JSNative native,
 283                                                   JSContext* cx) {
 284   Value v;
 285   if (!GetPropertyPure(cx, obj, NameToId(name), &v)) {
 286     return false;
 287   }
 288
 289   return IsNativeFunction(v, native);
 290 }
 291
 292 // Return whether 'obj' definitely has no @@toPrimitive method.
 293 static MOZ_ALWAYS_INLINE bool HasNoToPrimitiveMethodPure(JSObject* obj,
 294                                                          JSContext* cx) {
 295   JS::Symbol* toPrimitive = cx->wellKnownSymbols().toPrimitive;
 296   JSObject* holder;
 297   if (!MaybeHasInterestingSymbolProperty(cx, obj, toPrimitive, &holder)) {
 298 #ifdef DEBUG
 299     NativeObject* pobj;
 300     PropertyResult prop;
 301     MOZ_ASSERT(LookupPropertyPure(cx, obj, PropertyKey::Symbol(toPrimitive),
 302                                   &pobj, &prop));
 303     MOZ_ASSERT(prop.isNotFound());
 304 #endif
 305     return true;
 306   }
 307
 308   NativeObject* pobj;
 309   PropertyResult prop;
 310   if (!LookupPropertyPure(cx, holder, PropertyKey::Symbol(toPrimitive), &pobj,
 311                           &prop)) {
 312     return false;
 313   }
 314
 315   return prop.isNotFound();
 316 }
 317
 318 extern bool ToPropertyKeySlow(JSContext* cx, HandleValue argument,
 319                               MutableHandleId result);
 320
 321 /* ES6 draft rev 28 (2014 Oct 14) 7.1.14 */
 322 MOZ_ALWAYS_INLINE bool ToPropertyKey(JSContext* cx, HandleValue argument,
 323                                      MutableHandleId result) {
 324   if (MOZ_LIKELY(argument.isPrimitive())) {
 325     return PrimitiveValueToId<CanGC>(cx, argument, result);
 326   }
 327
 328   return ToPropertyKeySlow(cx, argument, result);
 329 }
 330
 331 /*
 332  * Return true if this is a compiler-created internal function accessed by
 333  * its own object. Such a function object must not be accessible to script
 334  * or embedding code.
 335  */
 336 inline bool IsInternalFunctionObject(JSObject& funobj) {
 337   JSFunction& fun = funobj.as<JSFunction>();
 338   return fun.isInterpreted() && !fun.environment();
 339 }
 340
 341 inline gc::Heap GetInitialHeap(NewObjectKind newKind, const JSClass* clasp,
 342                                gc::AllocSite* site = nullptr) {
 343   if (newKind != GenericObject) {
 344     return gc::Heap::Tenured;
 345   }
 346   if (clasp->hasFinalize() && !CanNurseryAllocateFinalizedClass(clasp)) {
 347     return gc::Heap::Tenured;
 348   }
 349   if (site) {
 350     return site->initialHeap();
 351   }
 352   return gc::Heap::Default;
 353 }
 354
 355 /*
 356  * Make an object with the specified prototype. If parent is null, it will
 357  * default to the prototype's global if the prototype is non-null.
 358  */
 359 NativeObject* NewObjectWithGivenTaggedProto(JSContext* cx, const JSClass* clasp,
 360                                             Handle<TaggedProto> proto,
 361                                             gc::AllocKind allocKind,
 362                                             NewObjectKind newKind,
 363                                             ObjectFlags objFlags);
 364
 365 template <NewObjectKind NewKind>
 366 inline NativeObject* NewObjectWithGivenTaggedProto(JSContext* cx,
 367                                                    const JSClass* clasp,
 368                                                    Handle<TaggedProto> proto,
 369                                                    ObjectFlags objFlags) {
 370   gc::AllocKind allocKind = gc::GetGCObjectKind(clasp);
 371   return NewObjectWithGivenTaggedProto(cx, clasp, proto, allocKind, NewKind,
 372                                        objFlags);
 373 }
 374
 375 namespace detail {
 376
 377 template <typename T, NewObjectKind NewKind>
 378 inline T* NewObjectWithGivenTaggedProtoForKind(JSContext* cx,
 379                                                Handle<TaggedProto> proto) {
 380   JSObject* obj = NewObjectWithGivenTaggedProto<NewKind>(cx, &T::class_, proto,
 381                                                          ObjectFlags());
 382   return obj ? &obj->as<T>() : nullptr;
 383 }
 384
 385 }  // namespace detail
 386
 387 template <typename T>
 388 inline T* NewObjectWithGivenTaggedProto(JSContext* cx,
 389                                         Handle<TaggedProto> proto) {
 390   return detail::NewObjectWithGivenTaggedProtoForKind<T, GenericObject>(cx,
 391                                                                         proto);
 392 }
 393
 394 inline NativeObject* NewObjectWithGivenProto(JSContext* cx,
 395                                              const JSClass* clasp,
 396                                              HandleObject proto) {
 397   return NewObjectWithGivenTaggedProto<GenericObject>(
 398       cx, clasp, AsTaggedProto(proto), ObjectFlags());
 399 }
 400
 401 inline NativeObject* NewTenuredObjectWithGivenProto(
 402     JSContext* cx, const JSClass* clasp, HandleObject proto,
 403     ObjectFlags objFlags = ObjectFlags()) {
 404   return NewObjectWithGivenTaggedProto<TenuredObject>(
 405       cx, clasp, AsTaggedProto(proto), objFlags);
 406 }
 407
 408 template <typename T>
 409 inline T* NewObjectWithGivenProto(JSContext* cx, HandleObject proto) {
 410   return detail::NewObjectWithGivenTaggedProtoForKind<T, GenericObject>(
 411       cx, AsTaggedProto(proto));
 412 }
 413
 414 template <typename T>
 415 inline T* NewTenuredObjectWithGivenProto(JSContext* cx, HandleObject proto) {
 416   return detail::NewObjectWithGivenTaggedProtoForKind<T, TenuredObject>(
 417       cx, AsTaggedProto(proto));
 418 }
 419
 420 template <typename T>
 421 inline T* NewObjectWithGivenProtoAndKinds(JSContext* cx, HandleObject proto,
 422                                           gc::AllocKind allocKind,
 423                                           NewObjectKind newKind) {
 424   JSObject* obj = NewObjectWithGivenTaggedProto(
 425       cx, &T::class_, AsTaggedProto(proto), allocKind, newKind);
 426   return obj ? &obj->as<T>() : nullptr;
 427 }
 428
 429 // Make an object with the prototype set according to the cached prototype or
 430 // Object.prototype.
 431 NativeObject* NewObjectWithClassProto(JSContext* cx, const JSClass* clasp,
 432                                       HandleObject proto,
 433                                       gc::AllocKind allocKind,
 434                                       NewObjectKind newKind = GenericObject,
 435                                       ObjectFlags objFlags = ObjectFlags());
 436
 437 inline NativeObject* NewObjectWithClassProto(
 438     JSContext* cx, const JSClass* clasp, HandleObject proto,
 439     NewObjectKind newKind = GenericObject,
 440     ObjectFlags objFlags = ObjectFlags()) {
 441   gc::AllocKind allocKind = gc::GetGCObjectKind(clasp);
 442   return NewObjectWithClassProto(cx, clasp, proto, allocKind, newKind,
 443                                  objFlags);
 444 }
 445
 446 template <class T>
 447 inline T* NewObjectWithClassProto(JSContext* cx, HandleObject proto) {
 448   JSObject* obj = NewObjectWithClassProto(cx, &T::class_, proto, GenericObject);
 449   return obj ? &obj->as<T>() : nullptr;
 450 }
 451
 452 template <class T>
 453 inline T* NewObjectWithClassProtoAndKind(JSContext* cx, HandleObject proto,
 454                                          NewObjectKind newKind,
 455                                          ObjectFlags objFlags = ObjectFlags()) {
 456   JSObject* obj =
 457       NewObjectWithClassProto(cx, &T::class_, proto, newKind, objFlags);
 458   return obj ? &obj->as<T>() : nullptr;
 459 }
 460
 461 template <class T>
 462 inline T* NewObjectWithClassProto(JSContext* cx, HandleObject proto,
 463                                   gc::AllocKind allocKind,
 464                                   NewObjectKind newKind = GenericObject) {
 465   NativeObject* obj =
 466       NewObjectWithClassProto(cx, &T::class_, proto, allocKind, newKind);
 467   return obj ? &obj->as<T>() : nullptr;
 468 }
 469
 470 /*
 471  * Create a native instance of the given class with parent and proto set
 472  * according to the context's active global.
 473  */
 474 inline NativeObject* NewBuiltinClassInstance(
 475     JSContext* cx, const JSClass* clasp, gc::AllocKind allocKind,
 476     NewObjectKind newKind = GenericObject) {
 477   return NewObjectWithClassProto(cx, clasp, nullptr, allocKind, newKind);
 478 }
 479
 480 inline NativeObject* NewBuiltinClassInstance(
 481     JSContext* cx, const JSClass* clasp,
 482     NewObjectKind newKind = GenericObject) {
 483   gc::AllocKind allocKind = gc::GetGCObjectKind(clasp);
 484   return NewBuiltinClassInstance(cx, clasp, allocKind, newKind);
 485 }
 486
 487 template <typename T>
 488 inline T* NewBuiltinClassInstance(JSContext* cx) {
 489   JSObject* obj = NewBuiltinClassInstance(cx, &T::class_, GenericObject);
 490   return obj ? &obj->as<T>() : nullptr;
 491 }
 492
 493 template <typename T>
 494 inline T* NewTenuredBuiltinClassInstance(JSContext* cx) {
 495   JSObject* obj = NewBuiltinClassInstance(cx, &T::class_, TenuredObject);
 496   return obj ? &obj->as<T>() : nullptr;
 497 }
 498
 499 template <typename T>
 500 inline T* NewBuiltinClassInstanceWithKind(JSContext* cx,
 501                                           NewObjectKind newKind) {
 502   JSObject* obj = NewBuiltinClassInstance(cx, &T::class_, newKind);
 503   return obj ? &obj->as<T>() : nullptr;
 504 }
 505
 506 template <typename T>
 507 inline T* NewBuiltinClassInstance(JSContext* cx, gc::AllocKind allocKind,
 508                                   NewObjectKind newKind = GenericObject) {
 509   JSObject* obj = NewBuiltinClassInstance(cx, &T::class_, allocKind, newKind);
 510   return obj ? &obj->as<T>() : nullptr;
 511 }
 512
 513 static inline gc::AllocKind GuessArrayGCKind(size_t numElements) {
 514   if (numElements) {
 515     return gc::GetGCArrayKind(numElements);
 516   }
 517   return gc::AllocKind::OBJECT8;
 518 }
 519
 520 // Returns ESClass::Other if the value isn't an object, or if the object
 521 // isn't of one of the enumerated classes.  Otherwise returns the appropriate
 522 // class.
 523 inline bool GetClassOfValue(JSContext* cx, HandleValue v, ESClass* cls) {
 524   if (!v.isObject()) {
 525     *cls = ESClass::Other;
 526     return true;
 527   }
 528
 529   RootedObject obj(cx, &v.toObject());
 530   return JS::GetBuiltinClass(cx, obj, cls);
 531 }
 532
 533 extern NativeObject* InitClass(
 534     JSContext* cx, HandleObject obj, const JSClass* protoClass,
 535     HandleObject protoProto, const char* name, JSNative constructor,
 536     unsigned nargs, const JSPropertySpec* ps, const JSFunctionSpec* fs,
 537     const JSPropertySpec* static_ps, const JSFunctionSpec* static_fs,
 538     NativeObject** ctorp = nullptr);
 539
 540 MOZ_ALWAYS_INLINE const char* GetObjectClassName(JSContext* cx,
 541                                                  HandleObject obj) {
 542   if (obj->is<ProxyObject>()) {
 543     return Proxy::className(cx, obj);
 544   }
 545
 546   return obj->getClass()->name;
 547 }
 548
 549 inline bool IsCallable(const Value& v) {
 550   return v.isObject() && v.toObject().isCallable();
 551 }
 552
 553 // ES6 rev 24 (2014 April 27) 7.2.5 IsConstructor
 554 inline bool IsConstructor(const Value& v) {
 555   return v.isObject() && v.toObject().isConstructor();
 556 }
 557
 558 static inline bool MaybePreserveDOMWrapper(JSContext* cx, HandleObject obj) {
 559   if (!obj->getClass()->isDOMClass()) {
 560     return true;
 561   }
 562
 563   MOZ_ASSERT(cx->runtime()->preserveWrapperCallback);
 564   return cx->runtime()->preserveWrapperCallback(cx, obj);
 565 }
 566
 567 } /* namespace js */
 568
 569 MOZ_ALWAYS_INLINE bool JSObject::isCallable() const {
 570   if (is<JSFunction>()) {
 571     return true;
 572   }
 573   if (is<js::ProxyObject>()) {
 574     const js::ProxyObject& p = as<js::ProxyObject>();
 575     return p.handler()->isCallable(const_cast<JSObject*>(this));
 576   }
 577   return callHook() != nullptr;
 578 }
 579
 580 MOZ_ALWAYS_INLINE bool JSObject::isConstructor() const {
 581   if (is<JSFunction>()) {
 582     const JSFunction& fun = as<JSFunction>();
 583     return fun.isConstructor();
 584   }
 585   if (is<js::BoundFunctionObject>()) {
 586     const js::BoundFunctionObject& bound = as<js::BoundFunctionObject>();
 587     return bound.isConstructor();
 588   }
 589   if (is<js::ProxyObject>()) {
 590     const js::ProxyObject& p = as<js::ProxyObject>();
 591     return p.handler()->isConstructor(const_cast<JSObject*>(this));
 592   }
 593   return constructHook() != nullptr;
 594 }
 595
 596 MOZ_ALWAYS_INLINE JSNative JSObject::callHook() const {
 597   return getClass()->getCall();
 598 }
 599
 600 MOZ_ALWAYS_INLINE JSNative JSObject::constructHook() const {
 601   return getClass()->getConstruct();
 602 }
 603
 604 #endif /* vm_JSObject_inl_h */