LCOV - app.info - js/src/vm/ObjectImpl-inl.h

LCOV - code coverage report
| Current view: | directory - js/src/vm - ObjectImpl-inl.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 54 | 54 | 100.0 %
| Date: | 2012-04-21 | Functions: | 15 | 15 | 100.0 %

           1                 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
           2                 :  * vim: set ts=8 sw=4 et tw=78:
           3                 :  *
           4                 :  * This Source Code Form is subject to the terms of the Mozilla Public
           5                 :  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
           6                 :  * You can obtain one at http://mozilla.org/MPL/2.0/. */
           7                 :
           8                 : #ifndef ObjectImpl_inl_h___
           9                 : #define ObjectImpl_inl_h___
          10                 :
          11                 : #include "mozilla/Assertions.h"
          12                 :
          13                 : #include "jscell.h"
          14                 : #include "jscompartment.h"
          15                 : #include "jsgc.h"
          16                 : #include "jsgcmark.h"
          17                 :
          18                 : #include "js/TemplateLib.h"
          19                 :
          20                 : #include "ObjectImpl.h"
          21                 :
          22                 : inline bool
          23       685345403 : js::ObjectImpl::isNative() const
          24                 : {
          25       685345403 :     return lastProperty()->isNative();
          26                 : }
          27                 :
          28                 : inline js::Class *
          29     -1242726205 : js::ObjectImpl::getClass() const
          30                 : {
          31     -1242726205 :     return lastProperty()->getObjectClass();
          32                 : }
          33                 :
          34                 : inline JSClass *
          35         4514531 : js::ObjectImpl::getJSClass() const
          36                 : {
          37         4514531 :     return Jsvalify(getClass());
          38                 : }
          39                 :
          40                 : inline bool
          41     -1948954066 : js::ObjectImpl::hasClass(const Class *c) const
          42                 : {
          43     -1948954066 :     return getClass() == c;
          44                 : }
          45                 :
          46                 : inline const js::ObjectOps *
          47       292319236 : js::ObjectImpl::getOps() const
          48                 : {
          49       292319236 :     return &getClass()->ops;
          50                 : }
          51                 :
          52                 : inline bool
          53        42884399 : js::ObjectImpl::isDelegate() const
          54                 : {
          55        42884399 :     return lastProperty()->hasObjectFlag(BaseShape::DELEGATE);
          56                 : }
          57                 :
          58                 : inline bool
          59      1244944449 : js::ObjectImpl::inDictionaryMode() const
          60                 : {
          61      1244944449 :     return lastProperty()->inDictionary();
          62                 : }
          63                 :
          64                 : /* static */ inline size_t
          65       822196257 : js::ObjectImpl::dynamicSlotsCount(size_t nfixed, size_t span)
          66                 : {
          67       822196257 :     if (span <= nfixed)
          68       354180544 :         return 0;
          69       468015713 :     span -= nfixed;
          70       468015713 :     if (span <= SLOT_CAPACITY_MIN)
          71       120899951 :         return SLOT_CAPACITY_MIN;
          72                 :
          73       347115762 :     size_t slots = RoundUpPow2(span);
          74       347115762 :     MOZ_ASSERT(slots >= span);
          75       347115762 :     return slots;
          76                 : }
          77                 :
          78                 : inline size_t
          79        30100246 : js::ObjectImpl::sizeOfThis() const
          80                 : {
          81        30100246 :     return arenaHeader()->getThingSize();
          82                 : }
          83                 :
          84                 : /* static */ inline void
          85           90903 : js::ObjectImpl::readBarrier(ObjectImpl *obj)
          86                 : {
          87                 : #ifdef JSGC_INCREMENTAL
          88           90903 :     JSCompartment *comp = obj->compartment();
          89           90903 :     if (comp->needsBarrier()) {
          90             153 :         MOZ_ASSERT(!comp->rt->gcRunning);
          91             153 :         JSObject *tmp = obj->asObjectPtr();
          92             153 :         MarkObjectUnbarriered(comp->barrierTracer(), &tmp, "read barrier");
          93             153 :         JS_ASSERT(tmp == obj->asObjectPtr());
          94                 :     }
          95                 : #endif
          96           90903 : }
          97                 :
          98                 : inline void
          99         5801942 : js::ObjectImpl::privateWriteBarrierPre(void **old)
         100                 : {
         101                 : #ifdef JSGC_INCREMENTAL
         102         5801942 :     JSCompartment *comp = compartment();
         103         5801942 :     if (comp->needsBarrier()) {
         104             651 :         if (*old && getClass()->trace)
         105             160 :             getClass()->trace(comp->barrierTracer(), this->asObjectPtr());
         106                 :     }
         107                 : #endif
         108         5801942 : }
         109                 :
         110                 : inline void
         111         5801942 : js::ObjectImpl::privateWriteBarrierPost(void **old)
         112                 : {
         113         5801942 : }
         114                 :
         115                 : /* static */ inline void
         116        25450568 : js::ObjectImpl::writeBarrierPre(ObjectImpl *obj)
         117                 : {
         118                 : #ifdef JSGC_INCREMENTAL
         119                 :     /*
         120                 :      * This would normally be a null test, but TypeScript::global uses 0x1 as a
         121                 :      * special value.
         122                 :      */
         123        25450568 :     if (uintptr_t(obj) < 32)
         124        20618679 :         return;
         125                 :
         126         4831889 :     JSCompartment *comp = obj->compartment();
         127         4831889 :     if (comp->needsBarrier()) {
         128             242 :         MOZ_ASSERT(!comp->rt->gcRunning);
         129             242 :         JSObject *tmp = obj->asObjectPtr();
         130             242 :         MarkObjectUnbarriered(comp->barrierTracer(), &tmp, "write barrier");
         131             242 :         JS_ASSERT(tmp == obj->asObjectPtr());
         132                 :     }
         133                 : #endif
         134                 : }
         135                 :
         136                 : /* static */ inline void
         137        44120260 : js::ObjectImpl::writeBarrierPost(ObjectImpl *obj, void *addr)
         138                 : {
         139        44120260 : }
         140                 :
         141                 : inline bool
         142        46738613 : js::ObjectImpl::isExtensible() const
         143                 : {
         144        46738613 :     return !lastProperty()->hasObjectFlag(BaseShape::NOT_EXTENSIBLE);
         145                 : }
         146                 :
         147                 : #endif /* ObjectImpl_inl_h__ */

Generated by: LCOV version 1.7