static inline void MarkIdInternal(JSTracer *trc, jsid *id) { if (JSID_IS_STRING(*id)) { JSString *str = JSID_TO_STRING(*id); MarkInternal(trc, &str); *id = ATOM_TO_JSID(reinterpret_cast<JSAtom *>(str)); } else if (JS_UNLIKELY(JSID_IS_OBJECT(*id))) { JSObject *obj = JSID_TO_OBJECT(*id); MarkInternal(trc, &obj); *id = OBJECT_TO_JSID(obj); } }
void MarkKind(JSTracer *trc, void **thingp, JSGCTraceKind kind) { JS_ASSERT(thingp); JS_ASSERT(*thingp); JS_ASSERT(kind == GetGCThingTraceKind(*thingp)); switch (kind) { case JSTRACE_OBJECT: MarkInternal(trc, reinterpret_cast<JSObject **>(thingp)); break; case JSTRACE_STRING: MarkInternal(trc, reinterpret_cast<JSString **>(thingp)); break; case JSTRACE_SCRIPT: MarkInternal(trc, reinterpret_cast<JSScript **>(thingp)); break; case JSTRACE_SHAPE: MarkInternal(trc, reinterpret_cast<Shape **>(thingp)); break; case JSTRACE_BASE_SHAPE: MarkInternal(trc, reinterpret_cast<BaseShape **>(thingp)); break; case JSTRACE_TYPE_OBJECT: MarkInternal(trc, reinterpret_cast<types::TypeObject **>(thingp)); break; case JSTRACE_IONCODE: MarkInternal(trc, reinterpret_cast<ion::IonCode **>(thingp)); break; #if JS_HAS_XML_SUPPORT case JSTRACE_XML: MarkInternal(trc, reinterpret_cast<JSXML **>(thingp)); break; #endif } }
void MarkTypeRoot(JSTracer *trc, types::Type *v, const char *name) { JS_ROOT_MARKING_ASSERT(trc); JS_SET_TRACING_NAME(trc, name); if (v->isSingleObject()) { JSObject *obj = v->singleObject(); MarkInternal(trc, &obj); *v = types::Type::ObjectType(obj); } else if (v->isTypeObject()) { types::TypeObject *typeObj = v->typeObject(); MarkInternal(trc, &typeObj); *v = types::Type::ObjectType(typeObj); } }
static void MarkRoot(JSTracer *trc, T **thingp, const char *name) { JS_ROOT_MARKING_ASSERT(trc); JS_SET_TRACING_NAME(trc, name); MarkInternal(trc, thingp); }
void SStopWatch::Restart() { Root* root = m_root; if (root) { RestartInternal(root); MarkInternal(root); } }
static void MarkRootRange(JSTracer *trc, size_t len, T **vec, const char *name) { JS_ROOT_MARKING_ASSERT(trc); for (size_t i = 0; i < len; ++i) { JS_SET_TRACING_INDEX(trc, name, i); MarkInternal(trc, &vec[i]); } }
static inline void MarkIdInternal(JSTracer *trc, jsid *id) { if (JSID_IS_STRING(*id)) { JSString *str = JSID_TO_STRING(*id); JS_SET_TRACING_LOCATION(trc, (void *)id); MarkInternal(trc, &str); *id = NON_INTEGER_ATOM_TO_JSID(reinterpret_cast<JSAtom *>(str)); } else if (JS_UNLIKELY(JSID_IS_OBJECT(*id))) { JSObject *obj = JSID_TO_OBJECT(*id); JS_SET_TRACING_LOCATION(trc, (void *)id); MarkInternal(trc, &obj); *id = OBJECT_TO_JSID(obj); } else { /* Unset realLocation manually if we do not call MarkInternal. */ JS_UNSET_TRACING_LOCATION(trc); } }
static void MarkRange(JSTracer *trc, size_t len, HeapPtr<T> *vec, const char *name) { for (size_t i = 0; i < len; ++i) { if (T *obj = vec[i]) { JS_SET_TRACING_INDEX(trc, name, i); MarkInternal(trc, obj); } } }
static void MarkRange(JSTracer *trc, size_t len, HeapPtr<T> *vec, const char *name) { for (size_t i = 0; i < len; ++i) { if (vec[i].get()) { JS_SET_TRACING_INDEX(trc, name, i); MarkInternal(trc, vec[i].unsafeGet()); } } }
void SStopWatch::StartProfiling(uint32_t flags) { Root* root = m_root; if (root == NULL || m_type == TYPE_CHILD) return; root->extensions |= EXTENSION_PROFILING; root->profFlags = flags; root->profError = B_OK; RestartInternal(root); MarkInternal(root); }
// Normal constructor. SStopWatch::SStopWatch(const char *name, uint32_t flags, int32_t minWeight, size_t maxItems) { Root* root = m_root = CurrentRoot(); // If this stop watch is nesting, use the existing context. if (root != NULL) { InitChild(root, name); return; } const size_t numNodes = maxItems ? maxItems : (flags&B_STOP_WATCH_NESTING) ? 10000 : 0; root = m_root = (Root*)malloc(sizeof(Root) + sizeof(Node)*numNodes); memset(root, 0, sizeof(Root) + sizeof(Node)*numNodes); Node* node = m_node = &root->top; root->flags = flags; root->extensions = 0; root->minWeight = minWeight; root->suspendTime = 0; root->perfNumRatios = 0; root->currentNode = node; root->numNodes = numNodes; root->curNodeIndex = 0; node->prev = NULL; m_type = TYPE_PLAIN; m_parent = NULL; if ((flags&B_STOP_WATCH_NESTING) != 0) { SetCurrentRoot(root); m_type = TYPE_ROOT; } if ((flags&B_STOP_WATCH_HIGH_PRIORITY) != 0) { KALThreadInfoType info; KeyID thread = (KeyID)SysCurrentThread(); KALThreadGetInfo(thread, kKALThreadInfoTypeCurrentVersion, &info); root->origPriority = info.currentPriority; KALThreadChangePriority(thread, sysThreadPriorityHigh); } node->children = NULL; node->name = name; node->time = 0; node->lap = 0; RestartInternal(root); MarkInternal(root); }
void SStopWatch::StartPerformance(perf_counter_t cntA, perf_counter_t cntB, uint32_t flags) { Root* root = m_root; if (root == NULL || m_type == TYPE_CHILD) return; root->extensions |= (flags&B_COUNT_HIGH_PRECISION) ? EXTENSION_PERFORMANCE_HIGH : EXTENSION_PERFORMANCE; root->perfFlags = flags; root->perfCounters[0] = cntA; root->perfCounters[1] = cntB; RestartInternal(root); MarkInternal(root); }
void SStopWatch::InitChild(Root* root, const char* name) { m_type = TYPE_CHILD; ErrFatalErrorIf(++root->curNodeIndex >= root->numNodes, "Out of memory for stop watch nodes!"); Node* node = m_node = (&root->top) + root->curNodeIndex; m_parent = root->currentNode; root->currentNode = node; node->prev = m_parent->children; m_parent->children = node; node->children = NULL; node->name = name; node->time = 0; node->lap = 0; RestartInternal(root); MarkInternal(root); }
void MarkObject(JSTracer *trc, HeapPtr<GlobalObject, JSScript *> *thingp, const char *name) { JS_SET_TRACING_NAME(trc, name); MarkInternal(trc, thingp->unsafeGet()); }
static void Mark(JSTracer *trc, HeapPtr<T> *thing, const char *name) { JS_SET_TRACING_NAME(trc, name); MarkInternal(trc, thing->unsafeGet()); }
static void MarkUnbarriered(JSTracer *trc, T **thingp, const char *name) { JS_SET_TRACING_NAME(trc, name); MarkInternal(trc, thingp); }
void SStopWatch::Mark() { if (m_root) MarkInternal(m_root); }