• file
• revisions
• annotate
• diff
• comparison
• raw

js/jsd/jsd_step.cpp@129ffea94266 (annotated)

js/jsd/jsd_step.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author

Michael Schloh von Bennewitz <michael@schloh.com>

date

Sat, 03 Jan 2015 20:18:00 +0100

branch

TOR_BUG_3246

changeset 7

129ffea94266

permissions

-rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

michael@0	1	/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
michael@0	2	* vim: set ts=8 sts=4 et sw=4 tw=99:
michael@0	3	* This Source Code Form is subject to the terms of the Mozilla Public
michael@0	4	* License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0	5	* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0	6
michael@0	7	/*
michael@0	8	* JavaScript Debugging support - Stepping support
michael@0	9	*/
michael@0	10
michael@0	11	#include "jsd.h"
michael@0	12
michael@0	13	/*
michael@0	14	* #define JSD_TRACE 1
michael@0	15	*/
michael@0	16
michael@0	17	#ifdef JSD_TRACE
michael@0	18
michael@0	19	static char*
michael@0	20	_indentSpaces(int i)
michael@0	21	{
michael@0	22	#define MAX_INDENT 63
michael@0	23	static char* p = nullptr;
michael@0	24	if(!p)
michael@0	25	{
michael@0	26	p = calloc(1, MAX_INDENT+1);
michael@0	27	if(!p) return "";
michael@0	28	memset(p, ' ', MAX_INDENT);
michael@0	29	}
michael@0	30	if(i > MAX_INDENT) return p;
michael@0	31	return p + MAX_INDENT-i;
michael@0	32	}
michael@0	33
michael@0	34	static void
michael@0	35	_interpreterTrace(JSDContext* jsdc, JSContext *cx, JSAbstractFramePtr frame,
michael@0	36	bool isConstructing, bool before)
michael@0	37	{
michael@0	38	JSDScript* jsdscript = nullptr;
michael@0	39	JSScript * script;
michael@0	40	static indent = 0;
michael@0	41	JSString* funName = nullptr;
michael@0	42
michael@0	43	script = frame.script();
michael@0	44	if(script)
michael@0	45	{
michael@0	46	JSD_LOCK_SCRIPTS(jsdc);
michael@0	47	jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, script, frame);
michael@0	48	JSD_UNLOCK_SCRIPTS(jsdc);
michael@0	49	if(jsdscript)
michael@0	50	funName = JSD_GetScriptFunctionId(jsdc, jsdscript);
michael@0	51	}
michael@0	52
michael@0	53	if(before)
michael@0	54	printf("%sentering ", _indentSpaces(indent++));
michael@0	55	else
michael@0	56	printf("%sleaving ", _indentSpaces(--indent));
michael@0	57
michael@0	58	if (!funName)
michael@0	59	printf("TOP_LEVEL");
michael@0	60	else
michael@0	61	JS_FileEscapedString(stdout, funName, 0);
michael@0	62
michael@0	63	if(before)
michael@0	64	{
michael@0	65	jsval thisVal;
michael@0	66
michael@0	67	printf("%s this: ", isConstructing ? "constructing":"");
michael@0	68
michael@0	69	if (JS_GetFrameThis(cx, frame, &thisVal))
michael@0	70	printf("0x%0llx", (uintptr_t) thisVal);
michael@0	71	else
michael@0	72	puts("<unavailable>");
michael@0	73	}
michael@0	74	printf("\n");
michael@0	75	MOZ_ASSERT(indent >= 0);
michael@0	76	}
michael@0	77	#endif
michael@0	78
michael@0	79	bool
michael@0	80	_callHook(JSDContext *jsdc, JSContext *cx, JSAbstractFramePtr frame, bool isConstructing,
michael@0	81	bool before, unsigned type, JSD_CallHookProc hook, void *hookData)
michael@0	82	{
michael@0	83	JSDScript* jsdscript;
michael@0	84	JSScript* jsscript;
michael@0	85	bool hookresult = true;
michael@0	86
michael@0	87	if (!jsdc || !jsdc->inited)
michael@0	88	return false;
michael@0	89
michael@0	90	if (!hook && !(jsdc->flags & JSD_COLLECT_PROFILE_DATA))
michael@0	91	{
michael@0	92	/* no hook to call, no profile data needs to be collected,
michael@0	93	* so there is nothing to do here.
michael@0	94	*/
michael@0	95	return hookresult;
michael@0	96	}
michael@0	97
michael@0	98	if (before && isConstructing) {
michael@0	99	JS::RootedValue newObj(cx);
michael@0	100	if (!frame.getThisValue(cx, &newObj))
michael@0	101	return false;
michael@0	102	jsd_Constructing(jsdc, cx, JSVAL_TO_OBJECT(newObj), frame);
michael@0	103	}
michael@0	104
michael@0	105	jsscript = frame.script();
michael@0	106	if (jsscript)
michael@0	107	{
michael@0	108	JSD_LOCK_SCRIPTS(jsdc);
michael@0	109	jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, jsscript, frame);
michael@0	110	JSD_UNLOCK_SCRIPTS(jsdc);
michael@0	111
michael@0	112	if (jsdscript)
michael@0	113	{
michael@0	114	if (JSD_IS_PROFILE_ENABLED(jsdc, jsdscript))
michael@0	115	{
michael@0	116	JSDProfileData *pdata;
michael@0	117	pdata = jsd_GetScriptProfileData (jsdc, jsdscript);
michael@0	118	if (pdata)
michael@0	119	{
michael@0	120	if (before)
michael@0	121	{
michael@0	122	if (!pdata->lastCallStart)
michael@0	123	{
michael@0	124	int64_t now;
michael@0	125	JSDProfileData *callerpdata;
michael@0	126
michael@0	127	/* Get the time just the once, for consistency. */
michael@0	128	now = JS_Now();
michael@0	129	/* This contains a pointer to the profile data for
michael@0	130	* the caller of this function. */
michael@0	131	callerpdata = jsdc->callingFunctionPData;
michael@0	132	if (callerpdata)
michael@0	133	{
michael@0	134	int64_t ll_delta;
michael@0	135	pdata->caller = callerpdata;
michael@0	136	/* We need to 'stop' the timer for the caller.
michael@0	137	* Use time since last return if appropriate. */
michael@0	138	ll_delta = jsdc->lastReturnTime
michael@0	139	? now - jsdc->lastReturnTime
michael@0	140	: now - callerpdata->lastCallStart;
michael@0	141	callerpdata->runningTime += ll_delta;
michael@0	142	}
michael@0	143	/* We're the new current function, and no return
michael@0	144	* has happened yet. */
michael@0	145	jsdc->callingFunctionPData = pdata;
michael@0	146	jsdc->lastReturnTime = 0;
michael@0	147	/* This function has no running time (just been
michael@0	148	* called!), and we'll need the call start time. */
michael@0	149	pdata->runningTime = 0;
michael@0	150	pdata->lastCallStart = now;
michael@0	151	} else {
michael@0	152	if (++pdata->recurseDepth > pdata->maxRecurseDepth)
michael@0	153	pdata->maxRecurseDepth = pdata->recurseDepth;
michael@0	154	}
michael@0	155	/* make sure we're called for the return too. */
michael@0	156	hookresult = true;
michael@0	157	} else if (!pdata->recurseDepth && pdata->lastCallStart) {
michael@0	158	int64_t now, ll_delta;
michael@0	159	double delta;
michael@0	160	now = JS_Now();
michael@0	161	ll_delta = now - pdata->lastCallStart;
michael@0	162	delta = ll_delta;
michael@0	163	delta /= 1000.0;
michael@0	164	pdata->totalExecutionTime += delta;
michael@0	165	/* minExecutionTime starts as 0, so we need to overwrite
michael@0	166	* it on the first call always. */
michael@0	167	if ((0 == pdata->callCount) ||
michael@0	168	delta < pdata->minExecutionTime)
michael@0	169	{
michael@0	170	pdata->minExecutionTime = delta;
michael@0	171	}
michael@0	172	if (delta > pdata->maxExecutionTime)
michael@0	173	pdata->maxExecutionTime = delta;
michael@0	174
michael@0	175	/* If we last returned from a function (as opposed to
michael@0	176	* having last entered this function), we need to inc.
michael@0	177	* the running total by the time delta since the last
michael@0	178	* return, and use the running total instead of the
michael@0	179	* delta calculated above. */
michael@0	180	if (jsdc->lastReturnTime)
michael@0	181	{
michael@0	182	/* Add last chunk to running time, and use total
michael@0	183	* running time as 'delta'. */
michael@0	184	ll_delta = now - jsdc->lastReturnTime;
michael@0	185	pdata->runningTime += ll_delta;
michael@0	186	delta = pdata->runningTime;
michael@0	187	delta /= 1000.0;
michael@0	188	}
michael@0	189
michael@0	190	pdata->totalOwnExecutionTime += delta;
michael@0	191	/* See minExecutionTime comment above. */
michael@0	192	if ((0 == pdata->callCount) ||
michael@0	193	delta < pdata->minOwnExecutionTime)
michael@0	194	{
michael@0	195	pdata->minOwnExecutionTime = delta;
michael@0	196	}
michael@0	197	if (delta > pdata->maxOwnExecutionTime)
michael@0	198	pdata->maxOwnExecutionTime = delta;
michael@0	199
michael@0	200	/* Current function is now our caller. */
michael@0	201	jsdc->callingFunctionPData = pdata->caller;
michael@0	202	/* No hanging pointers, please. */
michael@0	203	pdata->caller = nullptr;
michael@0	204	/* Mark the time we returned, and indicate this
michael@0	205	* function is no longer running. */
michael@0	206	jsdc->lastReturnTime = now;
michael@0	207	pdata->lastCallStart = 0;
michael@0	208	++pdata->callCount;
michael@0	209	} else if (pdata->recurseDepth) {
michael@0	210	--pdata->recurseDepth;
michael@0	211	++pdata->callCount;
michael@0	212	}
michael@0	213	}
michael@0	214	if (hook)
michael@0	215	jsd_CallCallHook (jsdc, cx, type, hook, hookData);
michael@0	216	} else {
michael@0	217	if (hook)
michael@0	218	hookresult =
michael@0	219	jsd_CallCallHook (jsdc, cx, type, hook, hookData);
michael@0	220	else
michael@0	221	hookresult = true;
michael@0	222	}
michael@0	223	}
michael@0	224	}
michael@0	225
michael@0	226	#ifdef JSD_TRACE
michael@0	227	_interpreterTrace(jsdc, cx, frame, isConstructing, before);
michael@0	228	return true;
michael@0	229	#else
michael@0	230	return hookresult;
michael@0	231	#endif
michael@0	232
michael@0	233	}
michael@0	234
michael@0	235	void *
michael@0	236	jsd_FunctionCallHook(JSContext *cx, JSAbstractFramePtr frame, bool isConstructing,
michael@0	237	bool before, bool *ok, void *closure)
michael@0	238	{
michael@0	239	JSDContext* jsdc;
michael@0	240	JSD_CallHookProc hook;
michael@0	241	void* hookData;
michael@0	242
michael@0	243	jsdc = (JSDContext*) closure;
michael@0	244
michael@0	245	/* local in case jsdc->functionHook gets cleared on another thread */
michael@0	246	JSD_LOCK();
michael@0	247	hook = jsdc->functionHook;
michael@0	248	hookData = jsdc->functionHookData;
michael@0	249	JSD_UNLOCK();
michael@0	250
michael@0	251	if (_callHook (jsdc, cx, frame, isConstructing, before,
michael@0	252	(before) ? JSD_HOOK_FUNCTION_CALL : JSD_HOOK_FUNCTION_RETURN,
michael@0	253	hook, hookData))
michael@0	254	{
michael@0	255	return closure;
michael@0	256	}
michael@0	257
michael@0	258	return nullptr;
michael@0	259	}
michael@0	260
michael@0	261	void *
michael@0	262	jsd_TopLevelCallHook(JSContext *cx, JSAbstractFramePtr frame, bool isConstructing,
michael@0	263	bool before, bool *ok, void *closure)
michael@0	264	{
michael@0	265	JSDContext* jsdc;
michael@0	266	JSD_CallHookProc hook;
michael@0	267	void* hookData;
michael@0	268
michael@0	269	jsdc = (JSDContext*) closure;
michael@0	270
michael@0	271	/* local in case jsdc->toplevelHook gets cleared on another thread */
michael@0	272	JSD_LOCK();
michael@0	273	hook = jsdc->toplevelHook;
michael@0	274	hookData = jsdc->toplevelHookData;
michael@0	275	JSD_UNLOCK();
michael@0	276
michael@0	277	if (_callHook (jsdc, cx, frame, isConstructing, before,
michael@0	278	(before) ? JSD_HOOK_TOPLEVEL_START : JSD_HOOK_TOPLEVEL_END,
michael@0	279	hook, hookData))
michael@0	280	{
michael@0	281	return closure;
michael@0	282	}
michael@0	283
michael@0	284	return nullptr;
michael@0	285
michael@0	286	}