uintN
jsd_GetClosestLine(JSDContext* jsdc, JSDScript* jsdscript, jsuword pc)
{
uintN first = jsdscript->lineBase;
uintN last = first + jsd_GetScriptLineExtent(jsdc, jsdscript) - 1;
uintN line = pc
? JS_PCToLineNumber(jsdc->dumbContext,
jsdscript->script,
(jsbytecode*)pc)
: 0;
if( line < first )
return first;
if( line > last )
return last;
#ifdef LIVEWIRE
if( jsdscript && jsdscript->lwscript )
{
uintN newline;
jsdlw_ProcessedToRawLineNumber(jsdc, jsdscript, line, &newline);
line = newline;
}
#endif
return line;
}
unsigned
jsd_GetClosestLine(JSDContext* jsdc, JSDScript* jsdscript, uintptr_t pc)
{
JSCompartment* oldCompartment;
unsigned first = jsdscript->lineBase;
unsigned last = first + jsd_GetScriptLineExtent(jsdc, jsdscript) - 1;
unsigned line = 0;
oldCompartment = JS_EnterCompartmentOfScript(jsdc->dumbContext, jsdscript->script);
if (pc)
line = JS_PCToLineNumber(jsdc->dumbContext, jsdscript->script, (jsbytecode*)pc);
JS_LeaveCompartment(jsdc->dumbContext, oldCompartment);
if( line < first )
return first;
if( line > last )
return last;
#ifdef LIVEWIRE
if( jsdscript && jsdscript->lwscript )
{
unsigned newline;
jsdlw_ProcessedToRawLineNumber(jsdc, jsdscript, line, &newline);
line = newline;
}
#endif
return line;
}
nsresult
XPCJSStackFrame::CreateStack(JSContext* cx, JSStackFrame* fp,
XPCJSStackFrame** stack)
{
static const unsigned MAX_FRAMES = 100;
unsigned numFrames = 0;
nsRefPtr<XPCJSStackFrame> first = new XPCJSStackFrame();
nsRefPtr<XPCJSStackFrame> self = first;
while (fp && self) {
if (!JS_IsScriptFrame(cx, fp)) {
self->mLanguage = nsIProgrammingLanguage::CPLUSPLUS;
} else {
self->mLanguage = nsIProgrammingLanguage::JAVASCRIPT;
JSScript* script = JS_GetFrameScript(cx, fp);
jsbytecode* pc = JS_GetFramePC(cx, fp);
if (script && pc) {
JS::AutoEnterFrameCompartment ac;
if (ac.enter(cx, fp)) {
const char* filename = JS_GetScriptFilename(cx, script);
if (filename) {
self->mFilename = (char*)
nsMemory::Clone(filename,
sizeof(char)*(strlen(filename)+1));
}
self->mLineno = (int32_t) JS_PCToLineNumber(cx, script, pc);
JSFunction* fun = JS_GetFrameFunction(cx, fp);
if (fun) {
JSString *funid = JS_GetFunctionId(fun);
if (funid) {
size_t length = JS_GetStringEncodingLength(cx, funid);
if (length != size_t(-1)) {
self->mFunname = static_cast<char *>(nsMemory::Alloc(length + 1));
if (self->mFunname) {
JS_EncodeStringToBuffer(funid, self->mFunname, length);
self->mFunname[length] = '\0';
}
}
}
}
}
} else {
self->mLanguage = nsIProgrammingLanguage::CPLUSPLUS;
}
}
if (++numFrames > MAX_FRAMES) {
fp = NULL;
} else if (JS_FrameIterator(cx, &fp)) {
XPCJSStackFrame* frame = new XPCJSStackFrame();
self->mCaller = frame;
self = frame;
}
}
*stack = first.forget().get();
return NS_OK;
}
uintN
jsd_GetClosestLine(JSDContext* jsdc, JSDScript* jsdscript, jsuword pc)
{
JSCrossCompartmentCall *call;
uintN first = jsdscript->lineBase;
uintN last = first + jsd_GetScriptLineExtent(jsdc, jsdscript) - 1;
uintN line = 0;
call = JS_EnterCrossCompartmentCallScript(jsdc->dumbContext, jsdscript->script);
if(!call)
return 0;
if (pc)
line = JS_PCToLineNumber(jsdc->dumbContext, jsdscript->script, (jsbytecode*)pc);
JS_LeaveCrossCompartmentCall(call);
if( line < first )
return first;
if( line > last )
return last;
#ifdef LIVEWIRE
if( jsdscript && jsdscript->lwscript )
{
uintN newline;
jsdlw_ProcessedToRawLineNumber(jsdc, jsdscript, line, &newline);
line = newline;
}
#endif
return line;
}
/*
* call-seq:
* line_number(context, script, bytecode)
*
* Get the line number of the +bytecode+ given +context+ and +script+
*/
static VALUE line_number(VALUE UNUSED(self), VALUE context, VALUE script, VALUE bytecode)
{
JSContext * js = NULL;
JSScript * js_script = NULL;
jsbytecode * js_bytecode = NULL;
Data_Get_Struct(context, JSContext, js);
Data_Get_Struct(script, JSScript, js_script);
Data_Get_Struct(bytecode, jsbytecode, js_bytecode);
return INT2NUM((long)JS_PCToLineNumber(js, js_script, js_bytecode));
}
void CThreadDebugger::SetNewTrap(CActiveBreakPoint* activeBreakPoint, std::string filename, uint line)
{
ENSURE(activeBreakPoint->m_Script == NULL); // The trap must not be set already!
ENSURE(CheckIfMappingPresent(filename, line)); // You have to check if the mapping exists before calling this function!
jsbytecode* pc = m->m_LineToPCMap[filename][line].pBytecode;
JSScript* script = m->m_LineToPCMap[filename][line].pScript;
activeBreakPoint->m_Script = script;
activeBreakPoint->m_Pc = pc;
ENSURE(script != NULL && pc != NULL);
activeBreakPoint->m_ActualLine = JS_PCToLineNumber(m->m_pScriptInterface->GetContext(), script, pc);
JS_SetTrap(m->m_pScriptInterface->GetContext(), script, pc, TrapHandler_, PRIVATE_TO_JSVAL(this));
}
JSTrapStatus CThreadDebugger::StepIntoHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval, void* UNUSED(closure))
{
// We break when we are on the same stack frame but not on the same line
// or when we are on another stack frame.
uint line = JS_PCToLineNumber(cx, script, pc);
JSStackFrame* iter = NULL;
JSStackFrame* pStackFrame;
pStackFrame = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
uint lastBreakLine = GetLastBreakLine();
jsval val = JSVAL_VOID;
if ((*m->m_pLastBreakFrame == pStackFrame && lastBreakLine != line) || *m->m_pLastBreakFrame != pStackFrame)
return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_INTERRUP);
else
return JSTRAP_CONTINUE;
}
/* define properties that JS Error() expose, such as
fileName, lineNumber and stack
*/
static void
define_error_properties(JSContext *context,
JSObject *obj)
{
JSStackFrame *frame;
JSScript *script;
jsbytecode *pc;
jsval v;
GString *stack;
const char *filename;
GjsContext *gjs_context;
/* find the JS frame that triggered the error */
frame = NULL;
while (JS_FrameIterator(context, &frame)) {
if (JS_IsScriptFrame(context, frame))
break;
}
/* someone called gjs_throw at top of the stack?
well, no stack in that case
*/
if (!frame)
return;
script = JS_GetFrameScript(context, frame);
pc = JS_GetFramePC(context, frame);
stack = g_string_new(NULL);
gjs_context = JS_GetContextPrivate(context);
gjs_context_print_stack_to_buffer(gjs_context, frame, stack);
if (gjs_string_from_utf8(context, stack->str, stack->len, &v))
JS_DefineProperty(context, obj, "stack", v,
NULL, NULL, JSPROP_ENUMERATE);
filename = JS_GetScriptFilename(context, script);
if (gjs_string_from_filename(context, filename, -1, &v))
JS_DefineProperty(context, obj, "fileName", v,
NULL, NULL, JSPROP_ENUMERATE);
v = INT_TO_JSVAL(JS_PCToLineNumber(context, script, pc));
JS_DefineProperty(context, obj, "lineNumber", v,
NULL, NULL, JSPROP_ENUMERATE);
g_string_free(stack, TRUE);
}
ScriptLocationName(const ScriptLocation& loc)
{
JSContext* cx = loc.cx;
JSScript* script = loc.script;
jsbytecode* pc = loc.pc;
std::string filename = JS_GetScriptFilename(cx, script);
size_t slash = filename.rfind('/');
if (slash != filename.npos)
filename = filename.substr(slash+1);
uintN line = JS_PCToLineNumber(cx, script, pc);
std::stringstream ss;
ss << "(" << filename << ":" << line << ")";
name = ss.str();
}
static JSDObject*
_createJSDObject(JSDContext* jsdc, JSContext *cx, JSObject *obj)
{
JSDObject* jsdobj;
JSStackFrame* fp;
JSStackFrame* iter = NULL;
const char* newURL;
jsbytecode* pc;
JS_ASSERT(JSD_OBJECTS_LOCKED(jsdc));
jsdobj = (JSDObject*) calloc(1, sizeof(JSDObject));
if (jsdobj)
{
JS_INIT_CLIST(&jsdobj->links);
JS_APPEND_LINK(&jsdobj->links, &jsdc->objectsList);
jsdobj->obj = obj;
JS_HashTableAdd(jsdc->objectsTable, obj, jsdobj);
if (jsdc->flags & JSD_DISABLE_OBJECT_TRACE)
return jsdobj;
/* walk the stack to find js frame (if any) causing creation */
while (NULL != (fp = JS_FrameIterator(cx, &iter)))
{
if( !JS_IsNativeFrame(cx, fp) )
{
JSScript* script = JS_GetFrameScript(cx, fp);
if( !script )
continue;
newURL = JS_GetScriptFilename(cx, script);
if( newURL )
jsdobj->newURL = jsd_AddAtom(jsdc, newURL);
pc = JS_GetFramePC(cx, fp);
if( pc )
jsdobj->newLineno = JS_PCToLineNumber(cx, script, pc);
break;
}
}
}
return jsdobj;
}
JSTrapStatus CThreadDebugger::StepHandler(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* rval, void* UNUSED(closure))
{
// We break in two conditions
// 1. We are in the same frame but on a different line
// Note: On loops for example, we can go a few lines up again without leaving the current stack frame, so it's not necessarily
// a higher line number.
// 2. We are in a different Frame and m_pLastBreakFrame is not a parent of the current frame (because we stepped out of the function)
uint line = JS_PCToLineNumber(cx, script, pc);
JSStackFrame* iter = NULL;
JSStackFrame* pStackFrame;
pStackFrame = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
uint lastBreakLine = GetLastBreakLine() ;
jsval val = JSVAL_VOID;
if ((*m->m_pLastBreakFrame == pStackFrame && lastBreakLine != line) ||
(*m->m_pLastBreakFrame != pStackFrame && !CurrentFrameIsChildOf(*m->m_pLastBreakFrame)))
return BreakHandler(cx, script, pc, rval, val, BREAK_SRC_INTERRUP);
else
return JSTRAP_CONTINUE;
}
const char*
ThreadStackHelper::AppendJSEntry(const volatile StackEntry* aEntry,
intptr_t& aAvailableBufferSize,
const char* aPrevLabel)
{
// May be called from another thread or inside a signal handler.
// We assume querying the script is safe but we must not manupulate it.
// Also we must not allocate any memory from heap.
MOZ_ASSERT(aEntry->isJs());
MOZ_ASSERT(aEntry->script());
const char* label;
if (IsChromeJSScript(aEntry->script())) {
const char* filename = JS_GetScriptFilename(aEntry->script());
const unsigned lineno = JS_PCToLineNumber(aEntry->script(), aEntry->pc());
MOZ_ASSERT(filename);
char buffer[128]; // Enough to fit longest js file name from the tree
// Some script names are in the form "foo -> bar -> baz".
// Here we find the origin of these redirected scripts.
const char* basename = GetPathAfterComponent(filename, " -> ");
if (basename) {
filename = basename;
}
basename = GetFullPathForScheme(filename, "chrome://");
if (!basename) {
basename = GetFullPathForScheme(filename, "resource://");
}
if (!basename) {
// If the (add-on) script is located under the {profile}/extensions
// directory, extract the path after the /extensions/ part.
basename = GetPathAfterComponent(filename, "/extensions/");
}
if (!basename) {
// Only keep the file base name for paths outside the above formats.
basename = strrchr(filename, '/');
basename = basename ? basename + 1 : filename;
// Look for Windows path separator as well.
filename = strrchr(basename, '\\');
if (filename) {
basename = filename + 1;
}
}
size_t len = snprintf_literal(buffer, "%s:%u", basename, lineno);
if (len < sizeof(buffer)) {
if (mStackToFill->IsSameAsEntry(aPrevLabel, buffer)) {
return aPrevLabel;
}
// Keep track of the required buffer size
aAvailableBufferSize -= (len + 1);
if (aAvailableBufferSize >= 0) {
// Buffer is big enough.
return mStackToFill->InfallibleAppendViaBuffer(buffer, len);
}
// Buffer is not big enough; fall through to using static label below.
}
// snprintf failed or buffer is not big enough.
label = "(chrome script)";
} else {
label = "(content script)";
}
if (mStackToFill->IsSameAsEntry(aPrevLabel, label)) {
return aPrevLabel;
}
mStackToFill->infallibleAppend(label);
return label;
}
static char* FormatJSFrame(JSContext* cx, JSStackFrame* fp,
char* buf, int num,
JSBool showArgs, JSBool showLocals, JSBool showThisProps)
{
JSPropertyDescArray callProps = {0, nsnull};
JSPropertyDescArray thisProps = {0, nsnull};
JSBool gotThisVal = JS_FALSE;
jsval thisVal;
JSObject* callObj = nsnull;
JSString* funname = nsnull;
JSAutoByteString funbytes;
const char* filename = nsnull;
PRInt32 lineno = 0;
JSFunction* fun = nsnull;
uint32 namedArgCount = 0;
jsval val;
JSBool isString;
// get the info for this stack frame
JSScript* script = JS_GetFrameScript(cx, fp);
jsbytecode* pc = JS_GetFramePC(cx, fp);
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if(!ac.enter(cx, JS_GetFrameScopeChain(cx, fp)))
return buf;
if(script && pc)
{
filename = JS_GetScriptFilename(cx, script);
lineno = (PRInt32) JS_PCToLineNumber(cx, script, pc);
fun = JS_GetFrameFunction(cx, fp);
if(fun)
funname = JS_GetFunctionId(fun);
if(showArgs || showLocals)
{
callObj = JS_GetFrameCallObject(cx, fp);
if(callObj)
if(!JS_GetPropertyDescArray(cx, callObj, &callProps))
callProps.array = nsnull; // just to be sure
}
gotThisVal = JS_GetFrameThis(cx, fp, &thisVal);
if (!gotThisVal ||
!showThisProps ||
JSVAL_IS_PRIMITIVE(thisVal) ||
!JS_GetPropertyDescArray(cx, JSVAL_TO_OBJECT(thisVal),
&thisProps))
{
thisProps.array = nsnull; // just to be sure
}
}
// print the frame number and function name
if(funname)
buf = JS_sprintf_append(buf, "%d %s(", num, funbytes.encode(cx, funname));
else if(fun)
buf = JS_sprintf_append(buf, "%d anonymous(", num);
else
buf = JS_sprintf_append(buf, "%d <TOP LEVEL>", num);
if(!buf) goto out;
// print the function arguments
if(showArgs && callObj)
{
for(uint32 i = 0; i < callProps.length; i++)
{
JSPropertyDesc* desc = &callProps.array[i];
if(desc->flags & JSPD_ARGUMENT)
{
JSAutoByteString nameBytes;
const char* name = JSVAL2String(cx, desc->id, &isString, &nameBytes);
if(!isString)
name = nsnull;
JSAutoByteString valueBytes;
const char* value = JSVAL2String(cx, desc->value, &isString, &valueBytes);
buf = JS_sprintf_append(buf, "%s%s%s%s%s%s",
namedArgCount ? ", " : "",
name ? name :"",
name ? " = " : "",
isString ? "\"" : "",
value ? value : "?unknown?",
isString ? "\"" : "");
if(!buf) goto out;
namedArgCount++;
}
}
// print any unnamed trailing args (found in 'arguments' object)
if(JS_GetProperty(cx, callObj, "arguments", &val) &&
JSVAL_IS_OBJECT(val))
{
uint32 argCount;
JSObject* argsObj = JSVAL_TO_OBJECT(val);
if(JS_GetProperty(cx, argsObj, "length", &val) &&
JS_ValueToECMAUint32(cx, val, &argCount) &&
argCount > namedArgCount)
{
for(uint32 k = namedArgCount; k < argCount; k++)
{
char number[8];
JS_snprintf(number, 8, "%d", (int) k);
if(JS_GetProperty(cx, argsObj, number, &val))
{
JSAutoByteString valueBytes;
const char *value = JSVAL2String(cx, val, &isString, &valueBytes);
buf = JS_sprintf_append(buf, "%s%s%s%s",
k ? ", " : "",
isString ? "\"" : "",
value ? value : "?unknown?",
isString ? "\"" : "");
if(!buf) goto out;
}
}
}
}
}
// print filename and line number
buf = JS_sprintf_append(buf, "%s [\"%s\":%d]\n",
fun ? ")" : "",
filename ? filename : "<unknown>",
lineno);
if(!buf) goto out;
// print local variables
if(showLocals && callProps.array)
{
for(uint32 i = 0; i < callProps.length; i++)
{
JSPropertyDesc* desc = &callProps.array[i];
if(desc->flags & JSPD_VARIABLE)
{
JSAutoByteString nameBytes;
JSAutoByteString valueBytes;
const char *name = JSVAL2String(cx, desc->id, nsnull, &nameBytes);
const char *value = JSVAL2String(cx, desc->value, &isString, &valueBytes);
if(name && value)
{
buf = JS_sprintf_append(buf, TAB "%s = %s%s%s\n",
name,
isString ? "\"" : "",
value,
isString ? "\"" : "");
if(!buf) goto out;
}
}
}
}
// print the value of 'this'
if(showLocals)
{
if(gotThisVal)
{
JSString* thisValStr;
JSAutoByteString thisValBytes;
if(nsnull != (thisValStr = JS_ValueToString(cx, thisVal)) &&
thisValBytes.encode(cx, thisValStr))
{
buf = JS_sprintf_append(buf, TAB "this = %s\n", thisValBytes.ptr());
if(!buf) goto out;
}
}
else
buf = JS_sprintf_append(buf, TAB "<failed to get 'this' value>\n");
}
// print the properties of 'this', if it is an object
if(showThisProps && thisProps.array)
{
for(uint32 i = 0; i < thisProps.length; i++)
{
JSPropertyDesc* desc = &thisProps.array[i];
if(desc->flags & JSPD_ENUMERATE)
{
JSAutoByteString nameBytes;
JSAutoByteString valueBytes;
const char *name = JSVAL2String(cx, desc->id, nsnull, &nameBytes);
const char *value = JSVAL2String(cx, desc->value, &isString, &valueBytes);
if(name && value)
{
buf = JS_sprintf_append(buf, TAB "this.%s = %s%s%s\n",
name,
isString ? "\"" : "",
value,
isString ? "\"" : "");
if(!buf) goto out;
}
}
}
}
out:
if(callProps.array)
JS_PutPropertyDescArray(cx, &callProps);
if(thisProps.array)
JS_PutPropertyDescArray(cx, &thisProps);
return buf;
}
static void
format_frame(JSContext* cx, JSStackFrame* fp,
GString *buf, int num)
{
JSPropertyDescArray call_props = { 0, NULL };
JSObject* call_obj = NULL;
char* funname_str = NULL;
const char* filename = NULL;
guint32 lineno = 0;
guint32 named_arg_count = 0;
JSFunction* fun = NULL;
JSScript* script;
guchar* pc;
guint32 i;
gboolean is_string;
jsval val;
(void)JS_EnterLocalRootScope(cx);
if (!JS_IsScriptFrame(cx, fp)) {
g_string_append_printf(buf, "%d [native frame]\n", num);
goto out;
}
/* get the info for this stack frame */
script = JS_GetFrameScript(cx, fp);
pc = JS_GetFramePC(cx, fp);
if (script && pc) {
filename = JS_GetScriptFilename(cx, script);
lineno = (guint32) JS_PCToLineNumber(cx, script, pc);
fun = JS_GetFrameFunction(cx, fp);
if (fun) {
JSString* funname = JS_GetFunctionId(fun);
if (funname)
funname_str = gjs_string_get_ascii(cx, STRING_TO_JSVAL(funname));
}
call_obj = JS_GetFrameCallObject(cx, fp);
if (call_obj) {
if (!JS_GetPropertyDescArray(cx, call_obj, &call_props))
call_props.array = NULL;
}
}
/* print the frame number and function name */
if (funname_str) {
g_string_append_printf(buf, "%d %s(", num, funname_str);
g_free(funname_str);
}
else if (fun)
g_string_append_printf(buf, "%d anonymous(", num);
else
g_string_append_printf(buf, "%d <TOP LEVEL>", num);
for (i = 0; i < call_props.length; i++) {
char *name = NULL;
char *value = NULL;
JSPropertyDesc* desc = &call_props.array[i];
if(desc->flags & JSPD_ARGUMENT) {
name = jsvalue_to_string(cx, desc->id, &is_string);
if(!is_string) {
g_free(name);
name = NULL;
}
value = jsvalue_to_string(cx, desc->value, &is_string);
g_string_append_printf(buf, "%s%s%s%s%s%s",
named_arg_count ? ", " : "",
name ? name :"",
name ? " = " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
named_arg_count++;
}
g_free(name);
g_free(value);
}
/* print any unnamed trailing args (found in 'arguments' object) */
if (call_obj != NULL &&
JS_GetProperty(cx, call_obj, "arguments", &val) &&
JSVAL_IS_OBJECT(val)) {
guint32 k;
guint32 arg_count;
JSObject* args_obj = JSVAL_TO_OBJECT(val);
if (JS_GetArrayLength(cx, args_obj, &arg_count) &&
arg_count > named_arg_count) {
for (k = named_arg_count; k < arg_count; k++) {
if (JS_GetElement(cx, args_obj, k, &val)) {
char *value = jsvalue_to_string(cx, val, &is_string);
g_string_append_printf(buf, "%s%s%s%s",
k ? ", " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
g_free(value);
}
}
}
}
/* print filename and line number */
g_string_append_printf(buf, "%s@%s:%d\n",
fun ? ")" : "",
filename ? filename : "",
lineno);
out:
if (call_props.array)
JS_PutPropertyDescArray(cx, &call_props);
JS_LeaveLocalRootScope(cx);
}
void ProfileBuffer::StreamSamplesToJSObject(JSStreamWriter& b, int aThreadId, JSRuntime* rt)
{
b.BeginArray();
bool sample = false;
int readPos = mReadPos;
int currentThreadID = -1;
while (readPos != mWritePos) {
ProfileEntry entry = mEntries[readPos];
if (entry.mTagName == 'T') {
currentThreadID = entry.mTagInt;
}
if (currentThreadID == aThreadId) {
switch (entry.mTagName) {
case 'r':
{
if (sample) {
b.NameValue("responsiveness", entry.mTagFloat);
}
}
break;
case 'p':
{
if (sample) {
b.NameValue("power", entry.mTagFloat);
}
}
break;
case 'R':
{
if (sample) {
b.NameValue("rss", entry.mTagFloat);
}
}
break;
case 'U':
{
if (sample) {
b.NameValue("uss", entry.mTagFloat);
}
}
break;
case 'f':
{
if (sample) {
b.NameValue("frameNumber", entry.mTagInt);
}
}
break;
case 't':
{
if (sample) {
b.NameValue("time", entry.mTagFloat);
}
}
break;
case 's':
{
// end the previous sample if there was one
if (sample) {
b.EndObject();
}
// begin the next sample
b.BeginObject();
sample = true;
// Seek forward through the entire sample, looking for frames
// this is an easier approach to reason about than adding more
// control variables and cases to the loop that goes through the buffer once
b.Name("frames");
b.BeginArray();
b.BeginObject();
b.NameValue("location", "(root)");
b.EndObject();
int framePos = (readPos + 1) % mEntrySize;
ProfileEntry frame = mEntries[framePos];
while (framePos != mWritePos && frame.mTagName != 's' && frame.mTagName != 'T') {
int incBy = 1;
frame = mEntries[framePos];
// Read ahead to the next tag, if it's a 'd' tag process it now
const char* tagStringData = frame.mTagData;
int readAheadPos = (framePos + 1) % mEntrySize;
char tagBuff[DYNAMIC_MAX_STRING];
// Make sure the string is always null terminated if it fills up
// DYNAMIC_MAX_STRING-2
tagBuff[DYNAMIC_MAX_STRING-1] = '\0';
if (readAheadPos != mWritePos && mEntries[readAheadPos].mTagName == 'd') {
tagStringData = processDynamicTag(framePos, &incBy, tagBuff);
}
// Write one frame. It can have either
// 1. only location - 'l' containing a memory address
// 2. location and line number - 'c' followed by 'd's,
// an optional 'n' and an optional 'y'
if (frame.mTagName == 'l') {
b.BeginObject();
// Bug 753041
// We need a double cast here to tell GCC that we don't want to sign
// extend 32-bit addresses starting with 0xFXXXXXX.
unsigned long long pc = (unsigned long long)(uintptr_t)frame.mTagPtr;
snprintf(tagBuff, DYNAMIC_MAX_STRING, "%#llx", pc);
b.NameValue("location", tagBuff);
b.EndObject();
} else if (frame.mTagName == 'c') {
b.BeginObject();
b.NameValue("location", tagStringData);
readAheadPos = (framePos + incBy) % mEntrySize;
if (readAheadPos != mWritePos &&
mEntries[readAheadPos].mTagName == 'n') {
b.NameValue("line", mEntries[readAheadPos].mTagInt);
incBy++;
}
readAheadPos = (framePos + incBy) % mEntrySize;
if (readAheadPos != mWritePos &&
mEntries[readAheadPos].mTagName == 'y') {
b.NameValue("category", mEntries[readAheadPos].mTagInt);
incBy++;
}
readAheadPos = (framePos + incBy) % mEntrySize;
if (readAheadPos != mWritePos &&
mEntries[readAheadPos].mTagName == 'J') {
void* pc = mEntries[readAheadPos].mTagPtr;
// TODOshu: cannot stream tracked optimization info if
// the JS engine has already shut down when streaming.
if (rt) {
JSScript *optsScript;
jsbytecode *optsPC;
b.Name("opts");
b.BeginArray();
StreamOptimizationTypeInfoOp typeInfoOp(b);
JS::ForEachTrackedOptimizationTypeInfo(rt, pc, typeInfoOp);
StreamOptimizationAttemptsOp attemptOp(b);
JS::ForEachTrackedOptimizationAttempt(rt, pc, attemptOp,
&optsScript, &optsPC);
b.EndArray();
b.NameValue("optsLine", JS_PCToLineNumber(optsScript, optsPC));
}
}
b.EndObject();
}
framePos = (framePos + incBy) % mEntrySize;
}
b.EndArray();
}
break;
}
}
readPos = (readPos + 1) % mEntrySize;
}
if (sample) {
b.EndObject();
}
b.EndArray();
}
JSTrapStatus CThreadDebugger::BreakHandler(JSContext* cx, JSScript* script, jsbytecode* pc, jsval* UNUSED(rval), jsval UNUSED(closure), BREAK_SRC breakSrc)
{
uint line = JS_PCToLineNumber(cx, script, pc);
std::string filename(JS_GetScriptFilename(cx, script));
SetIsInBreak(true);
SaveCallstack();
SetLastBreakLine(line);
SetBreakFileName(filename);
*m->m_pLastBreakFrame = NULL;
if (breakSrc == BREAK_SRC_INTERRUP)
{
JS_ClearInterrupt(m->m_pScriptInterface->GetRuntime(), NULL, NULL);
JS_SetSingleStepMode(cx, script, false);
}
if (m->m_pDebuggingServer->GetSettingSimultaneousThreadBreak())
{
m->m_pDebuggingServer->SetBreakRequestedByThread(true);
}
// Wait until the user continues the execution
while (1)
{
DBGCMD nextDbgCmd = GetNextDbgCmd();
while (!m->m_StackInfoRequests.empty())
{
StackInfoRequest request = m->m_StackInfoRequests.front();
SaveStackFrameData(request.requestType, request.nestingLevel);
SDL_SemPost(request.semaphore);
m->m_StackInfoRequests.pop();
}
if (nextDbgCmd == DBG_CMD_NONE)
{
// Wait a while before checking for new m_NextDbgCmd again.
// We don't want this loop to take 100% of a CPU core for each thread that is in break mode.
// On the other hande we don't want the debugger to become unresponsive.
SDL_Delay(100);
}
else if (nextDbgCmd == DBG_CMD_SINGLESTEP || nextDbgCmd == DBG_CMD_STEPINTO || nextDbgCmd == DBG_CMD_STEPOUT)
{
JSStackFrame* iter = NULL;
*m->m_pLastBreakFrame = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
if (!JS_SetSingleStepMode(cx, script, true))
LOGERROR(L"JS_SetSingleStepMode returned false!"); // TODO: When can this happen?
else
{
if (nextDbgCmd == DBG_CMD_SINGLESTEP)
{
JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), StepHandler_, this);
break;
}
else if (nextDbgCmd == DBG_CMD_STEPINTO)
{
JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), StepIntoHandler_, this);
break;
}
else if (nextDbgCmd == DBG_CMD_STEPOUT)
{
JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), StepOutHandler_, this);
break;
}
}
}
else if (nextDbgCmd == DBG_CMD_CONTINUE)
{
if (!JS_SetSingleStepMode(cx, script, true))
LOGERROR(L"JS_SetSingleStepMode returned false!"); // TODO: When can this happen?
else
{
// Setup a handler to check for break-requests from the DebuggingServer regularly
JS_SetInterrupt(m->m_pScriptInterface->GetRuntime(), CheckForBreakRequestHandler_, this);
}
break;
}
else
debug_warn("Invalid DBGCMD found in CThreadDebugger::BreakHandler!");
}
ClearTrapsToRemove();
SetAllNewTraps();
SetNextDbgCmd(DBG_CMD_NONE);
SetIsInBreak(false);
SetBreakFileName("");
// All saved stack data becomes invalid
{
CScopeLock lock(m->m_Mutex);
m->m_StackFrameData.clear();
}
return JSTRAP_CONTINUE;
}
void
ThreadStackHelper::CollectPseudoEntry(const js::ProfileEntry& aEntry)
{
// For non-js frames we just include the raw label.
if (!aEntry.isJs()) {
const char* entryLabel = aEntry.label();
// entryLabel is a statically allocated string, so we want to store a
// reference to it without performing any allocations. This is important, as
// we aren't allowed to allocate within this function.
//
// The variant for this kind of label in our HangStack object is a
// `nsCString`, which normally contains heap allocated string data. However,
// `nsCString` has an optimization for literal strings which causes the
// backing data to not be copied when being copied between nsCString
// objects.
//
// We take advantage of that optimization by creating a nsCString object
// which has the LITERAL flag set. Without this optimization, this code
// would be incorrect.
nsCString label;
label.AssignLiteral(entryLabel, strlen(entryLabel));
// Let's make sure we don't deadlock here, by asserting that `label`'s
// backing data matches.
MOZ_RELEASE_ASSERT(label.BeginReading() == entryLabel,
"String copy performed during ThreadStackHelper::CollectPseudoEntry");
TryAppendFrame(label);
return;
}
if (!aEntry.script()) {
TryAppendFrame(HangEntrySuppressed());
return;
}
if (!IsChromeJSScript(aEntry.script())) {
TryAppendFrame(HangEntryContent());
return;
}
// Rather than using the profiler's dynamic string, we compute our own string.
// This is because we want to do some size-saving strategies, and throw out
// information which won't help us as much.
// XXX: We currently don't collect the function name which hung.
const char* filename = JS_GetScriptFilename(aEntry.script());
unsigned lineno = JS_PCToLineNumber(aEntry.script(), aEntry.pc());
// Some script names are in the form "foo -> bar -> baz".
// Here we find the origin of these redirected scripts.
const char* basename = GetPathAfterComponent(filename, " -> ");
if (basename) {
filename = basename;
}
// Strip chrome:// or resource:// off of the filename if present.
basename = GetFullPathForScheme(filename, "chrome://");
if (!basename) {
basename = GetFullPathForScheme(filename, "resource://");
}
if (!basename) {
// If we're in an add-on script, under the {profile}/extensions
// directory, extract the path after the /extensions/ part.
basename = GetPathAfterComponent(filename, "/extensions/");
}
if (!basename) {
// Only keep the file base name for paths outside the above formats.
basename = strrchr(filename, '/');
basename = basename ? basename + 1 : filename;
// Look for Windows path separator as well.
filename = strrchr(basename, '\\');
if (filename) {
basename = filename + 1;
}
}
char buffer[128]; // Enough to fit longest js file name from the tree
size_t len = SprintfLiteral(buffer, "%s:%u", basename, lineno);
if (len < sizeof(buffer)) {
mDesiredBufferSize += len + 1;
if (mStackToFill->stack().Capacity() > mStackToFill->stack().Length() &&
(mStackToFill->strbuffer().Capacity() -
mStackToFill->strbuffer().Length()) > len + 1) {
// NOTE: We only increment this if we're going to successfully append.
mDesiredStackSize += 1;
uint32_t start = mStackToFill->strbuffer().Length();
mStackToFill->strbuffer().AppendElements(buffer, len);
mStackToFill->strbuffer().AppendElement('\0');
mStackToFill->stack().AppendElement(HangEntryBufOffset(start));
return;
}
}
TryAppendFrame(HangEntryChromeScript());
}
