void
jsd_NewScriptHookProc(
JSContext *cx,
const char *filename, /* URL this script loads from */
unsigned lineno, /* line where this script starts */
JSScript *script,
JSFunction *fun,
void* callerdata )
{
JSDScript* jsdscript = NULL;
JSDContext* jsdc = (JSDContext*) callerdata;
JSD_ScriptHookProc hook;
void* hookData;
JSD_ASSERT_VALID_CONTEXT(jsdc);
if( JSD_IS_DANGEROUS_THREAD(jsdc) )
return;
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = _newJSDScript(jsdc, cx, script);
JSD_UNLOCK_SCRIPTS(jsdc);
if( ! jsdscript )
return;
#ifdef JSD_DUMP
JSD_LOCK_SCRIPTS(jsdc);
_dumpJSDScript(jsdc, jsdscript, "***NEW Script: ");
_dumpJSDScriptList( jsdc );
JSD_UNLOCK_SCRIPTS(jsdc);
#endif /* JSD_DUMP */
/* local in case jsdc->scriptHook gets cleared on another thread */
JSD_LOCK();
hook = jsdc->scriptHook;
if( hook )
jsdscript->flags = jsdscript->flags | JSD_SCRIPT_CALL_DESTROY_HOOK_BIT;
hookData = jsdc->scriptHookData;
JSD_UNLOCK();
if( hook )
hook(jsdc, jsdscript, JS_TRUE, hookData);
}
void
jsd_ClearAllProfileData(JSDContext* jsdc)
{
JSDScript *current;
JSD_LOCK_SCRIPTS(jsdc);
current = (JSDScript *)jsdc->scripts.next;
while (current != (JSDScript *)&jsdc->scripts)
{
jsd_ClearScriptProfileData(jsdc, current);
current = (JSDScript *)current->links.next;
}
JSD_UNLOCK_SCRIPTS(jsdc);
}
static void
_interpreterTrace(JSDContext* jsdc, JSContext *cx, JSStackFrame *fp,
JSBool before)
{
JSDScript* jsdscript = NULL;
JSScript * script;
static indent = 0;
char* buf;
const char* funName = NULL;
script = JS_GetFrameScript(cx, fp);
if(script)
{
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindJSDScript(jsdc, script);
JSD_UNLOCK_SCRIPTS(jsdc);
if(jsdscript)
funName = JSD_GetScriptFunctionName(jsdc, jsdscript);
}
if(!funName)
funName = "TOP_LEVEL";
if(before)
{
buf = JS_smprintf("%sentering %s %s this: %0x\n",
_indentSpaces(indent++),
funName,
JS_IsConstructorFrame(cx, fp) ? "constructing":"",
(int)JS_GetFrameThis(cx, fp));
}
else
{
buf = JS_smprintf("%sleaving %s\n",
_indentSpaces(--indent),
funName);
}
JS_ASSERT(indent >= 0);
if(!buf)
return;
printf(buf);
free(buf);
}
static void
_interpreterTrace(JSDContext* jsdc, JSContext *cx, JSAbstractFramePtr frame,
bool isConstructing, JSBool before)
{
JSDScript* jsdscript = NULL;
JSScript * script;
static indent = 0;
JSString* funName = NULL;
script = frame.script();
if(script)
{
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, frame);
JSD_UNLOCK_SCRIPTS(jsdc);
if(jsdscript)
funName = JSD_GetScriptFunctionId(jsdc, jsdscript);
}
if(before)
printf("%sentering ", _indentSpaces(indent++));
else
printf("%sleaving ", _indentSpaces(--indent));
if (!funName)
printf("TOP_LEVEL");
else
JS_FileEscapedString(stdout, funName, 0);
if(before)
{
jsval thisVal;
printf("%s this: ", isConstructing ? "constructing":"");
if (JS_GetFrameThis(cx, frame, &thisVal))
printf("0x%0llx", (uintptr_t) thisVal);
else
puts("<unavailable>");
}
printf("\n");
JS_ASSERT(indent >= 0);
}
static JSDStackFrameInfo*
_addNewFrame(JSDContext* jsdc,
JSDThreadState* jsdthreadstate,
JSScript* script,
jsuword pc,
JSStackFrame* fp)
{
JSDStackFrameInfo* jsdframe;
JSDScript* jsdscript = NULL;
if (!JS_IsNativeFrame(jsdthreadstate->context, fp))
{
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindJSDScript(jsdc, script);
JSD_UNLOCK_SCRIPTS(jsdc);
if (!jsdscript || (jsdc->flags & JSD_HIDE_DISABLED_FRAMES &&
!JSD_IS_DEBUG_ENABLED(jsdc, jsdscript)))
{
return NULL;
}
if (!JSD_IS_DEBUG_ENABLED(jsdc, jsdscript))
jsdthreadstate->flags |= TS_HAS_DISABLED_FRAME;
}
jsdframe = (JSDStackFrameInfo*) calloc(1, sizeof(JSDStackFrameInfo));
if( ! jsdframe )
return NULL;
jsdframe->jsdthreadstate = jsdthreadstate;
jsdframe->jsdscript = jsdscript;
jsdframe->pc = pc;
jsdframe->fp = fp;
JS_APPEND_LINK(&jsdframe->links, &jsdthreadstate->stack);
jsdthreadstate->stackDepth++;
return jsdframe;
}
JSDScript*
jsd_GetScriptForValue(JSDContext* jsdc, JSDValue* jsdval)
{
JSContext* cx = jsdc->dumbContext;
jsval val = jsdval->val;
JSFunction* fun = NULL;
JSExceptionState* exceptionState;
JSScript* script = NULL;
JSDScript* jsdscript;
JSCrossCompartmentCall *call = NULL;
if (!jsd_IsValueFunction(jsdc, jsdval))
return NULL;
JS_BeginRequest(cx);
call = JS_EnterCrossCompartmentCall(cx, JSVAL_TO_OBJECT(val));
if (!call) {
JS_EndRequest(cx);
return NULL;
}
exceptionState = JS_SaveExceptionState(cx);
fun = JSD_GetValueFunction(jsdc, jsdval);
JS_RestoreExceptionState(cx, exceptionState);
if (fun)
script = JS_GetFunctionScript(cx, fun);
JS_LeaveCrossCompartmentCall(call);
JS_EndRequest(cx);
if (!script)
return NULL;
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindJSDScript(jsdc, script);
JSD_UNLOCK_SCRIPTS(jsdc);
return jsdscript;
}
JSTrapStatus
jsd_InterruptHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
void *closure)
{
JSDScript* jsdscript;
JSDContext* jsdc = (JSDContext*) closure;
JSD_ExecutionHookProc hook;
void* hookData;
if( ! jsdc || ! jsdc->inited )
return JSTRAP_CONTINUE;
if( JSD_IS_DANGEROUS_THREAD(jsdc) )
return JSTRAP_CONTINUE;
/* local in case jsdc->interruptHook gets cleared on another thread */
JSD_LOCK();
hook = jsdc->interruptHook;
hookData = jsdc->interruptHookData;
JSD_UNLOCK();
if (!hook)
return JSTRAP_CONTINUE;
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, JSNullFramePtr());
JSD_UNLOCK_SCRIPTS(jsdc);
if( ! jsdscript )
return JSTRAP_CONTINUE;
#ifdef LIVEWIRE
if( ! jsdlw_UserCodeAtPC(jsdc, jsdscript, (uintptr_t)pc) )
return JSTRAP_CONTINUE;
#endif
return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_INTERRUPTED,
hook, hookData, rval);
}
void
jsd_Constructing(JSDContext* jsdc, JSContext *cx, JSObject *obj,
JSAbstractFramePtr frame)
{
JSDObject* jsdobj;
JS::RootedScript script(cx);
JSDScript* jsdscript;
const char* ctorURL;
JSString* ctorNameStr;
const char* ctorName;
JSD_LOCK_OBJECTS(jsdc);
jsdobj = jsd_GetJSDObjectForJSObject(jsdc, obj);
if( jsdobj && !jsdobj->ctorURL )
{
script = frame.script();
if( script )
{
ctorURL = JS_GetScriptFilename(cx, script);
if( ctorURL )
jsdobj->ctorURL = jsd_AddAtom(jsdc, ctorURL);
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, frame);
JSD_UNLOCK_SCRIPTS(jsdc);
if( jsdscript && (ctorNameStr = jsd_GetScriptFunctionId(jsdc, jsdscript)) ) {
if( (ctorName = JS_EncodeString(cx, ctorNameStr)) ) {
jsdobj->ctorName = jsd_AddAtom(jsdc, ctorName);
JS_free(cx, (void *) ctorName);
}
}
jsdobj->ctorLineno = JS_GetScriptBaseLineNumber(cx, script);
}
}
TRACEOBJ(jsdc, jsdobj, 3);
JSD_UNLOCK_OBJECTS(jsdc);
}
void
jsd_Constructing(JSDContext* jsdc, JSContext *cx, JSObject *obj,
JSStackFrame *fp)
{
JSDObject* jsdobj;
JSScript* script;
JSDScript* jsdscript;
const char* ctorURL;
const char* ctorName;
JSD_LOCK_OBJECTS(jsdc);
jsdobj = jsd_GetJSDObjectForJSObject(jsdc, obj);
if( jsdobj && !jsdobj->ctorURL && !JS_IsNativeFrame(cx, fp) )
{
script = JS_GetFrameScript(cx, fp);
if( script )
{
ctorURL = JS_GetScriptFilename(cx, script);
if( ctorURL )
jsdobj->ctorURL = jsd_AddAtom(jsdc, ctorURL);
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, fp);
JSD_UNLOCK_SCRIPTS(jsdc);
if( jsdscript )
{
ctorName = jsd_GetScriptFunctionName(jsdc, jsdscript);
if( ctorName )
jsdobj->ctorName = jsd_AddAtom(jsdc, ctorName);
}
jsdobj->ctorLineno = JS_GetScriptBaseLineNumber(cx, script);
}
}
TRACEOBJ(jsdc, jsdobj, 3);
JSD_UNLOCK_OBJECTS(jsdc);
}
JSD_UnlockScriptSubsystem(JSDContext* jsdc)
{
JSD_ASSERT_VALID_CONTEXT(jsdc);
JSD_UNLOCK_SCRIPTS(jsdc);
}
JSBool
_callHook(JSDContext *jsdc, JSContext *cx, JSAbstractFramePtr frame, bool isConstructing,
JSBool before, unsigned type, JSD_CallHookProc hook, void *hookData)
{
JSDScript* jsdscript;
JSScript* jsscript;
JSBool hookresult = JS_TRUE;
if (!jsdc || !jsdc->inited)
return JS_FALSE;
if (!hook && !(jsdc->flags & JSD_COLLECT_PROFILE_DATA))
{
/* no hook to call, no profile data needs to be collected,
* so there is nothing to do here.
*/
return hookresult;
}
if (before && isConstructing) {
js::RootedValue newObj(cx);
if (!frame.getThisValue(cx, &newObj))
return JS_FALSE;
jsd_Constructing(jsdc, cx, JSVAL_TO_OBJECT(newObj), frame);
}
jsscript = frame.script();
if (jsscript)
{
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, jsscript, frame);
JSD_UNLOCK_SCRIPTS(jsdc);
if (jsdscript)
{
if (JSD_IS_PROFILE_ENABLED(jsdc, jsdscript))
{
JSDProfileData *pdata;
pdata = jsd_GetScriptProfileData (jsdc, jsdscript);
if (pdata)
{
if (before)
{
if (!pdata->lastCallStart)
{
int64_t now;
JSDProfileData *callerpdata;
/* Get the time just the once, for consistency. */
now = JS_Now();
/* This contains a pointer to the profile data for
* the caller of this function. */
callerpdata = jsdc->callingFunctionPData;
if (callerpdata)
{
int64_t ll_delta;
pdata->caller = callerpdata;
/* We need to 'stop' the timer for the caller.
* Use time since last return if appropriate. */
ll_delta = jsdc->lastReturnTime
? now - jsdc->lastReturnTime
: now - callerpdata->lastCallStart;
callerpdata->runningTime += ll_delta;
}
/* We're the new current function, and no return
* has happened yet. */
jsdc->callingFunctionPData = pdata;
jsdc->lastReturnTime = 0;
/* This function has no running time (just been
* called!), and we'll need the call start time. */
pdata->runningTime = 0;
pdata->lastCallStart = now;
} else {
if (++pdata->recurseDepth > pdata->maxRecurseDepth)
pdata->maxRecurseDepth = pdata->recurseDepth;
}
/* make sure we're called for the return too. */
hookresult = JS_TRUE;
} else if (!pdata->recurseDepth && pdata->lastCallStart) {
int64_t now, ll_delta;
double delta;
now = JS_Now();
ll_delta = now - pdata->lastCallStart;
delta = ll_delta;
delta /= 1000.0;
pdata->totalExecutionTime += delta;
/* minExecutionTime starts as 0, so we need to overwrite
* it on the first call always. */
if ((0 == pdata->callCount) ||
delta < pdata->minExecutionTime)
{
pdata->minExecutionTime = delta;
}
if (delta > pdata->maxExecutionTime)
pdata->maxExecutionTime = delta;
/* If we last returned from a function (as opposed to
* having last entered this function), we need to inc.
* the running total by the time delta since the last
* return, and use the running total instead of the
* delta calculated above. */
if (jsdc->lastReturnTime)
{
/* Add last chunk to running time, and use total
* running time as 'delta'. */
ll_delta = now - jsdc->lastReturnTime;
pdata->runningTime += ll_delta;
delta = pdata->runningTime;
delta /= 1000.0;
}
pdata->totalOwnExecutionTime += delta;
/* See minExecutionTime comment above. */
if ((0 == pdata->callCount) ||
delta < pdata->minOwnExecutionTime)
{
pdata->minOwnExecutionTime = delta;
}
if (delta > pdata->maxOwnExecutionTime)
pdata->maxOwnExecutionTime = delta;
/* Current function is now our caller. */
jsdc->callingFunctionPData = pdata->caller;
/* No hanging pointers, please. */
pdata->caller = NULL;
/* Mark the time we returned, and indicate this
* function is no longer running. */
jsdc->lastReturnTime = now;
pdata->lastCallStart = 0;
++pdata->callCount;
} else if (pdata->recurseDepth) {
--pdata->recurseDepth;
++pdata->callCount;
}
}
if (hook)
jsd_CallCallHook (jsdc, cx, type, hook, hookData);
} else {
if (hook)
hookresult =
jsd_CallCallHook (jsdc, cx, type, hook, hookData);
else
hookresult = JS_TRUE;
}
}
}
#ifdef JSD_TRACE
_interpreterTrace(jsdc, cx, frame, isConstructing, before);
return JS_TRUE;
#else
return hookresult;
#endif
}
JSBool
_callHook(JSDContext *jsdc, JSContext *cx, JSStackFrame *fp, JSBool before,
uintN type, JSD_CallHookProc hook, void *hookData)
{
JSDScript* jsdscript;
JSScript* jsscript;
JSBool hookresult = JS_TRUE;
if (!jsdc || !jsdc->inited)
return JS_FALSE;
if (!hook && !(jsdc->flags & JSD_COLLECT_PROFILE_DATA) &&
jsdc->flags & JSD_DISABLE_OBJECT_TRACE)
{
/* no hook to call, no profile data needs to be collected, and
* the client has object tracing disabled, so there is nothing
* to do here.
*/
return hookresult;
}
if (before && JS_IsConstructorFrame(cx, fp))
jsd_Constructing(jsdc, cx, JS_GetFrameThis(cx, fp), fp);
jsscript = JS_GetFrameScript(cx, fp);
if (jsscript)
{
JSD_LOCK_SCRIPTS(jsdc);
jsdscript = jsd_FindJSDScript(jsdc, jsscript);
JSD_UNLOCK_SCRIPTS(jsdc);
if (jsdscript)
{
if (JSD_IS_PROFILE_ENABLED(jsdc, jsdscript))
{
JSDProfileData *pdata;
pdata = jsd_GetScriptProfileData (jsdc, jsdscript);
if (pdata)
{
if (before)
{
if (JSLL_IS_ZERO(pdata->lastCallStart))
{
int64 now;
JSDProfileData *callerpdata;
/* Get the time just the once, for consistency. */
now = JS_Now();
/* This contains a pointer to the profile data for
* the caller of this function. */
callerpdata = jsdc->callingFunctionPData;
if (callerpdata)
{
int64 ll_delta;
pdata->caller = callerpdata;
/* We need to 'stop' the timer for the caller.
* Use time since last return if appropriate. */
if (JSLL_IS_ZERO(jsdc->lastReturnTime))
{
JSLL_SUB(ll_delta, now, callerpdata->lastCallStart);
} else {
JSLL_SUB(ll_delta, now, jsdc->lastReturnTime);
}
JSLL_ADD(callerpdata->runningTime, callerpdata->runningTime, ll_delta);
}
/* We're the new current function, and no return
* has happened yet. */
jsdc->callingFunctionPData = pdata;
jsdc->lastReturnTime = JSLL_ZERO;
/* This function has no running time (just been
* called!), and we'll need the call start time. */
pdata->runningTime = JSLL_ZERO;
pdata->lastCallStart = now;
} else {
if (++pdata->recurseDepth > pdata->maxRecurseDepth)
pdata->maxRecurseDepth = pdata->recurseDepth;
}
/* make sure we're called for the return too. */
hookresult = JS_TRUE;
} else if (!pdata->recurseDepth &&
!JSLL_IS_ZERO(pdata->lastCallStart)) {
int64 now, ll_delta;
jsdouble delta;
now = JS_Now();
JSLL_SUB(ll_delta, now, pdata->lastCallStart);
JSLL_L2D(delta, ll_delta);
delta /= 1000.0;
pdata->totalExecutionTime += delta;
/* minExecutionTime starts as 0, so we need to overwrite
* it on the first call always. */
if ((0 == pdata->callCount) ||
delta < pdata->minExecutionTime)
{
pdata->minExecutionTime = delta;
}
if (delta > pdata->maxExecutionTime)
pdata->maxExecutionTime = delta;
/* If we last returned from a function (as opposed to
* having last entered this function), we need to inc.
* the running total by the time delta since the last
* return, and use the running total instead of the
* delta calculated above. */
if (!JSLL_IS_ZERO(jsdc->lastReturnTime))
{
/* Add last chunk to running time, and use total
* running time as 'delta'. */
JSLL_SUB(ll_delta, now, jsdc->lastReturnTime);
JSLL_ADD(pdata->runningTime, pdata->runningTime, ll_delta);
JSLL_L2D(delta, pdata->runningTime);
delta /= 1000.0;
}
pdata->totalOwnExecutionTime += delta;
/* See minExecutionTime comment above. */
if ((0 == pdata->callCount) ||
delta < pdata->minOwnExecutionTime)
{
pdata->minOwnExecutionTime = delta;
}
if (delta > pdata->maxOwnExecutionTime)
pdata->maxOwnExecutionTime = delta;
/* Current function is now our caller. */
jsdc->callingFunctionPData = pdata->caller;
/* No hanging pointers, please. */
pdata->caller = NULL;
/* Mark the time we returned, and indicate this
* function is no longer running. */
jsdc->lastReturnTime = now;
pdata->lastCallStart = JSLL_ZERO;
++pdata->callCount;
} else if (pdata->recurseDepth) {
--pdata->recurseDepth;
++pdata->callCount;
}
}
if (hook)
jsd_CallCallHook (jsdc, cx, type, hook, hookData);
} else {
if (hook)
hookresult =
jsd_CallCallHook (jsdc, cx, type, hook, hookData);
else
hookresult = JS_TRUE;
}
}
}
#ifdef JSD_TRACE
_interpreterTrace(jsdc, cx, fp, before);
return JS_TRUE;
#else
return hookresult;
#endif
}
