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);
}
