2009-06-10 18:29:44 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
2007-03-22 10:30:00 -07:00
|
|
|
* vim: set ts=8 sw=4 et tw=78:
|
|
|
|
*
|
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code, released
|
|
|
|
* March 31, 1998.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JS script operations.
|
|
|
|
*/
|
|
|
|
#include <string.h>
|
|
|
|
#include "jstypes.h"
|
2009-03-18 11:38:16 -07:00
|
|
|
#include "jsstdint.h"
|
2010-10-01 16:46:54 -07:00
|
|
|
#include "jsutil.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jsprf.h"
|
|
|
|
#include "jsapi.h"
|
|
|
|
#include "jsatom.h"
|
|
|
|
#include "jscntxt.h"
|
2008-09-05 10:19:17 -07:00
|
|
|
#include "jsversion.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jsdbgapi.h"
|
|
|
|
#include "jsemit.h"
|
|
|
|
#include "jsfun.h"
|
|
|
|
#include "jsinterp.h"
|
|
|
|
#include "jslock.h"
|
|
|
|
#include "jsnum.h"
|
|
|
|
#include "jsopcode.h"
|
2007-10-02 16:10:09 -07:00
|
|
|
#include "jsparse.h"
|
2008-09-08 02:47:12 -07:00
|
|
|
#include "jsscope.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jsscript.h"
|
2009-02-09 16:58:39 -08:00
|
|
|
#include "jstracer.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#if JS_HAS_XDR
|
|
|
|
#include "jsxdrapi.h"
|
|
|
|
#endif
|
2010-05-22 17:45:52 -07:00
|
|
|
#include "methodjit/MethodJIT.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-08-09 22:43:33 -07:00
|
|
|
#include "jsinterpinlines.h"
|
2010-05-18 19:21:43 -07:00
|
|
|
#include "jsobjinlines.h"
|
2009-09-10 09:50:43 -07:00
|
|
|
#include "jsscriptinlines.h"
|
|
|
|
|
2010-01-22 14:49:18 -08:00
|
|
|
using namespace js;
|
2010-09-24 10:54:39 -07:00
|
|
|
using namespace js::gc;
|
2010-01-22 14:49:18 -08:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
#if JS_HAS_XDR
|
|
|
|
|
2010-09-13 22:33:44 -07:00
|
|
|
enum ScriptBits {
|
|
|
|
NoScriptRval,
|
|
|
|
SavedCallerFun,
|
|
|
|
HasSharps,
|
|
|
|
StrictModeCode,
|
|
|
|
UsesEval,
|
|
|
|
CompileAndGo,
|
|
|
|
UsesArguments
|
|
|
|
};
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JSBool
|
2010-11-16 15:30:56 -08:00
|
|
|
js_XDRScript(JSXDRState *xdr, JSScript **scriptp, JSBool *hasMagic)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
JSContext *cx;
|
2007-07-08 02:03:34 -07:00
|
|
|
JSScript *script, *oldscript;
|
2008-03-22 18:11:51 -07:00
|
|
|
JSBool ok;
|
|
|
|
jsbytecode *code;
|
2008-07-20 13:13:17 -07:00
|
|
|
uint32 length, lineno, nslots, magic;
|
2010-07-14 23:19:36 -07:00
|
|
|
uint32 natoms, nsrcnotes, ntrynotes, nobjects, nupvars, nregexps, nconsts, i;
|
2010-09-13 22:33:44 -07:00
|
|
|
uint32 prologLength, version, encodedClosedCount;
|
2010-10-04 14:13:33 -07:00
|
|
|
uint16 nClosedArgs = 0, nClosedVars = 0;
|
2007-07-08 02:03:34 -07:00
|
|
|
JSPrincipals *principals;
|
|
|
|
uint32 encodeable;
|
2007-03-22 10:30:00 -07:00
|
|
|
JSBool filenameWasSaved;
|
|
|
|
jssrcnote *notes, *sn;
|
2008-09-05 16:24:53 -07:00
|
|
|
JSSecurityCallbacks *callbacks;
|
2010-09-13 22:33:44 -07:00
|
|
|
uint32 scriptBits = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
cx = xdr->cx;
|
|
|
|
script = *scriptp;
|
2010-07-14 23:19:36 -07:00
|
|
|
nsrcnotes = ntrynotes = natoms = nobjects = nupvars = nregexps = nconsts = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
filenameWasSaved = JS_FALSE;
|
|
|
|
notes = NULL;
|
|
|
|
|
2010-05-22 15:38:04 -07:00
|
|
|
/* Should not XDR scripts optimized for a single global object. */
|
|
|
|
JS_ASSERT_IF(script, !script->globalsOffset);
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
if (xdr->mode == JSXDR_ENCODE)
|
|
|
|
magic = JSXDR_MAGIC_SCRIPT_CURRENT;
|
|
|
|
if (!JS_XDRUint32(xdr, &magic))
|
|
|
|
return JS_FALSE;
|
2007-07-08 02:03:34 -07:00
|
|
|
if (magic != JSXDR_MAGIC_SCRIPT_CURRENT) {
|
|
|
|
/* We do not provide binary compatibility with older scripts. */
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!hasMagic) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
|
|
|
JSMSG_BAD_SCRIPT_MAGIC);
|
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
*hasMagic = JS_FALSE;
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
if (hasMagic)
|
|
|
|
*hasMagic = JS_TRUE;
|
|
|
|
|
2009-10-18 17:41:24 -07:00
|
|
|
if (xdr->mode == JSXDR_ENCODE)
|
2010-11-16 15:30:56 -08:00
|
|
|
length = script->length;
|
2009-10-18 17:41:24 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &length))
|
|
|
|
return JS_FALSE;
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
if (xdr->mode == JSXDR_ENCODE) {
|
2009-02-18 09:14:51 -08:00
|
|
|
prologLength = script->main - script->code;
|
2010-09-13 09:38:22 -07:00
|
|
|
JS_ASSERT(script->getVersion() != JSVERSION_UNKNOWN);
|
|
|
|
version = (uint32)script->getVersion() | (script->nfixed << 16);
|
2007-03-22 10:30:00 -07:00
|
|
|
lineno = (uint32)script->lineno;
|
2008-07-20 13:13:17 -07:00
|
|
|
nslots = (uint32)script->nslots;
|
2009-04-05 21:17:22 -07:00
|
|
|
nslots = (uint32)((script->staticLevel << 16) | script->nslots);
|
2007-07-08 02:03:34 -07:00
|
|
|
natoms = (uint32)script->atomMap.length;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/* Count the srcnotes, keeping notes pointing at the first one. */
|
2009-09-09 16:52:55 -07:00
|
|
|
notes = script->notes();
|
2007-03-22 10:30:00 -07:00
|
|
|
for (sn = notes; !SN_IS_TERMINATOR(sn); sn = SN_NEXT(sn))
|
|
|
|
continue;
|
2009-02-18 09:14:51 -08:00
|
|
|
nsrcnotes = sn - notes;
|
2007-03-22 10:30:00 -07:00
|
|
|
nsrcnotes++; /* room for the terminator */
|
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (script->objectsOffset != 0)
|
2009-09-09 16:52:55 -07:00
|
|
|
nobjects = script->objects()->length;
|
2008-08-21 03:47:33 -07:00
|
|
|
if (script->upvarsOffset != 0)
|
2009-09-09 16:52:55 -07:00
|
|
|
nupvars = script->upvars()->length;
|
2007-07-08 02:03:34 -07:00
|
|
|
if (script->regexpsOffset != 0)
|
2009-09-09 16:52:55 -07:00
|
|
|
nregexps = script->regexps()->length;
|
2007-07-08 02:03:34 -07:00
|
|
|
if (script->trynotesOffset != 0)
|
2009-09-09 16:52:55 -07:00
|
|
|
ntrynotes = script->trynotes()->length;
|
2010-07-14 23:19:36 -07:00
|
|
|
if (script->constOffset != 0)
|
|
|
|
nconsts = script->consts()->length;
|
2010-09-13 22:33:44 -07:00
|
|
|
|
|
|
|
nClosedArgs = script->nClosedArgs;
|
|
|
|
nClosedVars = script->nClosedVars;
|
|
|
|
encodedClosedCount = (nClosedArgs << 16) | nClosedVars;
|
|
|
|
|
|
|
|
if (script->noScriptRval)
|
|
|
|
scriptBits |= (1 << NoScriptRval);
|
|
|
|
if (script->savedCallerFun)
|
|
|
|
scriptBits |= (1 << SavedCallerFun);
|
|
|
|
if (script->hasSharps)
|
|
|
|
scriptBits |= (1 << HasSharps);
|
|
|
|
if (script->strictModeCode)
|
|
|
|
scriptBits |= (1 << StrictModeCode);
|
|
|
|
if (script->compileAndGo)
|
|
|
|
scriptBits |= (1 << CompileAndGo);
|
|
|
|
if (script->usesEval)
|
|
|
|
scriptBits |= (1 << UsesEval);
|
|
|
|
if (script->usesArguments)
|
|
|
|
scriptBits |= (1 << UsesArguments);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &prologLength))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!JS_XDRUint32(xdr, &version))
|
|
|
|
return JS_FALSE;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
/*
|
2008-08-21 03:47:33 -07:00
|
|
|
* To fuse allocations, we need srcnote, atom, objects, upvar, regexp,
|
|
|
|
* and trynote counts early.
|
2007-07-08 02:03:34 -07:00
|
|
|
*/
|
|
|
|
if (!JS_XDRUint32(xdr, &natoms))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!JS_XDRUint32(xdr, &nsrcnotes))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!JS_XDRUint32(xdr, &ntrynotes))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!JS_XDRUint32(xdr, &nobjects))
|
|
|
|
return JS_FALSE;
|
2008-08-21 03:47:33 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &nupvars))
|
|
|
|
return JS_FALSE;
|
2007-07-08 02:03:34 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &nregexps))
|
|
|
|
return JS_FALSE;
|
2010-07-14 23:19:36 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &nconsts))
|
|
|
|
return JS_FALSE;
|
2010-09-13 22:33:44 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &encodedClosedCount))
|
|
|
|
return JS_FALSE;
|
|
|
|
if (!JS_XDRUint32(xdr, &scriptBits))
|
|
|
|
return JS_FALSE;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-03-29 11:36:33 -07:00
|
|
|
AutoScriptRooter tvr(cx, NULL);
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
if (xdr->mode == JSXDR_DECODE) {
|
2010-09-13 22:33:44 -07:00
|
|
|
nClosedArgs = encodedClosedCount >> 16;
|
|
|
|
nClosedVars = encodedClosedCount & 0xFFFF;
|
|
|
|
|
|
|
|
script = JSScript::NewScript(cx, length, nsrcnotes, natoms, nobjects, nupvars,
|
|
|
|
nregexps, ntrynotes, nconsts, 0, nClosedArgs,
|
|
|
|
nClosedVars);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!script)
|
|
|
|
return JS_FALSE;
|
2007-07-08 02:03:34 -07:00
|
|
|
|
|
|
|
script->main += prologLength;
|
2010-09-13 09:38:22 -07:00
|
|
|
script->setVersion(JSVersion(version & 0xffff));
|
2009-02-26 00:49:39 -08:00
|
|
|
script->nfixed = uint16(version >> 16);
|
2007-07-08 02:03:34 -07:00
|
|
|
|
|
|
|
/* If we know nsrcnotes, we allocated space for notes in script. */
|
2009-09-09 16:52:55 -07:00
|
|
|
notes = script->notes();
|
2007-03-22 10:30:00 -07:00
|
|
|
*scriptp = script;
|
2010-03-29 11:36:33 -07:00
|
|
|
tvr.setScript(script);
|
2010-09-13 22:33:44 -07:00
|
|
|
|
|
|
|
if (scriptBits & (1 << NoScriptRval))
|
|
|
|
script->noScriptRval = true;
|
|
|
|
if (scriptBits & (1 << SavedCallerFun))
|
|
|
|
script->savedCallerFun = true;
|
|
|
|
if (scriptBits & (1 << HasSharps))
|
|
|
|
script->hasSharps = true;
|
|
|
|
if (scriptBits & (1 << StrictModeCode))
|
|
|
|
script->strictModeCode = true;
|
|
|
|
if (scriptBits & (1 << CompileAndGo))
|
|
|
|
script->compileAndGo = true;
|
|
|
|
if (scriptBits & (1 << UsesEval))
|
|
|
|
script->usesEval = true;
|
|
|
|
if (scriptBits & (1 << UsesArguments))
|
|
|
|
script->usesArguments = true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-07-08 02:03:34 -07:00
|
|
|
* Control hereafter must goto error on failure, in order for the
|
|
|
|
* DECODE case to destroy script.
|
2007-03-22 10:30:00 -07:00
|
|
|
*/
|
2008-03-24 01:06:39 -07:00
|
|
|
oldscript = xdr->script;
|
2008-03-22 18:11:51 -07:00
|
|
|
code = script->code;
|
|
|
|
if (xdr->mode == JSXDR_ENCODE) {
|
2008-03-24 01:06:39 -07:00
|
|
|
code = js_UntrapScriptCode(cx, script);
|
|
|
|
if (!code)
|
|
|
|
goto error;
|
2008-03-22 18:11:51 -07:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
xdr->script = script;
|
2008-03-22 18:11:51 -07:00
|
|
|
ok = JS_XDRBytes(xdr, (char *) code, length * sizeof(jsbytecode));
|
|
|
|
|
|
|
|
if (code != script->code)
|
2009-07-27 21:10:12 -07:00
|
|
|
cx->free(code);
|
2008-03-22 18:11:51 -07:00
|
|
|
|
|
|
|
if (!ok)
|
2007-03-22 10:30:00 -07:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (!JS_XDRBytes(xdr, (char *)notes, nsrcnotes * sizeof(jssrcnote)) ||
|
|
|
|
!JS_XDRCStringOrNull(xdr, (char **)&script->filename) ||
|
|
|
|
!JS_XDRUint32(xdr, &lineno) ||
|
2008-07-20 13:13:17 -07:00
|
|
|
!JS_XDRUint32(xdr, &nslots)) {
|
2007-03-22 10:30:00 -07:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2008-09-05 16:24:53 -07:00
|
|
|
callbacks = JS_GetSecurityCallbacks(cx);
|
2007-07-08 02:03:34 -07:00
|
|
|
if (xdr->mode == JSXDR_ENCODE) {
|
|
|
|
principals = script->principals;
|
2008-09-05 16:24:53 -07:00
|
|
|
encodeable = callbacks && callbacks->principalsTranscoder;
|
2007-07-08 02:03:34 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &encodeable))
|
|
|
|
goto error;
|
|
|
|
if (encodeable &&
|
2008-09-05 16:24:53 -07:00
|
|
|
!callbacks->principalsTranscoder(xdr, &principals)) {
|
2007-07-08 02:03:34 -07:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!JS_XDRUint32(xdr, &encodeable))
|
|
|
|
goto error;
|
|
|
|
if (encodeable) {
|
2008-09-05 16:24:53 -07:00
|
|
|
if (!(callbacks && callbacks->principalsTranscoder)) {
|
2007-07-08 02:03:34 -07:00
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
|
|
|
JSMSG_CANT_DECODE_PRINCIPALS);
|
2007-03-22 10:30:00 -07:00
|
|
|
goto error;
|
|
|
|
}
|
2008-09-05 16:24:53 -07:00
|
|
|
if (!callbacks->principalsTranscoder(xdr, &principals))
|
2007-03-22 10:30:00 -07:00
|
|
|
goto error;
|
2007-07-08 02:03:34 -07:00
|
|
|
script->principals = principals;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xdr->mode == JSXDR_DECODE) {
|
|
|
|
const char *filename = script->filename;
|
|
|
|
if (filename) {
|
|
|
|
filename = js_SaveScriptFilename(cx, filename);
|
|
|
|
if (!filename)
|
|
|
|
goto error;
|
2009-07-27 21:10:12 -07:00
|
|
|
cx->free((void *) script->filename);
|
2007-03-22 10:30:00 -07:00
|
|
|
script->filename = filename;
|
|
|
|
filenameWasSaved = JS_TRUE;
|
|
|
|
}
|
|
|
|
script->lineno = (uintN)lineno;
|
2008-08-21 03:47:33 -07:00
|
|
|
script->nslots = (uint16)nslots;
|
2009-04-05 21:17:22 -07:00
|
|
|
script->staticLevel = (uint16)(nslots >> 16);
|
2010-09-13 22:33:44 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
for (i = 0; i != natoms; ++i) {
|
|
|
|
if (!js_XDRAtom(xdr, &script->atomMap.vector[i]))
|
|
|
|
goto error;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
/*
|
|
|
|
* Here looping from 0-to-length to xdr objects is essential. It ensures
|
2008-08-21 03:47:33 -07:00
|
|
|
* that block objects from the script->objects array will be written and
|
2009-05-06 16:03:10 -07:00
|
|
|
* restored in the outer-to-inner order. js_XDRBlockObject relies on this
|
|
|
|
* to restore the parent chain.
|
2007-07-08 02:03:34 -07:00
|
|
|
*/
|
|
|
|
for (i = 0; i != nobjects; ++i) {
|
2009-09-09 16:52:55 -07:00
|
|
|
JSObject **objp = &script->objects()->vector[i];
|
2009-05-06 16:03:10 -07:00
|
|
|
uint32 isBlock;
|
|
|
|
if (xdr->mode == JSXDR_ENCODE) {
|
2010-07-14 23:19:36 -07:00
|
|
|
Class *clasp = (*objp)->getClass();
|
2009-05-06 16:03:10 -07:00
|
|
|
JS_ASSERT(clasp == &js_FunctionClass ||
|
|
|
|
clasp == &js_BlockClass);
|
|
|
|
isBlock = (clasp == &js_BlockClass) ? 1 : 0;
|
2009-10-18 17:41:24 -07:00
|
|
|
}
|
2009-05-06 16:03:10 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &isBlock))
|
2007-07-08 02:03:34 -07:00
|
|
|
goto error;
|
2009-05-06 16:03:10 -07:00
|
|
|
if (isBlock == 0) {
|
|
|
|
if (!js_XDRFunctionObject(xdr, objp))
|
|
|
|
goto error;
|
|
|
|
} else {
|
|
|
|
JS_ASSERT(isBlock == 1);
|
|
|
|
if (!js_XDRBlockObject(xdr, objp))
|
|
|
|
goto error;
|
|
|
|
}
|
2007-07-08 02:03:34 -07:00
|
|
|
}
|
2008-08-21 03:47:33 -07:00
|
|
|
for (i = 0; i != nupvars; ++i) {
|
2010-07-02 13:37:39 -07:00
|
|
|
if (!JS_XDRUint32(xdr, reinterpret_cast<uint32 *>(&script->upvars()->vector[i])))
|
2008-08-21 03:47:33 -07:00
|
|
|
goto error;
|
|
|
|
}
|
2007-07-08 02:03:34 -07:00
|
|
|
for (i = 0; i != nregexps; ++i) {
|
2009-09-09 16:52:55 -07:00
|
|
|
if (!js_XDRRegExpObject(xdr, &script->regexps()->vector[i]))
|
2007-07-08 02:03:34 -07:00
|
|
|
goto error;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2010-09-13 22:33:44 -07:00
|
|
|
for (i = 0; i != nClosedArgs; ++i) {
|
|
|
|
if (!JS_XDRUint32(xdr, &script->closedSlots[i]))
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
for (i = 0; i != nClosedVars; ++i) {
|
|
|
|
if (!JS_XDRUint32(xdr, &script->closedSlots[nClosedArgs + i]))
|
|
|
|
goto error;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (ntrynotes != 0) {
|
2007-05-24 00:51:46 -07:00
|
|
|
/*
|
2007-07-08 02:03:34 -07:00
|
|
|
* We combine tn->kind and tn->stackDepth when serializing as XDR is not
|
2007-05-24 00:51:46 -07:00
|
|
|
* efficient when serializing small integer types.
|
|
|
|
*/
|
2007-07-08 02:03:34 -07:00
|
|
|
JSTryNote *tn, *tnfirst;
|
|
|
|
uint32 kindAndDepth;
|
2007-05-24 00:51:46 -07:00
|
|
|
JS_STATIC_ASSERT(sizeof(tn->kind) == sizeof(uint8));
|
|
|
|
JS_STATIC_ASSERT(sizeof(tn->stackDepth) == sizeof(uint16));
|
|
|
|
|
2009-09-09 16:52:55 -07:00
|
|
|
tnfirst = script->trynotes()->vector;
|
|
|
|
JS_ASSERT(script->trynotes()->length == ntrynotes);
|
2007-07-08 02:03:34 -07:00
|
|
|
tn = tnfirst + ntrynotes;
|
|
|
|
do {
|
|
|
|
--tn;
|
|
|
|
if (xdr->mode == JSXDR_ENCODE) {
|
|
|
|
kindAndDepth = ((uint32)tn->kind << 16)
|
|
|
|
| (uint32)tn->stackDepth;
|
|
|
|
}
|
|
|
|
if (!JS_XDRUint32(xdr, &kindAndDepth) ||
|
|
|
|
!JS_XDRUint32(xdr, &tn->start) ||
|
|
|
|
!JS_XDRUint32(xdr, &tn->length)) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (xdr->mode == JSXDR_DECODE) {
|
|
|
|
tn->kind = (uint8)(kindAndDepth >> 16);
|
|
|
|
tn->stackDepth = (uint16)kindAndDepth;
|
|
|
|
}
|
|
|
|
} while (tn != tnfirst);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
for (i = 0; i != nconsts; ++i) {
|
|
|
|
if (!JS_XDRValue(xdr, Jsvalify(&script->consts()->vector[i])))
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
xdr->script = oldscript;
|
|
|
|
return JS_TRUE;
|
|
|
|
|
|
|
|
error:
|
|
|
|
if (xdr->mode == JSXDR_DECODE) {
|
|
|
|
if (script->filename && !filenameWasSaved) {
|
2009-07-27 21:10:12 -07:00
|
|
|
cx->free((void *) script->filename);
|
2007-03-22 10:30:00 -07:00
|
|
|
script->filename = NULL;
|
|
|
|
}
|
|
|
|
js_DestroyScript(cx, script);
|
|
|
|
*scriptp = NULL;
|
|
|
|
}
|
2007-07-08 02:03:34 -07:00
|
|
|
xdr->script = oldscript;
|
2007-03-22 10:30:00 -07:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* JS_HAS_XDR */
|
|
|
|
|
|
|
|
static void
|
|
|
|
script_finalize(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
2009-08-04 14:06:55 -07:00
|
|
|
JSScript *script = (JSScript *) obj->getPrivate();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (script)
|
2010-10-06 08:21:23 -07:00
|
|
|
js_DestroyScriptFromGC(cx, script, NULL);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2007-04-16 23:53:37 -07:00
|
|
|
static void
|
|
|
|
script_trace(JSTracer *trc, JSObject *obj)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2009-08-04 14:06:55 -07:00
|
|
|
JSScript *script = (JSScript *) obj->getPrivate();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (script)
|
2007-04-16 23:53:37 -07:00
|
|
|
js_TraceScript(trc, script);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
Class js_ScriptClass = {
|
2010-03-04 00:33:57 -08:00
|
|
|
"Script",
|
2010-04-13 19:38:49 -07:00
|
|
|
JSCLASS_HAS_PRIVATE |
|
2010-03-04 00:33:57 -08:00
|
|
|
JSCLASS_MARK_IS_TRACE | JSCLASS_HAS_CACHED_PROTO(JSProto_Object),
|
2010-06-12 09:29:04 -07:00
|
|
|
PropertyStub, /* addProperty */
|
|
|
|
PropertyStub, /* delProperty */
|
|
|
|
PropertyStub, /* getProperty */
|
|
|
|
PropertyStub, /* setProperty */
|
|
|
|
EnumerateStub,
|
|
|
|
ResolveStub,
|
|
|
|
ConvertStub,
|
|
|
|
script_finalize,
|
|
|
|
NULL, /* reserved0 */
|
|
|
|
NULL, /* checkAccess */
|
|
|
|
NULL, /* call */
|
|
|
|
NULL, /* construct */
|
|
|
|
NULL, /* xdrObject */
|
|
|
|
NULL, /* hasInstance */
|
|
|
|
JS_CLASS_TRACE(script_trace)
|
2007-03-22 10:30:00 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shared script filename management.
|
|
|
|
*/
|
2008-09-06 15:21:43 -07:00
|
|
|
static int
|
2007-03-22 10:30:00 -07:00
|
|
|
js_compare_strings(const void *k1, const void *k2)
|
|
|
|
{
|
2007-07-05 13:37:47 -07:00
|
|
|
return strcmp((const char *) k1, (const char *) k2) == 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* NB: This struct overlays JSHashEntry -- see jshash.h, do not reorganize. */
|
|
|
|
typedef struct ScriptFilenameEntry {
|
|
|
|
JSHashEntry *next; /* hash chain linkage */
|
|
|
|
JSHashNumber keyHash; /* key hash function result */
|
|
|
|
const void *key; /* ptr to filename, below */
|
|
|
|
uint32 flags; /* user-defined filename prefix flags */
|
|
|
|
JSPackedBool mark; /* GC mark flag */
|
|
|
|
char filename[3]; /* two or more bytes, NUL-terminated */
|
|
|
|
} ScriptFilenameEntry;
|
|
|
|
|
2008-09-06 15:21:43 -07:00
|
|
|
static void *
|
2007-08-11 13:25:16 -07:00
|
|
|
js_alloc_table_space(void *priv, size_t size)
|
|
|
|
{
|
2009-07-27 21:10:12 -07:00
|
|
|
return js_malloc(size);
|
2007-08-11 13:25:16 -07:00
|
|
|
}
|
|
|
|
|
2008-09-06 15:21:43 -07:00
|
|
|
static void
|
2009-04-05 21:17:22 -07:00
|
|
|
js_free_table_space(void *priv, void *item, size_t size)
|
2007-08-11 13:25:16 -07:00
|
|
|
{
|
2009-07-27 21:10:12 -07:00
|
|
|
js_free(item);
|
2007-08-11 13:25:16 -07:00
|
|
|
}
|
|
|
|
|
2008-09-06 15:21:43 -07:00
|
|
|
static JSHashEntry *
|
2007-03-22 10:30:00 -07:00
|
|
|
js_alloc_sftbl_entry(void *priv, const void *key)
|
|
|
|
{
|
2007-07-05 13:37:47 -07:00
|
|
|
size_t nbytes = offsetof(ScriptFilenameEntry, filename) +
|
|
|
|
strlen((const char *) key) + 1;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-07-27 21:10:12 -07:00
|
|
|
return (JSHashEntry *) js_malloc(JS_MAX(nbytes, sizeof(JSHashEntry)));
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2008-09-06 15:21:43 -07:00
|
|
|
static void
|
2007-03-22 10:30:00 -07:00
|
|
|
js_free_sftbl_entry(void *priv, JSHashEntry *he, uintN flag)
|
|
|
|
{
|
|
|
|
if (flag != HT_FREE_ENTRY)
|
|
|
|
return;
|
2009-07-27 21:10:12 -07:00
|
|
|
js_free(he);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSHashAllocOps sftbl_alloc_ops = {
|
|
|
|
js_alloc_table_space, js_free_table_space,
|
|
|
|
js_alloc_sftbl_entry, js_free_sftbl_entry
|
|
|
|
};
|
|
|
|
|
2009-09-26 06:44:11 -07:00
|
|
|
static void
|
|
|
|
FinishRuntimeScriptState(JSRuntime *rt)
|
|
|
|
{
|
|
|
|
if (rt->scriptFilenameTable) {
|
|
|
|
JS_HashTableDestroy(rt->scriptFilenameTable);
|
|
|
|
rt->scriptFilenameTable = NULL;
|
|
|
|
}
|
|
|
|
#ifdef JS_THREADSAFE
|
|
|
|
if (rt->scriptFilenameTableLock) {
|
|
|
|
JS_DESTROY_LOCK(rt->scriptFilenameTableLock);
|
|
|
|
rt->scriptFilenameTableLock = NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JSBool
|
|
|
|
js_InitRuntimeScriptState(JSRuntime *rt)
|
|
|
|
{
|
|
|
|
#ifdef JS_THREADSAFE
|
|
|
|
JS_ASSERT(!rt->scriptFilenameTableLock);
|
|
|
|
rt->scriptFilenameTableLock = JS_NEW_LOCK();
|
|
|
|
if (!rt->scriptFilenameTableLock)
|
|
|
|
return JS_FALSE;
|
|
|
|
#endif
|
|
|
|
JS_ASSERT(!rt->scriptFilenameTable);
|
|
|
|
rt->scriptFilenameTable =
|
|
|
|
JS_NewHashTable(16, JS_HashString, js_compare_strings, NULL,
|
|
|
|
&sftbl_alloc_ops, NULL);
|
|
|
|
if (!rt->scriptFilenameTable) {
|
2009-09-26 06:44:11 -07:00
|
|
|
FinishRuntimeScriptState(rt); /* free lock if threadsafe */
|
2007-03-22 10:30:00 -07:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
JS_INIT_CLIST(&rt->scriptFilenamePrefixes);
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct ScriptFilenamePrefix {
|
|
|
|
JSCList links; /* circular list linkage for easy deletion */
|
|
|
|
const char *name; /* pointer to pinned ScriptFilenameEntry string */
|
|
|
|
size_t length; /* prefix string length, precomputed */
|
|
|
|
uint32 flags; /* user-defined flags to inherit from this prefix */
|
|
|
|
} ScriptFilenamePrefix;
|
|
|
|
|
|
|
|
void
|
|
|
|
js_FreeRuntimeScriptState(JSRuntime *rt)
|
|
|
|
{
|
|
|
|
if (!rt->scriptFilenameTable)
|
|
|
|
return;
|
|
|
|
|
|
|
|
while (!JS_CLIST_IS_EMPTY(&rt->scriptFilenamePrefixes)) {
|
2009-09-26 06:44:11 -07:00
|
|
|
ScriptFilenamePrefix *sfp = (ScriptFilenamePrefix *)
|
|
|
|
rt->scriptFilenamePrefixes.next;
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_REMOVE_LINK(&sfp->links);
|
2009-07-27 21:10:12 -07:00
|
|
|
js_free(sfp);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2009-09-26 06:44:11 -07:00
|
|
|
FinishRuntimeScriptState(rt);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG_brendan
|
|
|
|
#define DEBUG_SFTBL
|
|
|
|
#endif
|
|
|
|
#ifdef DEBUG_SFTBL
|
|
|
|
size_t sftbl_savings = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static ScriptFilenameEntry *
|
|
|
|
SaveScriptFilename(JSRuntime *rt, const char *filename, uint32 flags)
|
|
|
|
{
|
|
|
|
JSHashTable *table;
|
|
|
|
JSHashNumber hash;
|
|
|
|
JSHashEntry **hep;
|
|
|
|
ScriptFilenameEntry *sfe;
|
|
|
|
size_t length;
|
|
|
|
JSCList *head, *link;
|
|
|
|
ScriptFilenamePrefix *sfp;
|
|
|
|
|
|
|
|
table = rt->scriptFilenameTable;
|
|
|
|
hash = JS_HashString(filename);
|
|
|
|
hep = JS_HashTableRawLookup(table, hash, filename);
|
|
|
|
sfe = (ScriptFilenameEntry *) *hep;
|
|
|
|
#ifdef DEBUG_SFTBL
|
|
|
|
if (sfe)
|
|
|
|
sftbl_savings += strlen(sfe->filename);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!sfe) {
|
|
|
|
sfe = (ScriptFilenameEntry *)
|
|
|
|
JS_HashTableRawAdd(table, hep, hash, filename, NULL);
|
|
|
|
if (!sfe)
|
|
|
|
return NULL;
|
|
|
|
sfe->key = strcpy(sfe->filename, filename);
|
|
|
|
sfe->flags = 0;
|
|
|
|
sfe->mark = JS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If saving a prefix, add it to the set in rt->scriptFilenamePrefixes. */
|
|
|
|
if (flags != 0) {
|
|
|
|
/* Search in case filename was saved already; we must be idempotent. */
|
|
|
|
sfp = NULL;
|
|
|
|
length = strlen(filename);
|
|
|
|
for (head = link = &rt->scriptFilenamePrefixes;
|
|
|
|
link->next != head;
|
|
|
|
link = link->next) {
|
|
|
|
/* Lag link behind sfp to insert in non-increasing length order. */
|
|
|
|
sfp = (ScriptFilenamePrefix *) link->next;
|
|
|
|
if (!strcmp(sfp->name, filename))
|
|
|
|
break;
|
|
|
|
if (sfp->length <= length) {
|
|
|
|
sfp = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
sfp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sfp) {
|
|
|
|
/* No such prefix: add one now. */
|
2009-07-27 21:10:12 -07:00
|
|
|
sfp = (ScriptFilenamePrefix *) js_malloc(sizeof(ScriptFilenamePrefix));
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!sfp)
|
|
|
|
return NULL;
|
|
|
|
JS_INSERT_AFTER(&sfp->links, link);
|
|
|
|
sfp->name = sfe->filename;
|
|
|
|
sfp->length = length;
|
|
|
|
sfp->flags = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Accumulate flags in both sfe and sfp: sfe for later access from the
|
|
|
|
* JS_GetScriptedCallerFilenameFlags debug-API, and sfp so that longer
|
|
|
|
* filename entries can inherit by prefix.
|
|
|
|
*/
|
|
|
|
sfe->flags |= flags;
|
|
|
|
sfp->flags |= flags;
|
|
|
|
}
|
|
|
|
|
2010-07-23 14:41:56 -07:00
|
|
|
#ifdef DEBUG
|
|
|
|
if (rt->functionMeterFilename) {
|
|
|
|
size_t len = strlen(sfe->filename);
|
|
|
|
if (len >= sizeof rt->lastScriptFilename)
|
|
|
|
len = sizeof rt->lastScriptFilename - 1;
|
|
|
|
memcpy(rt->lastScriptFilename, sfe->filename, len);
|
|
|
|
rt->lastScriptFilename[len] = '\0';
|
|
|
|
}
|
2009-04-05 21:17:22 -07:00
|
|
|
#endif
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
return sfe;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
js_SaveScriptFilename(JSContext *cx, const char *filename)
|
|
|
|
{
|
|
|
|
JSRuntime *rt;
|
|
|
|
ScriptFilenameEntry *sfe;
|
|
|
|
JSCList *head, *link;
|
|
|
|
ScriptFilenamePrefix *sfp;
|
|
|
|
|
|
|
|
rt = cx->runtime;
|
|
|
|
JS_ACQUIRE_LOCK(rt->scriptFilenameTableLock);
|
|
|
|
sfe = SaveScriptFilename(rt, filename, 0);
|
|
|
|
if (!sfe) {
|
|
|
|
JS_RELEASE_LOCK(rt->scriptFilenameTableLock);
|
|
|
|
JS_ReportOutOfMemory(cx);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to inherit flags by prefix. We assume there won't be more than a
|
|
|
|
* few (dozen! ;-) prefixes, so linear search is tolerable.
|
|
|
|
* XXXbe every time I've assumed that in the JS engine, I've been wrong!
|
|
|
|
*/
|
|
|
|
for (head = &rt->scriptFilenamePrefixes, link = head->next;
|
|
|
|
link != head;
|
|
|
|
link = link->next) {
|
|
|
|
sfp = (ScriptFilenamePrefix *) link;
|
|
|
|
if (!strncmp(sfp->name, filename, sfp->length)) {
|
|
|
|
sfe->flags |= sfp->flags;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
JS_RELEASE_LOCK(rt->scriptFilenameTableLock);
|
|
|
|
return sfe->filename;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
js_SaveScriptFilenameRT(JSRuntime *rt, const char *filename, uint32 flags)
|
|
|
|
{
|
|
|
|
ScriptFilenameEntry *sfe;
|
|
|
|
|
|
|
|
/* This may be called very early, via the jsdbgapi.h entry point. */
|
|
|
|
if (!rt->scriptFilenameTable && !js_InitRuntimeScriptState(rt))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
JS_ACQUIRE_LOCK(rt->scriptFilenameTableLock);
|
|
|
|
sfe = SaveScriptFilename(rt, filename, flags);
|
|
|
|
JS_RELEASE_LOCK(rt->scriptFilenameTableLock);
|
|
|
|
if (!sfe)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return sfe->filename;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Back up from a saved filename by its offset within its hash table entry.
|
|
|
|
*/
|
|
|
|
#define FILENAME_TO_SFE(fn) \
|
|
|
|
((ScriptFilenameEntry *) ((fn) - offsetof(ScriptFilenameEntry, filename)))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The sfe->key member, redundant given sfe->filename but required by the old
|
|
|
|
* jshash.c code, here gives us a useful sanity check. This assertion will
|
|
|
|
* very likely botch if someone tries to mark a string that wasn't allocated
|
|
|
|
* as an sfe->filename.
|
|
|
|
*/
|
|
|
|
#define ASSERT_VALID_SFE(sfe) JS_ASSERT((sfe)->key == (sfe)->filename)
|
|
|
|
|
|
|
|
uint32
|
|
|
|
js_GetScriptFilenameFlags(const char *filename)
|
|
|
|
{
|
|
|
|
ScriptFilenameEntry *sfe;
|
|
|
|
|
|
|
|
sfe = FILENAME_TO_SFE(filename);
|
|
|
|
ASSERT_VALID_SFE(sfe);
|
|
|
|
return sfe->flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
js_MarkScriptFilename(const char *filename)
|
|
|
|
{
|
|
|
|
ScriptFilenameEntry *sfe;
|
|
|
|
|
|
|
|
sfe = FILENAME_TO_SFE(filename);
|
|
|
|
ASSERT_VALID_SFE(sfe);
|
|
|
|
sfe->mark = JS_TRUE;
|
|
|
|
}
|
|
|
|
|
2008-09-06 15:21:43 -07:00
|
|
|
static intN
|
2007-03-22 10:30:00 -07:00
|
|
|
js_script_filename_marker(JSHashEntry *he, intN i, void *arg)
|
|
|
|
{
|
|
|
|
ScriptFilenameEntry *sfe = (ScriptFilenameEntry *) he;
|
|
|
|
|
|
|
|
sfe->mark = JS_TRUE;
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-04-23 15:15:42 -07:00
|
|
|
js_MarkScriptFilenames(JSRuntime *rt)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
JSCList *head, *link;
|
|
|
|
ScriptFilenamePrefix *sfp;
|
|
|
|
|
|
|
|
if (!rt->scriptFilenameTable)
|
|
|
|
return;
|
|
|
|
|
2010-04-23 15:15:42 -07:00
|
|
|
if (rt->gcKeepAtoms) {
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_HashTableEnumerateEntries(rt->scriptFilenameTable,
|
|
|
|
js_script_filename_marker,
|
|
|
|
rt);
|
|
|
|
}
|
|
|
|
for (head = &rt->scriptFilenamePrefixes, link = head->next;
|
|
|
|
link != head;
|
|
|
|
link = link->next) {
|
|
|
|
sfp = (ScriptFilenamePrefix *) link;
|
|
|
|
js_MarkScriptFilename(sfp->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-06 15:21:43 -07:00
|
|
|
static intN
|
2007-03-22 10:30:00 -07:00
|
|
|
js_script_filename_sweeper(JSHashEntry *he, intN i, void *arg)
|
|
|
|
{
|
|
|
|
ScriptFilenameEntry *sfe = (ScriptFilenameEntry *) he;
|
|
|
|
|
|
|
|
if (!sfe->mark)
|
|
|
|
return HT_ENUMERATE_REMOVE;
|
|
|
|
sfe->mark = JS_FALSE;
|
|
|
|
return HT_ENUMERATE_NEXT;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
js_SweepScriptFilenames(JSRuntime *rt)
|
|
|
|
{
|
|
|
|
if (!rt->scriptFilenameTable)
|
|
|
|
return;
|
|
|
|
|
2009-09-26 06:44:11 -07:00
|
|
|
/*
|
|
|
|
* JS_HashTableEnumerateEntries shrinks the table if many entries are
|
|
|
|
* removed preventing wasting memory on a too sparse table.
|
|
|
|
*/
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_HashTableEnumerateEntries(rt->scriptFilenameTable,
|
|
|
|
js_script_filename_sweeper,
|
|
|
|
rt);
|
|
|
|
#ifdef DEBUG_notme
|
|
|
|
#ifdef DEBUG_SFTBL
|
|
|
|
printf("script filename table savings so far: %u\n", sftbl_savings);
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
/*
|
|
|
|
* JSScript data structures memory alignment:
|
|
|
|
*
|
|
|
|
* JSScript
|
|
|
|
* JSObjectArray script objects' descriptor if JSScript.objectsOffset != 0,
|
2009-09-09 16:52:55 -07:00
|
|
|
* use script->objects() to access it.
|
2007-07-08 02:03:34 -07:00
|
|
|
* JSObjectArray script regexps' descriptor if JSScript.regexpsOffset != 0,
|
2009-09-09 16:52:55 -07:00
|
|
|
* use script->regexps() to access it.
|
2007-07-08 02:03:34 -07:00
|
|
|
* JSTryNoteArray script try notes' descriptor if JSScript.tryNotesOffset
|
2009-09-09 16:52:55 -07:00
|
|
|
* != 0, use script->trynotes() to access it.
|
2007-07-08 02:03:34 -07:00
|
|
|
* JSAtom *a[] array of JSScript.atomMap.length atoms pointed by
|
|
|
|
* JSScript.atomMap.vector if any.
|
2009-09-09 16:52:55 -07:00
|
|
|
* JSObject *o[] array of script->objects()->length objects if any
|
|
|
|
* pointed by script->objects()->vector.
|
|
|
|
* JSObject *r[] array of script->regexps()->length regexps if any
|
|
|
|
* pointed by script->regexps()->vector.
|
|
|
|
* JSTryNote t[] array of script->trynotes()->length try notes if any
|
|
|
|
* pointed by script->trynotes()->vector.
|
2007-07-08 02:03:34 -07:00
|
|
|
* jsbytecode b[] script bytecode pointed by JSScript.code.
|
2009-09-09 16:52:55 -07:00
|
|
|
* jssrcnote s[] script source notes, use script->notes() to access it
|
2007-07-08 02:03:34 -07:00
|
|
|
*
|
|
|
|
* The alignment avoids gaps between entries as alignment requirement for each
|
|
|
|
* subsequent structure or array is the same or divides the alignment
|
|
|
|
* requirement for the previous one.
|
|
|
|
*
|
|
|
|
* The followings asserts checks that assuming that the alignment requirement
|
|
|
|
* for JSObjectArray and JSTryNoteArray are sizeof(void *) and for JSTryNote
|
|
|
|
* it is sizeof(uint32) as the structure consists of 3 uint32 fields.
|
|
|
|
*/
|
|
|
|
JS_STATIC_ASSERT(sizeof(JSScript) % sizeof(void *) == 0);
|
|
|
|
JS_STATIC_ASSERT(sizeof(JSObjectArray) % sizeof(void *) == 0);
|
|
|
|
JS_STATIC_ASSERT(sizeof(JSTryNoteArray) == sizeof(JSObjectArray));
|
|
|
|
JS_STATIC_ASSERT(sizeof(JSAtom *) == sizeof(JSObject *));
|
|
|
|
JS_STATIC_ASSERT(sizeof(JSObject *) % sizeof(uint32) == 0);
|
|
|
|
JS_STATIC_ASSERT(sizeof(JSTryNote) == 3 * sizeof(uint32));
|
|
|
|
JS_STATIC_ASSERT(sizeof(uint32) % sizeof(jsbytecode) == 0);
|
|
|
|
JS_STATIC_ASSERT(sizeof(jsbytecode) % sizeof(jssrcnote) == 0);
|
|
|
|
|
|
|
|
/*
|
2008-08-21 03:47:33 -07:00
|
|
|
* Check that uint8 offset for object, upvar, regexp, and try note arrays is
|
|
|
|
* sufficient.
|
2007-07-08 02:03:34 -07:00
|
|
|
*/
|
2008-08-21 03:47:33 -07:00
|
|
|
JS_STATIC_ASSERT(sizeof(JSScript) + 2 * sizeof(JSObjectArray) +
|
|
|
|
sizeof(JSUpvarArray) < JS_BIT(8));
|
2007-07-08 02:03:34 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JSScript *
|
2010-09-13 22:33:44 -07:00
|
|
|
JSScript::NewScript(JSContext *cx, uint32 length, uint32 nsrcnotes, uint32 natoms,
|
|
|
|
uint32 nobjects, uint32 nupvars, uint32 nregexps,
|
|
|
|
uint32 ntrynotes, uint32 nconsts, uint32 nglobals,
|
2010-11-29 13:33:17 -08:00
|
|
|
uint16 nClosedArgs, uint16 nClosedVars)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2007-07-08 02:03:34 -07:00
|
|
|
size_t size, vectorSize;
|
2007-03-22 10:30:00 -07:00
|
|
|
JSScript *script;
|
2007-07-08 02:03:34 -07:00
|
|
|
uint8 *cursor;
|
2010-07-14 23:19:36 -07:00
|
|
|
unsigned constPadding = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-09-13 22:33:44 -07:00
|
|
|
uint32 totalClosed = nClosedArgs + nClosedVars;
|
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
size = sizeof(JSScript) +
|
2010-07-14 23:19:36 -07:00
|
|
|
sizeof(JSAtom *) * natoms;
|
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (nobjects != 0)
|
|
|
|
size += sizeof(JSObjectArray) + nobjects * sizeof(JSObject *);
|
2008-08-21 03:47:33 -07:00
|
|
|
if (nupvars != 0)
|
|
|
|
size += sizeof(JSUpvarArray) + nupvars * sizeof(uint32);
|
2007-07-08 02:03:34 -07:00
|
|
|
if (nregexps != 0)
|
|
|
|
size += sizeof(JSObjectArray) + nregexps * sizeof(JSObject *);
|
|
|
|
if (ntrynotes != 0)
|
|
|
|
size += sizeof(JSTryNoteArray) + ntrynotes * sizeof(JSTryNote);
|
2010-05-22 15:38:04 -07:00
|
|
|
if (nglobals != 0)
|
|
|
|
size += sizeof(GlobalSlotArray) + nglobals * sizeof(GlobalSlotArray::Entry);
|
2010-09-13 22:33:44 -07:00
|
|
|
if (totalClosed != 0)
|
|
|
|
size += totalClosed * sizeof(uint32);
|
2007-07-08 02:03:34 -07:00
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
if (nconsts != 0) {
|
|
|
|
size += sizeof(JSConstArray);
|
|
|
|
/*
|
|
|
|
* Calculate padding assuming that consts go after the other arrays,
|
|
|
|
* but before the bytecode and source notes.
|
|
|
|
*/
|
|
|
|
constPadding = (8 - (size % 8)) % 8;
|
|
|
|
size += constPadding + nconsts * sizeof(Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
size += length * sizeof(jsbytecode) +
|
|
|
|
nsrcnotes * sizeof(jssrcnote);
|
|
|
|
|
2009-07-27 21:10:12 -07:00
|
|
|
script = (JSScript *) cx->malloc(size);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!script)
|
|
|
|
return NULL;
|
2010-08-05 17:15:49 -07:00
|
|
|
|
2010-03-10 15:34:12 -08:00
|
|
|
PodZero(script);
|
2007-03-22 10:30:00 -07:00
|
|
|
script->length = length;
|
2010-09-13 09:38:22 -07:00
|
|
|
script->setVersion(cx->findVersion());
|
2007-07-08 02:03:34 -07:00
|
|
|
|
|
|
|
cursor = (uint8 *)script + sizeof(JSScript);
|
|
|
|
if (nobjects != 0) {
|
|
|
|
script->objectsOffset = (uint8)(cursor - (uint8 *)script);
|
|
|
|
cursor += sizeof(JSObjectArray);
|
|
|
|
}
|
2008-08-21 03:47:33 -07:00
|
|
|
if (nupvars != 0) {
|
|
|
|
script->upvarsOffset = (uint8)(cursor - (uint8 *)script);
|
|
|
|
cursor += sizeof(JSUpvarArray);
|
|
|
|
}
|
2007-07-08 02:03:34 -07:00
|
|
|
if (nregexps != 0) {
|
|
|
|
script->regexpsOffset = (uint8)(cursor - (uint8 *)script);
|
|
|
|
cursor += sizeof(JSObjectArray);
|
|
|
|
}
|
|
|
|
if (ntrynotes != 0) {
|
|
|
|
script->trynotesOffset = (uint8)(cursor - (uint8 *)script);
|
|
|
|
cursor += sizeof(JSTryNoteArray);
|
|
|
|
}
|
2010-05-22 15:38:04 -07:00
|
|
|
if (nglobals != 0) {
|
|
|
|
script->globalsOffset = (uint8)(cursor - (uint8 *)script);
|
|
|
|
cursor += sizeof(GlobalSlotArray);
|
|
|
|
}
|
2010-10-14 12:58:01 -07:00
|
|
|
JS_ASSERT((cursor - (uint8 *)script) <= 0xFF);
|
2010-07-14 23:19:36 -07:00
|
|
|
if (nconsts != 0) {
|
|
|
|
script->constOffset = (uint8)(cursor - (uint8 *)script);
|
|
|
|
cursor += sizeof(JSConstArray);
|
|
|
|
}
|
2007-07-08 02:03:34 -07:00
|
|
|
|
2010-10-14 12:58:01 -07:00
|
|
|
JS_STATIC_ASSERT(sizeof(JSScript) +
|
|
|
|
sizeof(JSObjectArray) +
|
|
|
|
sizeof(JSUpvarArray) +
|
|
|
|
sizeof(JSObjectArray) +
|
|
|
|
sizeof(JSTryNoteArray) +
|
|
|
|
sizeof(GlobalSlotArray) <= 0xFF);
|
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (natoms != 0) {
|
|
|
|
script->atomMap.length = natoms;
|
|
|
|
script->atomMap.vector = (JSAtom **)cursor;
|
|
|
|
vectorSize = natoms * sizeof(script->atomMap.vector[0]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear object map's vector so the GC tracing can run when not yet
|
|
|
|
* all atoms are copied to the array.
|
|
|
|
*/
|
|
|
|
memset(cursor, 0, vectorSize);
|
|
|
|
cursor += vectorSize;
|
|
|
|
}
|
2008-06-03 23:52:28 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (nobjects != 0) {
|
2009-09-09 16:52:55 -07:00
|
|
|
script->objects()->length = nobjects;
|
|
|
|
script->objects()->vector = (JSObject **)cursor;
|
|
|
|
vectorSize = nobjects * sizeof(script->objects()->vector[0]);
|
2007-07-08 02:03:34 -07:00
|
|
|
memset(cursor, 0, vectorSize);
|
|
|
|
cursor += vectorSize;
|
|
|
|
}
|
2008-08-21 03:47:33 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (nregexps != 0) {
|
2009-09-09 16:52:55 -07:00
|
|
|
script->regexps()->length = nregexps;
|
|
|
|
script->regexps()->vector = (JSObject **)cursor;
|
|
|
|
vectorSize = nregexps * sizeof(script->regexps()->vector[0]);
|
2007-07-08 02:03:34 -07:00
|
|
|
memset(cursor, 0, vectorSize);
|
|
|
|
cursor += vectorSize;
|
|
|
|
}
|
2008-08-21 03:47:33 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
if (ntrynotes != 0) {
|
2009-09-09 16:52:55 -07:00
|
|
|
script->trynotes()->length = ntrynotes;
|
|
|
|
script->trynotes()->vector = (JSTryNote *)cursor;
|
|
|
|
vectorSize = ntrynotes * sizeof(script->trynotes()->vector[0]);
|
2007-07-08 02:03:34 -07:00
|
|
|
#ifdef DEBUG
|
|
|
|
memset(cursor, 0, vectorSize);
|
|
|
|
#endif
|
|
|
|
cursor += vectorSize;
|
|
|
|
}
|
2008-06-03 23:52:28 -07:00
|
|
|
|
2010-05-22 15:38:04 -07:00
|
|
|
if (nglobals != 0) {
|
|
|
|
script->globals()->length = nglobals;
|
|
|
|
script->globals()->vector = (GlobalSlotArray::Entry *)cursor;
|
|
|
|
vectorSize = nglobals * sizeof(script->globals()->vector[0]);
|
|
|
|
cursor += vectorSize;
|
|
|
|
}
|
|
|
|
|
2010-09-13 22:33:44 -07:00
|
|
|
if (totalClosed != 0) {
|
2010-11-11 14:23:49 -08:00
|
|
|
script->nClosedArgs = nClosedArgs;
|
|
|
|
script->nClosedVars = nClosedVars;
|
2010-09-13 22:33:44 -07:00
|
|
|
script->closedSlots = (uint32 *)cursor;
|
|
|
|
cursor += totalClosed * sizeof(uint32);
|
|
|
|
}
|
|
|
|
|
2009-09-06 12:05:51 -07:00
|
|
|
/*
|
|
|
|
* NB: We allocate the vector of uint32 upvar cookies after all vectors of
|
|
|
|
* pointers, to avoid misalignment on 64-bit platforms. See bug 514645.
|
|
|
|
*/
|
|
|
|
if (nupvars != 0) {
|
2009-09-09 16:52:55 -07:00
|
|
|
script->upvars()->length = nupvars;
|
2010-07-02 13:37:39 -07:00
|
|
|
script->upvars()->vector = reinterpret_cast<UpvarCookie *>(cursor);
|
2009-09-09 16:52:55 -07:00
|
|
|
vectorSize = nupvars * sizeof(script->upvars()->vector[0]);
|
2009-09-06 12:05:51 -07:00
|
|
|
memset(cursor, 0, vectorSize);
|
|
|
|
cursor += vectorSize;
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
/* Must go after other arrays; see constPadding definition. */
|
|
|
|
if (nconsts != 0) {
|
|
|
|
cursor += constPadding;
|
|
|
|
script->consts()->length = nconsts;
|
|
|
|
script->consts()->vector = (Value *)cursor;
|
|
|
|
JS_ASSERT((size_t)cursor % sizeof(double) == 0);
|
|
|
|
vectorSize = nconsts * sizeof(script->consts()->vector[0]);
|
|
|
|
memset(cursor, 0, vectorSize);
|
|
|
|
cursor += vectorSize;
|
|
|
|
}
|
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
script->code = script->main = (jsbytecode *)cursor;
|
|
|
|
JS_ASSERT(cursor +
|
|
|
|
length * sizeof(jsbytecode) +
|
|
|
|
nsrcnotes * sizeof(jssrcnote) ==
|
|
|
|
(uint8 *)script + size);
|
|
|
|
|
2010-09-29 23:17:29 -07:00
|
|
|
script->compartment = cx->compartment;
|
2008-02-07 15:18:45 -08:00
|
|
|
#ifdef CHECK_SCRIPT_OWNER
|
|
|
|
script->owner = cx->thread;
|
|
|
|
#endif
|
2010-08-05 17:15:49 -07:00
|
|
|
|
|
|
|
JS_APPEND_LINK(&script->links, &cx->compartment->scripts);
|
2007-03-22 10:30:00 -07:00
|
|
|
return script;
|
|
|
|
}
|
|
|
|
|
2007-11-29 06:49:42 -08:00
|
|
|
JSScript *
|
2010-09-13 22:33:44 -07:00
|
|
|
JSScript::NewScriptFromCG(JSContext *cx, JSCodeGenerator *cg)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2008-07-20 13:13:17 -07:00
|
|
|
uint32 mainLength, prologLength, nsrcnotes, nfixed;
|
2007-03-22 10:30:00 -07:00
|
|
|
JSScript *script;
|
|
|
|
const char *filename;
|
2008-03-29 03:34:29 -07:00
|
|
|
JSFunction *fun;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-07-08 02:03:34 -07:00
|
|
|
/* The counts of indexed things must be checked during code generation. */
|
|
|
|
JS_ASSERT(cg->atomList.count <= INDEX_LIMIT);
|
|
|
|
JS_ASSERT(cg->objectList.length <= INDEX_LIMIT);
|
|
|
|
JS_ASSERT(cg->regexpList.length <= INDEX_LIMIT);
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
mainLength = CG_OFFSET(cg);
|
|
|
|
prologLength = CG_PROLOG_OFFSET(cg);
|
2009-10-18 17:41:24 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
CG_COUNT_FINAL_SRCNOTES(cg, nsrcnotes);
|
2010-11-29 13:33:17 -08:00
|
|
|
uint16 nClosedArgs = uint16(cg->closedArgs.length());
|
|
|
|
JS_ASSERT(nClosedArgs == cg->closedArgs.length());
|
|
|
|
uint16 nClosedVars = uint16(cg->closedVars.length());
|
|
|
|
JS_ASSERT(nClosedVars == cg->closedVars.length());
|
2010-09-13 22:33:44 -07:00
|
|
|
script = NewScript(cx, prologLength + mainLength, nsrcnotes,
|
|
|
|
cg->atomList.count, cg->objectList.length,
|
|
|
|
cg->upvarList.count, cg->regexpList.length,
|
|
|
|
cg->ntrynotes, cg->constList.length(),
|
2010-11-29 13:33:17 -08:00
|
|
|
cg->globalUses.length(), nClosedArgs, nClosedVars);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!script)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Now that we have script, error control flow must go to label bad. */
|
|
|
|
script->main += prologLength;
|
|
|
|
memcpy(script->code, CG_PROLOG_BASE(cg), prologLength * sizeof(jsbytecode));
|
|
|
|
memcpy(script->main, CG_BASE(cg), mainLength * sizeof(jsbytecode));
|
2010-11-16 14:13:29 -08:00
|
|
|
nfixed = cg->inFunction()
|
|
|
|
? cg->fun()->u.i.nvars
|
2010-09-21 12:38:30 -07:00
|
|
|
: cg->sharpSlots();
|
2008-07-20 13:13:17 -07:00
|
|
|
JS_ASSERT(nfixed < SLOTNO_LIMIT);
|
|
|
|
script->nfixed = (uint16) nfixed;
|
2007-07-08 02:03:34 -07:00
|
|
|
js_InitAtomMap(cx, &script->atomMap, &cg->atomList);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-04-10 21:15:35 -07:00
|
|
|
filename = cg->parser->tokenStream.getFilename();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (filename) {
|
|
|
|
script->filename = js_SaveScriptFilename(cx, filename);
|
|
|
|
if (!script->filename)
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
script->lineno = cg->firstLine;
|
2008-08-21 03:47:33 -07:00
|
|
|
if (script->nfixed + cg->maxStackDepth >= JS_BIT(16)) {
|
2010-03-21 16:07:48 -07:00
|
|
|
ReportCompileErrorNumber(cx, CG_TS(cg), NULL, JSREPORT_ERROR, JSMSG_NEED_DIET, "script");
|
2008-08-21 03:47:33 -07:00
|
|
|
goto bad;
|
|
|
|
}
|
2008-07-20 13:13:17 -07:00
|
|
|
script->nslots = script->nfixed + cg->maxStackDepth;
|
2010-03-04 20:44:09 -08:00
|
|
|
script->staticLevel = uint16(cg->staticLevel);
|
2010-04-10 21:15:35 -07:00
|
|
|
script->principals = cg->parser->principals;
|
2007-10-02 16:10:09 -07:00
|
|
|
if (script->principals)
|
2007-03-22 10:30:00 -07:00
|
|
|
JSPRINCIPALS_HOLD(cx, script->principals);
|
|
|
|
|
2009-09-09 16:52:55 -07:00
|
|
|
if (!js_FinishTakingSrcNotes(cx, cg, script->notes()))
|
2007-03-22 10:30:00 -07:00
|
|
|
goto bad;
|
2007-07-08 02:03:34 -07:00
|
|
|
if (cg->ntrynotes != 0)
|
2009-09-09 16:52:55 -07:00
|
|
|
js_FinishTakingTryNotes(cg, script->trynotes());
|
2007-07-08 02:03:34 -07:00
|
|
|
if (cg->objectList.length != 0)
|
2009-09-09 16:52:55 -07:00
|
|
|
cg->objectList.finish(script->objects());
|
2007-07-08 02:03:34 -07:00
|
|
|
if (cg->regexpList.length != 0)
|
2009-09-09 16:52:55 -07:00
|
|
|
cg->regexpList.finish(script->regexps());
|
2010-07-14 23:19:36 -07:00
|
|
|
if (cg->constList.length() != 0)
|
|
|
|
cg->constList.finish(script->consts());
|
2009-04-05 21:17:22 -07:00
|
|
|
if (cg->flags & TCF_NO_SCRIPT_RVAL)
|
2009-10-08 10:29:03 -07:00
|
|
|
script->noScriptRval = true;
|
2009-09-09 20:21:15 -07:00
|
|
|
if (cg->hasSharps())
|
2009-10-08 10:29:03 -07:00
|
|
|
script->hasSharps = true;
|
2009-11-18 13:33:53 -08:00
|
|
|
if (cg->flags & TCF_STRICT_MODE_CODE)
|
|
|
|
script->strictModeCode = true;
|
2010-06-12 19:00:27 -07:00
|
|
|
if (cg->flags & TCF_COMPILE_N_GO)
|
|
|
|
script->compileAndGo = true;
|
2010-09-13 22:33:44 -07:00
|
|
|
if (cg->callsEval())
|
2010-06-18 11:07:15 -07:00
|
|
|
script->usesEval = true;
|
2010-09-13 22:33:44 -07:00
|
|
|
if (cg->flags & TCF_FUN_USES_ARGUMENTS)
|
|
|
|
script->usesArguments = true;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-08-21 03:47:33 -07:00
|
|
|
if (cg->upvarList.count != 0) {
|
|
|
|
JS_ASSERT(cg->upvarList.count <= cg->upvarMap.length);
|
2009-09-09 16:52:55 -07:00
|
|
|
memcpy(script->upvars()->vector, cg->upvarMap.vector,
|
2008-08-21 03:47:33 -07:00
|
|
|
cg->upvarList.count * sizeof(uint32));
|
2009-04-05 21:17:22 -07:00
|
|
|
cg->upvarList.clear();
|
2009-07-27 21:10:12 -07:00
|
|
|
cx->free(cg->upvarMap.vector);
|
2008-08-21 03:47:33 -07:00
|
|
|
cg->upvarMap.vector = NULL;
|
|
|
|
}
|
|
|
|
|
2010-05-22 15:38:04 -07:00
|
|
|
if (cg->globalUses.length()) {
|
|
|
|
memcpy(script->globals()->vector, &cg->globalUses[0],
|
|
|
|
cg->globalUses.length() * sizeof(GlobalSlotArray::Entry));
|
|
|
|
}
|
|
|
|
|
2010-09-13 22:33:44 -07:00
|
|
|
if (script->nClosedArgs)
|
|
|
|
memcpy(script->closedSlots, &cg->closedArgs[0], script->nClosedArgs * sizeof(uint32));
|
|
|
|
if (script->nClosedVars) {
|
|
|
|
memcpy(&script->closedSlots[script->nClosedArgs], &cg->closedVars[0],
|
|
|
|
script->nClosedVars * sizeof(uint32));
|
|
|
|
}
|
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
/*
|
|
|
|
* We initialize fun->u.script to be the script constructed above
|
|
|
|
* so that the debugger has a valid FUN_SCRIPT(fun).
|
|
|
|
*/
|
2008-03-28 15:27:36 -07:00
|
|
|
fun = NULL;
|
2010-11-16 14:13:29 -08:00
|
|
|
if (cg->inFunction()) {
|
|
|
|
fun = cg->fun();
|
2008-03-29 03:34:29 -07:00
|
|
|
JS_ASSERT(FUN_INTERPRETED(fun) && !FUN_SCRIPT(fun));
|
2009-10-18 17:41:24 -07:00
|
|
|
if (script->upvarsOffset != 0)
|
|
|
|
JS_ASSERT(script->upvars()->length == fun->u.i.nupvars);
|
|
|
|
else
|
|
|
|
fun->u.i.nupvars = 0;
|
2008-08-21 03:47:33 -07:00
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
fun->freezeLocalNames(cx);
|
2008-03-29 03:34:29 -07:00
|
|
|
fun->u.i.script = script;
|
2008-02-07 15:18:45 -08:00
|
|
|
#ifdef CHECK_SCRIPT_OWNER
|
|
|
|
script->owner = NULL;
|
|
|
|
#endif
|
2009-04-05 21:17:22 -07:00
|
|
|
if (cg->flags & TCF_FUN_HEAVYWEIGHT)
|
2008-03-28 15:27:36 -07:00
|
|
|
fun->flags |= JSFUN_HEAVYWEIGHT;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Tell the debugger about this compiled script. */
|
2008-03-28 15:27:36 -07:00
|
|
|
js_CallNewScriptHook(cx, script, fun);
|
2010-12-02 14:23:51 -08:00
|
|
|
#ifdef DEBUG
|
|
|
|
{
|
2010-11-16 15:30:56 -08:00
|
|
|
jsrefcount newEmptyLive, newLive, newTotal;
|
|
|
|
if (script->isEmpty()) {
|
|
|
|
newEmptyLive = JS_RUNTIME_METER(cx->runtime, liveEmptyScripts);
|
|
|
|
newLive = cx->runtime->liveScripts;
|
|
|
|
newTotal =
|
|
|
|
JS_RUNTIME_METER(cx->runtime, totalEmptyScripts) + cx->runtime->totalScripts;
|
|
|
|
} else {
|
|
|
|
newLive = JS_RUNTIME_METER(cx->runtime, liveScripts);
|
|
|
|
newEmptyLive = cx->runtime->liveEmptyScripts;
|
|
|
|
newTotal =
|
|
|
|
JS_RUNTIME_METER(cx->runtime, totalScripts) + cx->runtime->totalEmptyScripts;
|
|
|
|
}
|
|
|
|
|
2010-12-02 14:23:51 -08:00
|
|
|
jsrefcount oldHigh = cx->runtime->highWaterLiveScripts;
|
|
|
|
if (newEmptyLive + newLive > oldHigh) {
|
|
|
|
JS_ATOMIC_SET(&cx->runtime->highWaterLiveScripts, newEmptyLive + newLive);
|
|
|
|
if (getenv("JS_DUMP_LIVE_SCRIPTS")) {
|
|
|
|
fprintf(stderr, "high water script count: %d empty, %d not (total %d)\n",
|
|
|
|
newEmptyLive, newLive, newTotal);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
return script;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
js_DestroyScript(cx, script);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
JS_FRIEND_API(void)
|
|
|
|
js_CallNewScriptHook(JSContext *cx, JSScript *script, JSFunction *fun)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
JSNewScriptHook hook;
|
|
|
|
|
2007-06-14 23:44:18 -07:00
|
|
|
hook = cx->debugHooks->newScriptHook;
|
2007-03-22 10:30:00 -07:00
|
|
|
if (hook) {
|
2010-04-08 05:54:18 -07:00
|
|
|
AutoKeepAtoms keep(cx->runtime);
|
2008-03-29 03:34:29 -07:00
|
|
|
hook(cx, script->filename, script->lineno, script, fun,
|
2007-06-14 23:44:18 -07:00
|
|
|
cx->debugHooks->newScriptHookData);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
JS_FRIEND_API(void)
|
2007-03-22 10:30:00 -07:00
|
|
|
js_CallDestroyScriptHook(JSContext *cx, JSScript *script)
|
|
|
|
{
|
|
|
|
JSDestroyScriptHook hook;
|
|
|
|
|
2007-06-14 23:44:18 -07:00
|
|
|
hook = cx->debugHooks->destroyScriptHook;
|
2007-03-22 10:30:00 -07:00
|
|
|
if (hook)
|
2007-06-14 23:44:18 -07:00
|
|
|
hook(cx, script, cx->debugHooks->destroyScriptHookData);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-10-06 08:21:23 -07:00
|
|
|
static void
|
|
|
|
DestroyScript(JSContext *cx, JSScript *script, JSThreadData *data)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-12-02 14:23:51 -08:00
|
|
|
#ifdef DEBUG
|
2010-11-16 15:30:56 -08:00
|
|
|
if (script->isEmpty())
|
|
|
|
JS_RUNTIME_UNMETER(cx->runtime, liveEmptyScripts);
|
|
|
|
else
|
|
|
|
JS_RUNTIME_UNMETER(cx->runtime, liveScripts);
|
2010-12-02 14:23:51 -08:00
|
|
|
#endif
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
js_CallDestroyScriptHook(cx, script);
|
|
|
|
JS_ClearScriptTraps(cx, script);
|
2008-02-07 15:18:45 -08:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
if (script->principals)
|
|
|
|
JSPRINCIPALS_DROP(cx, script->principals);
|
2008-02-07 15:18:45 -08:00
|
|
|
|
2008-06-25 13:50:26 -07:00
|
|
|
if (JS_GSN_CACHE(cx).code == script->code)
|
2009-03-24 05:07:35 -07:00
|
|
|
JS_PURGE_GSN_CACHE(cx);
|
2008-02-07 15:18:45 -08:00
|
|
|
|
|
|
|
/*
|
2009-07-23 17:59:49 -07:00
|
|
|
* Worry about purging the property cache and any compiled traces related
|
|
|
|
* to its bytecode if this script is being destroyed from JS_DestroyScript
|
|
|
|
* or equivalent according to a mandatory "New/Destroy" protocol.
|
2008-02-07 15:18:45 -08:00
|
|
|
*
|
2009-07-24 06:55:28 -07:00
|
|
|
* The GC purges all property caches when regenerating shapes upon shape
|
|
|
|
* generator overflow, so no need in that event to purge just the entries
|
|
|
|
* for this script.
|
|
|
|
*
|
|
|
|
* The GC purges trace-JITted code on every GC activation, not just when
|
|
|
|
* regenerating shapes, so we don't have to purge fragments if the GC is
|
|
|
|
* currently running.
|
|
|
|
*
|
2010-03-24 19:20:44 -07:00
|
|
|
* JS_THREADSAFE note: The code below purges only the current thread's
|
|
|
|
* property cache, so a script not owned by a function or object, which
|
|
|
|
* hands off lifetime management for that script to the GC, must be used by
|
|
|
|
* only one thread over its lifetime.
|
2008-02-07 15:18:45 -08:00
|
|
|
*
|
|
|
|
* This should be an API-compatible change, since a script is never safe
|
|
|
|
* against premature GC if shared among threads without a rooted object
|
|
|
|
* wrapping it to protect the script's mapped atoms against GC. We use
|
|
|
|
* script->owner to enforce this requirement via assertions.
|
|
|
|
*/
|
|
|
|
#ifdef CHECK_SCRIPT_OWNER
|
|
|
|
JS_ASSERT_IF(cx->runtime->gcRunning, !script->owner);
|
|
|
|
#endif
|
|
|
|
|
2009-07-24 12:47:55 -07:00
|
|
|
/* FIXME: bug 506341; would like to do this only if regenerating shapes. */
|
|
|
|
if (!cx->runtime->gcRunning) {
|
2008-12-09 08:38:32 -08:00
|
|
|
JSStackFrame *fp = js_GetTopStackFrame(cx);
|
|
|
|
|
2010-08-09 22:43:33 -07:00
|
|
|
if (!(fp && fp->isEvalFrame())) {
|
2010-03-24 19:20:44 -07:00
|
|
|
JS_PROPERTY_CACHE(cx).purgeForScript(script);
|
2009-07-23 18:40:13 -07:00
|
|
|
|
2008-02-07 15:18:45 -08:00
|
|
|
#ifdef CHECK_SCRIPT_OWNER
|
2009-07-24 12:47:55 -07:00
|
|
|
JS_ASSERT(script->owner == cx->thread);
|
2009-02-09 16:58:39 -08:00
|
|
|
#endif
|
2008-06-03 23:52:28 -07:00
|
|
|
}
|
2008-06-02 18:06:33 -07:00
|
|
|
}
|
|
|
|
|
2009-08-17 14:50:57 -07:00
|
|
|
#ifdef JS_TRACER
|
2010-10-06 08:21:23 -07:00
|
|
|
# ifdef JS_THREADSAFE
|
|
|
|
if (data) {
|
|
|
|
PurgeScriptFragments(&data->traceMonitor, script);
|
|
|
|
} else {
|
|
|
|
for (ThreadDataIter i(cx->runtime); !i.empty(); i.popFront())
|
|
|
|
PurgeScriptFragments(&i.threadData()->traceMonitor, script);
|
|
|
|
}
|
|
|
|
# else
|
2010-11-18 10:51:56 -08:00
|
|
|
PurgeScriptFragments(&JS_TRACE_MONITOR(cx), script);
|
2010-10-06 08:21:23 -07:00
|
|
|
# endif
|
2009-08-17 14:50:57 -07:00
|
|
|
#endif
|
|
|
|
|
2010-05-22 17:45:52 -07:00
|
|
|
#if defined(JS_METHODJIT)
|
|
|
|
mjit::ReleaseScriptCode(cx, script);
|
|
|
|
#endif
|
2010-08-05 17:15:49 -07:00
|
|
|
JS_REMOVE_LINK(&script->links);
|
2010-05-22 17:45:52 -07:00
|
|
|
|
2009-07-27 21:10:12 -07:00
|
|
|
cx->free(script);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-10-06 08:21:23 -07:00
|
|
|
void
|
|
|
|
js_DestroyScript(JSContext *cx, JSScript *script)
|
|
|
|
{
|
|
|
|
JS_ASSERT(!cx->runtime->gcRunning);
|
|
|
|
DestroyScript(cx, script, JS_THREAD_DATA(cx));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
js_DestroyScriptFromGC(JSContext *cx, JSScript *script, JSThreadData *data)
|
|
|
|
{
|
|
|
|
JS_ASSERT(cx->runtime->gcRunning);
|
|
|
|
DestroyScript(cx, script, data);
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
void
|
2007-04-16 23:53:37 -07:00
|
|
|
js_TraceScript(JSTracer *trc, JSScript *script)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
JSAtomMap *map = &script->atomMap;
|
|
|
|
MarkAtomRange(trc, map->length, map->vector, "atomMap");
|
2007-07-08 02:03:34 -07:00
|
|
|
|
|
|
|
if (script->objectsOffset != 0) {
|
2010-07-14 23:19:36 -07:00
|
|
|
JSObjectArray *objarray = script->objects();
|
|
|
|
uintN i = objarray->length;
|
2007-07-08 02:03:34 -07:00
|
|
|
do {
|
|
|
|
--i;
|
2008-01-30 18:19:49 -08:00
|
|
|
if (objarray->vector[i]) {
|
|
|
|
JS_SET_TRACING_INDEX(trc, "objects", i);
|
2010-09-24 10:54:39 -07:00
|
|
|
Mark(trc, objarray->vector[i]);
|
2008-01-30 18:19:49 -08:00
|
|
|
}
|
2007-07-08 02:03:34 -07:00
|
|
|
} while (i != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (script->regexpsOffset != 0) {
|
2010-07-14 23:19:36 -07:00
|
|
|
JSObjectArray *objarray = script->regexps();
|
|
|
|
uintN i = objarray->length;
|
2007-07-08 02:03:34 -07:00
|
|
|
do {
|
|
|
|
--i;
|
2008-01-30 18:19:49 -08:00
|
|
|
if (objarray->vector[i]) {
|
|
|
|
JS_SET_TRACING_INDEX(trc, "regexps", i);
|
2010-09-24 10:54:39 -07:00
|
|
|
Mark(trc, objarray->vector[i]);
|
2008-01-30 18:19:49 -08:00
|
|
|
}
|
2007-07-08 02:03:34 -07:00
|
|
|
} while (i != 0);
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
if (script->constOffset != 0) {
|
|
|
|
JSConstArray *constarray = script->consts();
|
|
|
|
MarkValueRange(trc, constarray->length, constarray->vector, "consts");
|
|
|
|
}
|
|
|
|
|
2008-08-20 22:18:42 -07:00
|
|
|
if (script->u.object) {
|
2008-06-12 13:58:07 -07:00
|
|
|
JS_SET_TRACING_NAME(trc, "object");
|
2010-09-24 10:54:39 -07:00
|
|
|
Mark(trc, script->u.object);
|
2008-06-12 13:58:07 -07:00
|
|
|
}
|
|
|
|
|
2007-04-16 23:53:37 -07:00
|
|
|
if (IS_GC_MARKING_TRACER(trc) && script->filename)
|
2007-03-22 10:30:00 -07:00
|
|
|
js_MarkScriptFilename(script->filename);
|
|
|
|
}
|
|
|
|
|
2010-08-20 13:11:05 -07:00
|
|
|
JSBool
|
|
|
|
js_NewScriptObject(JSContext *cx, JSScript *script)
|
|
|
|
{
|
|
|
|
AutoScriptRooter root(cx, script);
|
|
|
|
|
|
|
|
JS_ASSERT(!script->u.object);
|
|
|
|
|
|
|
|
JSObject *obj = NewNonFunction<WithProto::Class>(cx, &js_ScriptClass, NULL, NULL);
|
|
|
|
if (!obj)
|
|
|
|
return JS_FALSE;
|
|
|
|
obj->setPrivate(script);
|
|
|
|
script->u.object = obj;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear the object's proto, to avoid entraining stuff. Once we no longer use the parent
|
|
|
|
* for security checks, then we can clear the parent, too.
|
|
|
|
*/
|
|
|
|
obj->clearProto();
|
|
|
|
|
|
|
|
#ifdef CHECK_SCRIPT_OWNER
|
|
|
|
script->owner = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
typedef struct GSNCacheEntry {
|
|
|
|
JSDHashEntryHdr hdr;
|
|
|
|
jsbytecode *pc;
|
|
|
|
jssrcnote *sn;
|
|
|
|
} GSNCacheEntry;
|
|
|
|
|
|
|
|
#define GSN_CACHE_THRESHOLD 100
|
|
|
|
|
2009-03-24 05:07:35 -07:00
|
|
|
void
|
|
|
|
js_PurgeGSNCache(JSGSNCache *cache)
|
|
|
|
{
|
|
|
|
cache->code = NULL;
|
|
|
|
if (cache->table.ops) {
|
|
|
|
JS_DHashTableFinish(&cache->table);
|
|
|
|
cache->table.ops = NULL;
|
|
|
|
}
|
|
|
|
GSN_CACHE_METER(cache, purges);
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
jssrcnote *
|
|
|
|
js_GetSrcNoteCached(JSContext *cx, JSScript *script, jsbytecode *pc)
|
|
|
|
{
|
|
|
|
ptrdiff_t target, offset;
|
|
|
|
GSNCacheEntry *entry;
|
|
|
|
jssrcnote *sn, *result;
|
|
|
|
uintN nsrcnotes;
|
|
|
|
|
|
|
|
|
2009-02-18 09:14:51 -08:00
|
|
|
target = pc - script->code;
|
2007-03-22 10:30:00 -07:00
|
|
|
if ((uint32)target >= script->length)
|
|
|
|
return NULL;
|
|
|
|
|
2008-06-25 13:50:26 -07:00
|
|
|
if (JS_GSN_CACHE(cx).code == script->code) {
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_METER_GSN_CACHE(cx, hits);
|
|
|
|
entry = (GSNCacheEntry *)
|
|
|
|
JS_DHashTableOperate(&JS_GSN_CACHE(cx).table, pc,
|
|
|
|
JS_DHASH_LOOKUP);
|
|
|
|
return entry->sn;
|
|
|
|
}
|
|
|
|
|
|
|
|
JS_METER_GSN_CACHE(cx, misses);
|
|
|
|
offset = 0;
|
2009-09-09 16:52:55 -07:00
|
|
|
for (sn = script->notes(); ; sn = SN_NEXT(sn)) {
|
2007-03-22 10:30:00 -07:00
|
|
|
if (SN_IS_TERMINATOR(sn)) {
|
|
|
|
result = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset += SN_DELTA(sn);
|
|
|
|
if (offset == target && SN_IS_GETTABLE(sn)) {
|
|
|
|
result = sn;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-25 13:50:26 -07:00
|
|
|
if (JS_GSN_CACHE(cx).code != script->code &&
|
2007-03-22 10:30:00 -07:00
|
|
|
script->length >= GSN_CACHE_THRESHOLD) {
|
2009-03-24 05:07:35 -07:00
|
|
|
JS_PURGE_GSN_CACHE(cx);
|
2007-03-22 10:30:00 -07:00
|
|
|
nsrcnotes = 0;
|
2009-09-09 16:52:55 -07:00
|
|
|
for (sn = script->notes(); !SN_IS_TERMINATOR(sn);
|
2007-03-22 10:30:00 -07:00
|
|
|
sn = SN_NEXT(sn)) {
|
|
|
|
if (SN_IS_GETTABLE(sn))
|
|
|
|
++nsrcnotes;
|
|
|
|
}
|
|
|
|
if (!JS_DHashTableInit(&JS_GSN_CACHE(cx).table, JS_DHashGetStubOps(),
|
|
|
|
NULL, sizeof(GSNCacheEntry),
|
|
|
|
JS_DHASH_DEFAULT_CAPACITY(nsrcnotes))) {
|
|
|
|
JS_GSN_CACHE(cx).table.ops = NULL;
|
|
|
|
} else {
|
|
|
|
pc = script->code;
|
2009-09-09 16:52:55 -07:00
|
|
|
for (sn = script->notes(); !SN_IS_TERMINATOR(sn);
|
2007-03-22 10:30:00 -07:00
|
|
|
sn = SN_NEXT(sn)) {
|
|
|
|
pc += SN_DELTA(sn);
|
|
|
|
if (SN_IS_GETTABLE(sn)) {
|
|
|
|
entry = (GSNCacheEntry *)
|
|
|
|
JS_DHashTableOperate(&JS_GSN_CACHE(cx).table, pc,
|
|
|
|
JS_DHASH_ADD);
|
|
|
|
entry->pc = pc;
|
|
|
|
entry->sn = sn;
|
|
|
|
}
|
|
|
|
}
|
2008-06-25 13:50:26 -07:00
|
|
|
JS_GSN_CACHE(cx).code = script->code;
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_METER_GSN_CACHE(cx, fills);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2008-11-13 00:30:20 -08:00
|
|
|
uintN
|
|
|
|
js_FramePCToLineNumber(JSContext *cx, JSStackFrame *fp)
|
|
|
|
{
|
2010-08-09 22:43:33 -07:00
|
|
|
return js_PCToLineNumber(cx, fp->script(),
|
|
|
|
fp->hasImacropc() ? fp->imacropc() : fp->pc(cx));
|
2008-11-13 00:30:20 -08:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
uintN
|
|
|
|
js_PCToLineNumber(JSContext *cx, JSScript *script, jsbytecode *pc)
|
|
|
|
{
|
2009-02-18 16:31:09 -08:00
|
|
|
JSOp op;
|
2008-03-29 03:34:29 -07:00
|
|
|
JSFunction *fun;
|
2007-03-22 10:30:00 -07:00
|
|
|
uintN lineno;
|
|
|
|
ptrdiff_t offset, target;
|
|
|
|
jssrcnote *sn;
|
|
|
|
JSSrcNoteType type;
|
|
|
|
|
|
|
|
/* Cope with JSStackFrame.pc value prior to entering js_Interpret. */
|
|
|
|
if (!pc)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Special case: function definition needs no line number note because
|
|
|
|
* the function's script contains its starting line number.
|
|
|
|
*/
|
2009-02-18 16:31:09 -08:00
|
|
|
op = js_GetOpcode(cx, script, pc);
|
|
|
|
if (js_CodeSpec[op].format & JOF_INDEXBASE)
|
|
|
|
pc += js_CodeSpec[op].length;
|
2007-03-22 10:30:00 -07:00
|
|
|
if (*pc == JSOP_DEFFUN) {
|
2008-04-02 00:46:12 -07:00
|
|
|
GET_FUNCTION_FROM_BYTECODE(script, pc, 0, fun);
|
2008-03-29 03:34:29 -07:00
|
|
|
return fun->u.i.script->lineno;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* General case: walk through source notes accumulating their deltas,
|
|
|
|
* keeping track of line-number notes, until we pass the note for pc's
|
|
|
|
* offset within script->code.
|
|
|
|
*/
|
|
|
|
lineno = script->lineno;
|
|
|
|
offset = 0;
|
2009-02-18 09:14:51 -08:00
|
|
|
target = pc - script->code;
|
2009-09-09 16:52:55 -07:00
|
|
|
for (sn = script->notes(); !SN_IS_TERMINATOR(sn); sn = SN_NEXT(sn)) {
|
2007-03-22 10:30:00 -07:00
|
|
|
offset += SN_DELTA(sn);
|
|
|
|
type = (JSSrcNoteType) SN_TYPE(sn);
|
|
|
|
if (type == SRC_SETLINE) {
|
|
|
|
if (offset <= target)
|
|
|
|
lineno = (uintN) js_GetSrcNoteOffset(sn, 0);
|
|
|
|
} else if (type == SRC_NEWLINE) {
|
|
|
|
if (offset <= target)
|
|
|
|
lineno++;
|
|
|
|
}
|
|
|
|
if (offset > target)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return lineno;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The line number limit is the same as the jssrcnote offset limit. */
|
|
|
|
#define SN_LINE_LIMIT (SN_3BYTE_OFFSET_FLAG << 16)
|
|
|
|
|
|
|
|
jsbytecode *
|
|
|
|
js_LineNumberToPC(JSScript *script, uintN target)
|
|
|
|
{
|
|
|
|
ptrdiff_t offset, best;
|
|
|
|
uintN lineno, bestdiff, diff;
|
|
|
|
jssrcnote *sn;
|
|
|
|
JSSrcNoteType type;
|
|
|
|
|
|
|
|
offset = 0;
|
|
|
|
best = -1;
|
|
|
|
lineno = script->lineno;
|
|
|
|
bestdiff = SN_LINE_LIMIT;
|
2009-09-09 16:52:55 -07:00
|
|
|
for (sn = script->notes(); !SN_IS_TERMINATOR(sn); sn = SN_NEXT(sn)) {
|
2007-04-02 11:13:22 -07:00
|
|
|
/*
|
|
|
|
* Exact-match only if offset is not in the prolog; otherwise use
|
|
|
|
* nearest greater-or-equal line number match.
|
|
|
|
*/
|
|
|
|
if (lineno == target && script->code + offset >= script->main)
|
2007-03-22 10:30:00 -07:00
|
|
|
goto out;
|
2007-04-02 11:13:22 -07:00
|
|
|
if (lineno >= target) {
|
2007-03-22 10:30:00 -07:00
|
|
|
diff = lineno - target;
|
|
|
|
if (diff < bestdiff) {
|
|
|
|
bestdiff = diff;
|
|
|
|
best = offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
offset += SN_DELTA(sn);
|
|
|
|
type = (JSSrcNoteType) SN_TYPE(sn);
|
|
|
|
if (type == SRC_SETLINE) {
|
|
|
|
lineno = (uintN) js_GetSrcNoteOffset(sn, 0);
|
|
|
|
} else if (type == SRC_NEWLINE) {
|
|
|
|
lineno++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (best >= 0)
|
|
|
|
offset = best;
|
|
|
|
out:
|
|
|
|
return script->code + offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
JS_FRIEND_API(uintN)
|
|
|
|
js_GetScriptLineExtent(JSScript *script)
|
|
|
|
{
|
|
|
|
uintN lineno;
|
|
|
|
jssrcnote *sn;
|
|
|
|
JSSrcNoteType type;
|
|
|
|
|
|
|
|
lineno = script->lineno;
|
2009-09-09 16:52:55 -07:00
|
|
|
for (sn = script->notes(); !SN_IS_TERMINATOR(sn); sn = SN_NEXT(sn)) {
|
2007-03-22 10:30:00 -07:00
|
|
|
type = (JSSrcNoteType) SN_TYPE(sn);
|
|
|
|
if (type == SRC_SETLINE) {
|
|
|
|
lineno = (uintN) js_GetSrcNoteOffset(sn, 0);
|
|
|
|
} else if (type == SRC_NEWLINE) {
|
|
|
|
lineno++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1 + lineno - script->lineno;
|
|
|
|
}
|
2010-08-24 19:57:35 -07:00
|
|
|
|
2010-09-29 23:17:29 -07:00
|
|
|
class DisablePrincipalsTranscoding {
|
|
|
|
JSSecurityCallbacks *callbacks;
|
|
|
|
JSPrincipalsTranscoder temp;
|
|
|
|
|
|
|
|
public:
|
2010-10-10 21:11:45 -07:00
|
|
|
DisablePrincipalsTranscoding(JSContext *cx)
|
|
|
|
: callbacks(JS_GetRuntimeSecurityCallbacks(cx->runtime)),
|
|
|
|
temp(NULL)
|
|
|
|
{
|
2010-09-29 23:17:29 -07:00
|
|
|
if (callbacks) {
|
|
|
|
temp = callbacks->principalsTranscoder;
|
|
|
|
callbacks->principalsTranscoder = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
~DisablePrincipalsTranscoding() {
|
|
|
|
if (callbacks)
|
|
|
|
callbacks->principalsTranscoder = temp;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
JSScript *
|
|
|
|
js_CloneScript(JSContext *cx, JSScript *script)
|
|
|
|
{
|
|
|
|
JS_ASSERT(cx->compartment != script->compartment);
|
|
|
|
JS_ASSERT(script->compartment);
|
|
|
|
|
|
|
|
// serialize script
|
|
|
|
JSXDRState *w = JS_XDRNewMem(cx, JSXDR_ENCODE);
|
|
|
|
if (!w)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
// we don't want gecko to transcribe our principals for us
|
|
|
|
DisablePrincipalsTranscoding disable(cx);
|
|
|
|
|
|
|
|
if (!JS_XDRScript(w, &script)) {
|
|
|
|
JS_XDRDestroy(w);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32 nbytes;
|
|
|
|
void *p = JS_XDRMemGetData(w, &nbytes);
|
|
|
|
if (!p) {
|
|
|
|
JS_XDRDestroy(w);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// de-serialize script
|
|
|
|
JSXDRState *r = JS_XDRNewMem(cx, JSXDR_DECODE);
|
|
|
|
if (!r) {
|
|
|
|
JS_XDRDestroy(w);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Hand p off from w to r. Don't want them to share the data
|
|
|
|
// mem, lest they both try to free it in JS_XDRDestroy
|
|
|
|
JS_XDRMemSetData(r, p, nbytes);
|
|
|
|
JS_XDRMemSetData(w, NULL, 0);
|
|
|
|
|
|
|
|
// We can't use the public API because it makes a script object.
|
2010-11-16 15:30:56 -08:00
|
|
|
if (!js_XDRScript(r, &script, NULL))
|
2010-09-29 23:17:29 -07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
JS_XDRDestroy(r);
|
|
|
|
JS_XDRDestroy(w);
|
|
|
|
|
|
|
|
// set the proper principals for the script
|
|
|
|
script->principals = script->compartment->principals;
|
|
|
|
if (script->principals)
|
|
|
|
JSPRINCIPALS_HOLD(cx, script->principals);
|
|
|
|
|
|
|
|
return script;
|
|
|
|
}
|
|
|
|
|
2010-09-13 22:33:44 -07:00
|
|
|
void
|
|
|
|
JSScript::copyClosedSlotsTo(JSScript *other)
|
|
|
|
{
|
|
|
|
memcpy(other->closedSlots, closedSlots, nClosedArgs + nClosedVars);
|
|
|
|
}
|