JavaScriptCore: Simplified the host calling convention.
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 29 May 2010 06:33:05 +0000 (06:33 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 29 May 2010 06:33:05 +0000 (06:33 +0000)
Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.

22.5% speedup on 32-bit host function calls. 9.5% speedup on 64-bit host
function calls.

No change on SunSpider.

All JS calls (but not constructs, yet) now go through the normal JS
calling convention via the RegisterFile. As a result, the host calling
convention, which used to be this

    JSValue (JSC_HOST_CALL *NativeFunction)(ExecState*, JSObject*, JSValue thisValue, const ArgList&)

is now this

    JSValue (JSC_HOST_CALL *NativeFunction)(ExecState*)

Callee, 'this', and argument access all hapen relative to the ExecState*,
which is a pointer into the RegisterFile.

This patch comes in two parts.

PART ONE: Functional code changes.

* wtf/Platform.h: Disabled optimized calls on platforms I didn't test.
We can re-enable once we verify that host calls on these platforms are
correct.

* debugger/DebuggerCallFrame.cpp:
(JSC::DebuggerCallFrame::functionName):
(JSC::DebuggerCallFrame::calculatedFunctionName): Updated for change to
ExecState::callee().

(JSC::DebuggerCallFrame::thisObject): Updated for removal of ExecState::thisValue().

* interpreter/CallFrame.cpp:
* interpreter/CallFrame.h:
(JSC::ExecState::callee):
(JSC::ExecState::scopeChain):
(JSC::ExecState::init): Changed callee() to be JSObject* instead of
JSFunction* -- now, it might be some other callable host object.

(JSC::ExecState::hostThisRegister):
(JSC::ExecState::hostThisValue):
(JSC::ExecState::argumentCount):
(JSC::ExecState::argumentCountIncludingThis):
(JSC::ExecState::argument):
(JSC::ExecState::setArgumentCountIncludingThis):
(JSC::ExecState::setCallee): Added convenient accessors for arguments
from within a host function. Removed thisValue() because it was too
tempting to use incorrectly, and it only had one or two clients, anyway.

* interpreter/Interpreter.cpp:
(JSC::Interpreter::callEval): Updated for removal of ExecState::thisValue().

(JSC::Interpreter::throwException): Be sure to shrink the register file
before invoking the exception handler, to reduce the chances that the
handler will re-throw in the case of stack overflow. (Re-throwing is now
more likely than it used to be, since standardizing the calling convention
implicitly added stack overflow checks to some places where they used to be missing.)

(JSC::Interpreter::execute): Clarified the scope of DynamicGlobalObjectScope.
Updated for CallFrame::init API change.

(JSC::Interpreter::executeCall): Clarified scope of DynamicGlobalObjectScope.
Updated for CallFrame::init API change. Added support for calling a host
function.

(JSC::Interpreter::executeConstruct): Clarified scope of DynamicGlobalObjectScope.
Updated for CallFrame::init API change.

(JSC::Interpreter::prepareForRepeatCall): Updated for CallFrame::init API change.

(JSC::Interpreter::privateExecute): Updated for CallFrame::init API change.
Added some explicit JSValue(JSObject*) initialization, since relaxing
the JSFunction* restriction on callee has made register types more ambiguous.
Removed toThisObject() conversion, since all callees do it themselves now.
Updated host function call for new host function signature. Updated for
change to ExecState::argumentCount() API.

* interpreter/Register.h:
(JSC::Register::):
(JSC::Register::operator=):
(JSC::Register::function): Changed callee() to be JSObject* instead of
JSFunction* -- now, it might be some other callable host object.

* jit/JITOpcodes.cpp:
(JSC::JIT::privateCompileCTINativeCall):
* jit/JITOpcodes32_64.cpp:
(JSC::JIT::privateCompileCTINativeCall): Deleted a bunch of code that
set up the arguments to host functions -- all but one of the arguments
are gone now. This is the actual optimization.

* jit/JITStubs.cpp:
(JSC::DEFINE_STUB_FUNCTION): Updated for ExecState and Register API
changes noted above. Removed toThisObject() conversion, since all callees
do it themselves now.

* runtime/ArgList.h:
(JSC::ArgList::ArgList): ArgList is getting close to unused. Added a
temporary shim for converting from ExecState* to ArgList where it's still
necessary.

* runtime/Arguments.h:
(JSC::Arguments::getArgumentsData):
(JSC::Arguments::Arguments): Updated for ExecState and Register API
changes noted above.

* runtime/CallData.cpp:
(JSC::call): Changed call always to call Interpreter::executeCall, even
for host functions. This ensures that the normal calling convention is
set up in the RegsiterFile when calling from C++ to host function.

* runtime/CallData.h: Changed host function signature as described above.

* runtime/ConstructData.cpp:
(JSC::construct): Moved JSFunction::construct code here so I could nix
JSFunction::call and JSFunction::call. We want a JSFunction-agnostic
way to call and construct, so that everything works naturally for non-
JSFunction objects.

* runtime/JSFunction.cpp:
(JSC::callHostFunctionAsConstructor):
* runtime/JSFunction.h: Updated for ExecState and Register API changes
noted above. Nixed JSFunction::call and JSFunction::construct, noted above.

* runtime/JSGlobalObject.cpp:
(JSC::JSGlobalObject::init): Ditto.

PART TWO: Global search and replace.

In the areas below, I used global search-and-replace to change
    (ExecState*, JSObject*, JSValue, const ArgList&) => (ExecState*)
    args.size() => exec->argumentCount()
    args.at(i) => exec->argument(i)

* API/JSCallbackFunction.cpp:
(JSC::JSCallbackFunction::call):
* API/JSCallbackFunction.h:
* API/JSCallbackObject.h:
* API/JSCallbackObjectFunctions.h:
(JSC::::call):
* JavaScriptCore.exp:
* jsc.cpp:
(functionPrint):
(functionDebug):
(functionGC):
(functionVersion):
(functionRun):
(functionLoad):
(functionCheckSyntax):
(functionSetSamplingFlags):
(functionClearSamplingFlags):
(functionReadline):
(functionQuit):
* runtime/ArrayConstructor.cpp:
(JSC::callArrayConstructor):
(JSC::arrayConstructorIsArray):
* runtime/ArrayPrototype.cpp:
(JSC::arrayProtoFuncToString):
(JSC::arrayProtoFuncToLocaleString):
(JSC::arrayProtoFuncJoin):
(JSC::arrayProtoFuncConcat):
(JSC::arrayProtoFuncPop):
(JSC::arrayProtoFuncPush):
(JSC::arrayProtoFuncReverse):
(JSC::arrayProtoFuncShift):
(JSC::arrayProtoFuncSlice):
(JSC::arrayProtoFuncSort):
(JSC::arrayProtoFuncSplice):
(JSC::arrayProtoFuncUnShift):
(JSC::arrayProtoFuncFilter):
(JSC::arrayProtoFuncMap):
(JSC::arrayProtoFuncEvery):
(JSC::arrayProtoFuncForEach):
(JSC::arrayProtoFuncSome):
(JSC::arrayProtoFuncReduce):
(JSC::arrayProtoFuncReduceRight):
(JSC::arrayProtoFuncIndexOf):
(JSC::arrayProtoFuncLastIndexOf):
* runtime/BooleanConstructor.cpp:
(JSC::callBooleanConstructor):
* runtime/BooleanPrototype.cpp:
(JSC::booleanProtoFuncToString):
(JSC::booleanProtoFuncValueOf):
* runtime/DateConstructor.cpp:
(JSC::callDate):
(JSC::dateParse):
(JSC::dateNow):
(JSC::dateUTC):
* runtime/DatePrototype.cpp:
(JSC::formatLocaleDate):
(JSC::fillStructuresUsingTimeArgs):
(JSC::fillStructuresUsingDateArgs):
(JSC::dateProtoFuncToString):
(JSC::dateProtoFuncToUTCString):
(JSC::dateProtoFuncToISOString):
(JSC::dateProtoFuncToDateString):
(JSC::dateProtoFuncToTimeString):
(JSC::dateProtoFuncToLocaleString):
(JSC::dateProtoFuncToLocaleDateString):
(JSC::dateProtoFuncToLocaleTimeString):
(JSC::dateProtoFuncGetTime):
(JSC::dateProtoFuncGetFullYear):
(JSC::dateProtoFuncGetUTCFullYear):
(JSC::dateProtoFuncToGMTString):
(JSC::dateProtoFuncGetMonth):
(JSC::dateProtoFuncGetUTCMonth):
(JSC::dateProtoFuncGetDate):
(JSC::dateProtoFuncGetUTCDate):
(JSC::dateProtoFuncGetDay):
(JSC::dateProtoFuncGetUTCDay):
(JSC::dateProtoFuncGetHours):
(JSC::dateProtoFuncGetUTCHours):
(JSC::dateProtoFuncGetMinutes):
(JSC::dateProtoFuncGetUTCMinutes):
(JSC::dateProtoFuncGetSeconds):
(JSC::dateProtoFuncGetUTCSeconds):
(JSC::dateProtoFuncGetMilliSeconds):
(JSC::dateProtoFuncGetUTCMilliseconds):
(JSC::dateProtoFuncGetTimezoneOffset):
(JSC::dateProtoFuncSetTime):
(JSC::setNewValueFromTimeArgs):
(JSC::setNewValueFromDateArgs):
(JSC::dateProtoFuncSetMilliSeconds):
(JSC::dateProtoFuncSetUTCMilliseconds):
(JSC::dateProtoFuncSetSeconds):
(JSC::dateProtoFuncSetUTCSeconds):
(JSC::dateProtoFuncSetMinutes):
(JSC::dateProtoFuncSetUTCMinutes):
(JSC::dateProtoFuncSetHours):
(JSC::dateProtoFuncSetUTCHours):
(JSC::dateProtoFuncSetDate):
(JSC::dateProtoFuncSetUTCDate):
(JSC::dateProtoFuncSetMonth):
(JSC::dateProtoFuncSetUTCMonth):
(JSC::dateProtoFuncSetFullYear):
(JSC::dateProtoFuncSetUTCFullYear):
(JSC::dateProtoFuncSetYear):
(JSC::dateProtoFuncGetYear):
(JSC::dateProtoFuncToJSON):
* runtime/ErrorConstructor.cpp:
(JSC::callErrorConstructor):
* runtime/ErrorPrototype.cpp:
(JSC::errorProtoFuncToString):
* runtime/FunctionConstructor.cpp:
(JSC::callFunctionConstructor):
* runtime/FunctionPrototype.cpp:
(JSC::callFunctionPrototype):
(JSC::functionProtoFuncToString):
(JSC::functionProtoFuncApply):
(JSC::functionProtoFuncCall):
* runtime/JSGlobalObjectFunctions.cpp:
(JSC::encode):
(JSC::decode):
(JSC::globalFuncEval):
(JSC::globalFuncParseInt):
(JSC::globalFuncParseFloat):
(JSC::globalFuncIsNaN):
(JSC::globalFuncIsFinite):
(JSC::globalFuncDecodeURI):
(JSC::globalFuncDecodeURIComponent):
(JSC::globalFuncEncodeURI):
(JSC::globalFuncEncodeURIComponent):
(JSC::globalFuncEscape):
(JSC::globalFuncUnescape):
(JSC::globalFuncJSCPrint):
* runtime/JSGlobalObjectFunctions.h:
* runtime/JSONObject.cpp:
(JSC::JSONProtoFuncParse):
(JSC::JSONProtoFuncStringify):
* runtime/JSString.h:
* runtime/MathObject.cpp:
(JSC::mathProtoFuncAbs):
(JSC::mathProtoFuncACos):
(JSC::mathProtoFuncASin):
(JSC::mathProtoFuncATan):
(JSC::mathProtoFuncATan2):
(JSC::mathProtoFuncCeil):
(JSC::mathProtoFuncCos):
(JSC::mathProtoFuncExp):
(JSC::mathProtoFuncFloor):
(JSC::mathProtoFuncLog):
(JSC::mathProtoFuncMax):
(JSC::mathProtoFuncMin):
(JSC::mathProtoFuncPow):
(JSC::mathProtoFuncRandom):
(JSC::mathProtoFuncRound):
(JSC::mathProtoFuncSin):
(JSC::mathProtoFuncSqrt):
(JSC::mathProtoFuncTan):
* runtime/NativeErrorConstructor.cpp:
(JSC::callNativeErrorConstructor):
* runtime/NumberConstructor.cpp:
(JSC::callNumberConstructor):
* runtime/NumberPrototype.cpp:
(JSC::numberProtoFuncToString):
(JSC::numberProtoFuncToLocaleString):
(JSC::numberProtoFuncValueOf):
(JSC::numberProtoFuncToFixed):
(JSC::numberProtoFuncToExponential):
(JSC::numberProtoFuncToPrecision):
* runtime/ObjectConstructor.cpp:
(JSC::callObjectConstructor):
(JSC::objectConstructorGetPrototypeOf):
(JSC::objectConstructorGetOwnPropertyDescriptor):
(JSC::objectConstructorGetOwnPropertyNames):
(JSC::objectConstructorKeys):
(JSC::objectConstructorDefineProperty):
(JSC::objectConstructorDefineProperties):
(JSC::objectConstructorCreate):
* runtime/ObjectPrototype.cpp:
(JSC::objectProtoFuncValueOf):
(JSC::objectProtoFuncHasOwnProperty):
(JSC::objectProtoFuncIsPrototypeOf):
(JSC::objectProtoFuncDefineGetter):
(JSC::objectProtoFuncDefineSetter):
(JSC::objectProtoFuncLookupGetter):
(JSC::objectProtoFuncLookupSetter):
(JSC::objectProtoFuncPropertyIsEnumerable):
(JSC::objectProtoFuncToLocaleString):
(JSC::objectProtoFuncToString):
* runtime/ObjectPrototype.h:
* runtime/Operations.h:
(JSC::jsString):
* runtime/RegExpConstructor.cpp:
(JSC::callRegExpConstructor):
* runtime/RegExpObject.cpp:
(JSC::RegExpObject::test):
(JSC::RegExpObject::exec):
(JSC::callRegExpObject):
(JSC::RegExpObject::match):
* runtime/RegExpObject.h:
* runtime/RegExpPrototype.cpp:
(JSC::regExpProtoFuncTest):
(JSC::regExpProtoFuncExec):
(JSC::regExpProtoFuncCompile):
(JSC::regExpProtoFuncToString):
* runtime/StringConstructor.cpp:
(JSC::stringFromCharCodeSlowCase):
(JSC::stringFromCharCode):
(JSC::callStringConstructor):
* runtime/StringPrototype.cpp:
(JSC::stringProtoFuncReplace):
(JSC::stringProtoFuncToString):
(JSC::stringProtoFuncCharAt):
(JSC::stringProtoFuncCharCodeAt):
(JSC::stringProtoFuncConcat):
(JSC::stringProtoFuncIndexOf):
(JSC::stringProtoFuncLastIndexOf):
(JSC::stringProtoFuncMatch):
(JSC::stringProtoFuncSearch):
(JSC::stringProtoFuncSlice):
(JSC::stringProtoFuncSplit):
(JSC::stringProtoFuncSubstr):
(JSC::stringProtoFuncSubstring):
(JSC::stringProtoFuncToLowerCase):
(JSC::stringProtoFuncToUpperCase):
(JSC::stringProtoFuncLocaleCompare):
(JSC::stringProtoFuncBig):
(JSC::stringProtoFuncSmall):
(JSC::stringProtoFuncBlink):
(JSC::stringProtoFuncBold):
(JSC::stringProtoFuncFixed):
(JSC::stringProtoFuncItalics):
(JSC::stringProtoFuncStrike):
(JSC::stringProtoFuncSub):
(JSC::stringProtoFuncSup):
(JSC::stringProtoFuncFontcolor):
(JSC::stringProtoFuncFontsize):
(JSC::stringProtoFuncAnchor):
(JSC::stringProtoFuncLink):
(JSC::stringProtoFuncTrim):
(JSC::stringProtoFuncTrimLeft):
(JSC::stringProtoFuncTrimRight):

JavaScriptGlue: Simplified the host calling convention.

Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.

PART ONE: Functional code changes.

[ None in JavaScriptGlue ]

PART TWO: Global search and replace.

In the areas below, I used global search-and-replace to change
    (ExecState*, JSObject*, JSValue, const ArgList&) => (ExecState*)
    args.size() => exec->argumentCount()
    args.at(i) => exec->argument(i)

* JSObject.cpp:
(nativeCallFunction):
* UserObjectImp.cpp:
(UserObjectImp::callAsFunction):
* UserObjectImp.h:

WebCore: Simplified the host calling convention.

Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.

PART ONE: Functional code changes.

[ None in WebCore ]

PART TWO: Global search and replace.

In the areas below, I used global search-and-replace to change
    (ExecState*, JSObject*, JSValue, const ArgList&) => (ExecState*)
    args.size() => exec->argumentCount()
    args.at(i) => exec->argument(i)

* bindings/js/JSArrayBufferViewCustom.cpp:
(WebCore::JSArrayBufferView::slice):
* bindings/js/JSArrayBufferViewHelper.h:
(WebCore::setWebGLArrayHelper):
* bindings/js/JSCanvasRenderingContext2DCustom.cpp:
(WebCore::JSCanvasRenderingContext2D::setFillColor):
(WebCore::JSCanvasRenderingContext2D::setStrokeColor):
(WebCore::JSCanvasRenderingContext2D::strokeRect):
(WebCore::JSCanvasRenderingContext2D::drawImage):
(WebCore::JSCanvasRenderingContext2D::drawImageFromRect):
(WebCore::JSCanvasRenderingContext2D::setShadow):
(WebCore::JSCanvasRenderingContext2D::createPattern):
(WebCore::JSCanvasRenderingContext2D::createImageData):
(WebCore::JSCanvasRenderingContext2D::putImageData):
(WebCore::JSCanvasRenderingContext2D::fillText):
(WebCore::JSCanvasRenderingContext2D::strokeText):
* bindings/js/JSClipboardCustom.cpp:
(WebCore::JSClipboard::clearData):
(WebCore::JSClipboard::getData):
(WebCore::JSClipboard::setDragImage):
* bindings/js/JSDOMApplicationCacheCustom.cpp:
(WebCore::JSDOMApplicationCache::hasItem):
(WebCore::JSDOMApplicationCache::add):
(WebCore::JSDOMApplicationCache::remove):
* bindings/js/JSDOMFormDataCustom.cpp:
(WebCore::JSDOMFormData::append):
* bindings/js/JSDOMWindowCustom.cpp:
(WebCore::JSDOMWindow::open):
(WebCore::JSDOMWindow::showModalDialog):
(WebCore::JSDOMWindow::postMessage):
(WebCore::JSDOMWindow::setTimeout):
(WebCore::JSDOMWindow::setInterval):
(WebCore::JSDOMWindow::addEventListener):
(WebCore::JSDOMWindow::removeEventListener):
(WebCore::JSDOMWindow::openDatabase):
* bindings/js/JSDatabaseCustom.cpp:
(WebCore::JSDatabase::changeVersion):
(WebCore::createTransaction):
(WebCore::JSDatabase::transaction):
(WebCore::JSDatabase::readTransaction):
* bindings/js/JSDatabaseSyncCustom.cpp:
(WebCore::JSDatabaseSync::changeVersion):
(WebCore::createTransaction):
(WebCore::JSDatabaseSync::transaction):
(WebCore::JSDatabaseSync::readTransaction):
* bindings/js/JSDedicatedWorkerContextCustom.cpp:
(WebCore::JSDedicatedWorkerContext::postMessage):
* bindings/js/JSDesktopNotificationsCustom.cpp:
(WebCore::JSNotificationCenter::requestPermission):
* bindings/js/JSFloatArrayCustom.cpp:
(WebCore::JSFloatArray::set):
* bindings/js/JSGeolocationCustom.cpp:
(WebCore::JSGeolocation::getCurrentPosition):
(WebCore::JSGeolocation::watchPosition):
* bindings/js/JSHTMLAllCollectionCustom.cpp:
(WebCore::callHTMLAllCollection):
(WebCore::JSHTMLAllCollection::item):
(WebCore::JSHTMLAllCollection::namedItem):
* bindings/js/JSHTMLCanvasElementCustom.cpp:
(WebCore::JSHTMLCanvasElement::getContext):
* bindings/js/JSHTMLCollectionCustom.cpp:
(WebCore::callHTMLCollection):
(WebCore::JSHTMLCollection::item):
(WebCore::JSHTMLCollection::namedItem):
* bindings/js/JSHTMLDocumentCustom.cpp:
(WebCore::JSHTMLDocument::open):
(WebCore::documentWrite):
(WebCore::JSHTMLDocument::write):
(WebCore::JSHTMLDocument::writeln):
* bindings/js/JSHTMLInputElementCustom.cpp:
(WebCore::JSHTMLInputElement::setSelectionRange):
* bindings/js/JSHTMLOptionsCollectionCustom.cpp:
(WebCore::JSHTMLOptionsCollection::add):
(WebCore::JSHTMLOptionsCollection::remove):
* bindings/js/JSHTMLSelectElementCustom.cpp:
(WebCore::JSHTMLSelectElement::remove):
* bindings/js/JSHistoryCustom.cpp:
(WebCore::JSHistory::pushState):
(WebCore::JSHistory::replaceState):
* bindings/js/JSInjectedScriptHostCustom.cpp:
(WebCore::JSInjectedScriptHost::databaseForId):
(WebCore::JSInjectedScriptHost::currentCallFrame):
(WebCore::JSInjectedScriptHost::nodeForId):
(WebCore::JSInjectedScriptHost::pushNodePathToFrontend):
(WebCore::JSInjectedScriptHost::selectDatabase):
(WebCore::JSInjectedScriptHost::selectDOMStorage):
(WebCore::JSInjectedScriptHost::reportDidDispatchOnInjectedScript):
* bindings/js/JSInspectorFrontendHostCustom.cpp:
(WebCore::JSInspectorFrontendHost::platform):
(WebCore::JSInspectorFrontendHost::port):
(WebCore::JSInspectorFrontendHost::showContextMenu):
* bindings/js/JSInt16ArrayCustom.cpp:
(WebCore::JSInt16Array::set):
* bindings/js/JSInt32ArrayCustom.cpp:
(WebCore::JSInt32Array::set):
* bindings/js/JSInt8ArrayCustom.cpp:
(WebCore::JSInt8Array::set):
* bindings/js/JSJavaScriptCallFrameCustom.cpp:
(WebCore::JSJavaScriptCallFrame::evaluate):
(WebCore::JSJavaScriptCallFrame::scopeType):
* bindings/js/JSLocationCustom.cpp:
(WebCore::JSLocation::replace):
(WebCore::JSLocation::reload):
(WebCore::JSLocation::assign):
(WebCore::JSLocation::toString):
* bindings/js/JSMessageEventCustom.cpp:
(WebCore::JSMessageEvent::initMessageEvent):
* bindings/js/JSMessagePortCustom.cpp:
(WebCore::JSMessagePort::postMessage):
* bindings/js/JSMessagePortCustom.h:
(WebCore::handlePostMessage):
* bindings/js/JSNodeCustom.cpp:
(WebCore::JSNode::insertBefore):
(WebCore::JSNode::replaceChild):
(WebCore::JSNode::removeChild):
(WebCore::JSNode::appendChild):
* bindings/js/JSNodeListCustom.cpp:
(WebCore::callNodeList):
* bindings/js/JSPluginElementFunctions.cpp:
(WebCore::callPlugin):
* bindings/js/JSSQLResultSetRowListCustom.cpp:
(WebCore::JSSQLResultSetRowList::item):
* bindings/js/JSSQLTransactionCustom.cpp:
(WebCore::JSSQLTransaction::executeSql):
* bindings/js/JSSQLTransactionSyncCustom.cpp:
(WebCore::JSSQLTransactionSync::executeSql):
* bindings/js/JSSVGLengthCustom.cpp:
(WebCore::JSSVGLength::convertToSpecifiedUnits):
* bindings/js/JSSVGMatrixCustom.cpp:
(WebCore::JSSVGMatrix::multiply):
(WebCore::JSSVGMatrix::inverse):
(WebCore::JSSVGMatrix::rotateFromVector):
* bindings/js/JSSVGPODListCustom.h:
(WebCore::JSSVGPODListCustom::clear):
(WebCore::JSSVGPODListCustom::initialize):
(WebCore::JSSVGPODListCustom::getItem):
(WebCore::JSSVGPODListCustom::insertItemBefore):
(WebCore::JSSVGPODListCustom::replaceItem):
(WebCore::JSSVGPODListCustom::removeItem):
(WebCore::JSSVGPODListCustom::appendItem):
* bindings/js/JSSVGPathSegListCustom.cpp:
(WebCore::JSSVGPathSegList::clear):
(WebCore::JSSVGPathSegList::initialize):
(WebCore::JSSVGPathSegList::getItem):
(WebCore::JSSVGPathSegList::insertItemBefore):
(WebCore::JSSVGPathSegList::replaceItem):
(WebCore::JSSVGPathSegList::removeItem):
(WebCore::JSSVGPathSegList::appendItem):
* bindings/js/JSUint16ArrayCustom.cpp:
(WebCore::JSUint16Array::set):
* bindings/js/JSUint32ArrayCustom.cpp:
(WebCore::JSUint32Array::set):
* bindings/js/JSUint8ArrayCustom.cpp:
(WebCore::JSUint8Array::set):
* bindings/js/JSWebGLRenderingContextCustom.cpp:
(WebCore::JSWebGLRenderingContext::bufferData):
(WebCore::JSWebGLRenderingContext::bufferSubData):
(WebCore::getObjectParameter):
(WebCore::JSWebGLRenderingContext::getBufferParameter):
(WebCore::JSWebGLRenderingContext::getFramebufferAttachmentParameter):
(WebCore::JSWebGLRenderingContext::getParameter):
(WebCore::JSWebGLRenderingContext::getProgramParameter):
(WebCore::JSWebGLRenderingContext::getRenderbufferParameter):
(WebCore::JSWebGLRenderingContext::getShaderParameter):
(WebCore::JSWebGLRenderingContext::getTexParameter):
(WebCore::JSWebGLRenderingContext::getUniform):
(WebCore::JSWebGLRenderingContext::getVertexAttrib):
(WebCore::JSWebGLRenderingContext::texImage2D):
(WebCore::JSWebGLRenderingContext::texSubImage2D):
(WebCore::dataFunctionf):
(WebCore::dataFunctioni):
(WebCore::dataFunctionMatrix):
(WebCore::JSWebGLRenderingContext::uniform1fv):
(WebCore::JSWebGLRenderingContext::uniform1iv):
(WebCore::JSWebGLRenderingContext::uniform2fv):
(WebCore::JSWebGLRenderingContext::uniform2iv):
(WebCore::JSWebGLRenderingContext::uniform3fv):
(WebCore::JSWebGLRenderingContext::uniform3iv):
(WebCore::JSWebGLRenderingContext::uniform4fv):
(WebCore::JSWebGLRenderingContext::uniform4iv):
(WebCore::JSWebGLRenderingContext::uniformMatrix2fv):
(WebCore::JSWebGLRenderingContext::uniformMatrix3fv):
(WebCore::JSWebGLRenderingContext::uniformMatrix4fv):
(WebCore::JSWebGLRenderingContext::vertexAttrib1fv):
(WebCore::JSWebGLRenderingContext::vertexAttrib2fv):
(WebCore::JSWebGLRenderingContext::vertexAttrib3fv):
(WebCore::JSWebGLRenderingContext::vertexAttrib4fv):
* bindings/js/JSWebSocketCustom.cpp:
(WebCore::JSWebSocket::send):
* bindings/js/JSWorkerContextCustom.cpp:
(WebCore::JSWorkerContext::importScripts):
(WebCore::JSWorkerContext::setTimeout):
(WebCore::JSWorkerContext::setInterval):
(WebCore::JSWorkerContext::openDatabase):
(WebCore::JSWorkerContext::openDatabaseSync):
* bindings/js/JSWorkerCustom.cpp:
(WebCore::JSWorker::postMessage):
* bindings/js/JSXMLHttpRequestCustom.cpp:
(WebCore::JSXMLHttpRequest::open):
(WebCore::JSXMLHttpRequest::send):
* bindings/js/JSXSLTProcessorCustom.cpp:
(WebCore::JSXSLTProcessor::importStylesheet):
(WebCore::JSXSLTProcessor::transformToFragment):
(WebCore::JSXSLTProcessor::transformToDocument):
(WebCore::JSXSLTProcessor::setParameter):
(WebCore::JSXSLTProcessor::getParameter):
(WebCore::JSXSLTProcessor::removeParameter):
* bindings/js/ScheduledAction.cpp:
(WebCore::ScheduledAction::create):
(WebCore::ScheduledAction::ScheduledAction):
* bindings/js/ScheduledAction.h:
* bindings/js/ScriptCallFrame.cpp:
(WebCore::ScriptCallFrame::ScriptCallFrame):
* bindings/js/ScriptCallFrame.h:
* bindings/js/ScriptCallStack.cpp:
(WebCore::ScriptCallStack::ScriptCallStack):
(WebCore::ScriptCallStack::initialize):
* bindings/js/ScriptCallStack.h:
* bindings/scripts/CodeGeneratorJS.pm:
* bridge/c/c_instance.cpp:
(JSC::Bindings::CInstance::invokeMethod):
(JSC::Bindings::CInstance::invokeDefaultMethod):
* bridge/c/c_instance.h:
* bridge/jni/jsc/JavaInstanceJSC.cpp:
(JavaInstance::invokeMethod):
* bridge/jni/jsc/JavaInstanceJSC.h:
* bridge/jsc/BridgeJSC.h:
(JSC::Bindings::Instance::invokeDefaultMethod):
* bridge/objc/objc_instance.h:
* bridge/objc/objc_instance.mm:
(ObjcInstance::invokeMethod):
(ObjcInstance::invokeObjcMethod):
(ObjcInstance::invokeDefaultMethod):
* bridge/objc/objc_runtime.mm:
(JSC::Bindings::callObjCFallbackObject):
* bridge/runtime_method.cpp:
(JSC::callRuntimeMethod):
* bridge/runtime_object.cpp:
(JSC::Bindings::callRuntimeObject):

WebKit/mac: Simplified the host calling convention.

Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.

PART ONE: Functional code changes.

[ None in WebKit ]

PART TWO: Global search and replace.

In the areas below, I used global search-and-replace to change
    (ExecState*, JSObject*, JSValue, const ArgList&) => (ExecState*)
    args.size() => exec->argumentCount()
    args.at(i) => exec->argument(i)

* Plugins/Hosted/ProxyInstance.h:
* Plugins/Hosted/ProxyInstance.mm:
(WebKit::ProxyInstance::invoke):
(WebKit::ProxyInstance::invokeMethod):
(WebKit::ProxyInstance::invokeDefaultMethod):

LayoutTests: Simplified the host calling convention.

Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.

Changed these results to expect to fail to stringify their exception
objects in the case of stack overflow. (Standardizing the calling
convention has implicitly added stack overflow checks to some places
where they used to be missing.)

In a future patch, I plan to implement a more reliable way to stringify
exceptions without invoking a JS function. For now, though, it seems best
to match other test results, instead of silently overflowing the stack.

* fast/js/global-recursion-on-full-stack-expected.txt:
* fast/xmlhttprequest/xmlhttprequest-recursive-sync-event-expected.txt:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@60392 268f45cc-cd09-0410-ab3c-d52691b4dbfc

132 files changed:
JavaScriptCore/API/JSCallbackFunction.cpp
JavaScriptCore/API/JSCallbackFunction.h
JavaScriptCore/API/JSCallbackObject.h
JavaScriptCore/API/JSCallbackObjectFunctions.h
JavaScriptCore/ChangeLog
JavaScriptCore/JavaScriptCore.exp
JavaScriptCore/debugger/DebuggerCallFrame.cpp
JavaScriptCore/interpreter/CallFrame.cpp
JavaScriptCore/interpreter/CallFrame.h
JavaScriptCore/interpreter/Interpreter.cpp
JavaScriptCore/interpreter/Interpreter.h
JavaScriptCore/interpreter/Register.h
JavaScriptCore/jit/JITOpcodes.cpp
JavaScriptCore/jit/JITOpcodes32_64.cpp
JavaScriptCore/jit/JITStubs.cpp
JavaScriptCore/jsc.cpp
JavaScriptCore/runtime/ArgList.h
JavaScriptCore/runtime/Arguments.h
JavaScriptCore/runtime/ArrayConstructor.cpp
JavaScriptCore/runtime/ArrayPrototype.cpp
JavaScriptCore/runtime/BooleanConstructor.cpp
JavaScriptCore/runtime/BooleanPrototype.cpp
JavaScriptCore/runtime/CallData.cpp
JavaScriptCore/runtime/CallData.h
JavaScriptCore/runtime/ConstructData.cpp
JavaScriptCore/runtime/DateConstructor.cpp
JavaScriptCore/runtime/DatePrototype.cpp
JavaScriptCore/runtime/ErrorConstructor.cpp
JavaScriptCore/runtime/ErrorPrototype.cpp
JavaScriptCore/runtime/FunctionConstructor.cpp
JavaScriptCore/runtime/FunctionPrototype.cpp
JavaScriptCore/runtime/JSFunction.cpp
JavaScriptCore/runtime/JSFunction.h
JavaScriptCore/runtime/JSGlobalObject.cpp
JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
JavaScriptCore/runtime/JSGlobalObjectFunctions.h
JavaScriptCore/runtime/JSONObject.cpp
JavaScriptCore/runtime/JSString.h
JavaScriptCore/runtime/MathObject.cpp
JavaScriptCore/runtime/NativeErrorConstructor.cpp
JavaScriptCore/runtime/NumberConstructor.cpp
JavaScriptCore/runtime/NumberPrototype.cpp
JavaScriptCore/runtime/ObjectConstructor.cpp
JavaScriptCore/runtime/ObjectPrototype.cpp
JavaScriptCore/runtime/ObjectPrototype.h
JavaScriptCore/runtime/Operations.h
JavaScriptCore/runtime/PropertySlot.cpp
JavaScriptCore/runtime/RegExpConstructor.cpp
JavaScriptCore/runtime/RegExpObject.cpp
JavaScriptCore/runtime/RegExpObject.h
JavaScriptCore/runtime/RegExpPrototype.cpp
JavaScriptCore/runtime/StringConstructor.cpp
JavaScriptCore/runtime/StringPrototype.cpp
JavaScriptCore/wtf/Platform.h
JavaScriptGlue/ChangeLog
JavaScriptGlue/JSObject.cpp
JavaScriptGlue/UserObjectImp.cpp
JavaScriptGlue/UserObjectImp.h
LayoutTests/ChangeLog
LayoutTests/fast/js/global-recursion-on-full-stack-expected.txt
LayoutTests/fast/xmlhttprequest/xmlhttprequest-recursive-sync-event-expected.txt
WebCore/ChangeLog
WebCore/bindings/js/JSArrayBufferViewCustom.cpp
WebCore/bindings/js/JSArrayBufferViewHelper.h
WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
WebCore/bindings/js/JSClipboardCustom.cpp
WebCore/bindings/js/JSDOMApplicationCacheCustom.cpp
WebCore/bindings/js/JSDOMFormDataCustom.cpp
WebCore/bindings/js/JSDOMWindowCustom.cpp
WebCore/bindings/js/JSDatabaseCustom.cpp
WebCore/bindings/js/JSDatabaseSyncCustom.cpp
WebCore/bindings/js/JSDedicatedWorkerContextCustom.cpp
WebCore/bindings/js/JSDesktopNotificationsCustom.cpp
WebCore/bindings/js/JSFloatArrayCustom.cpp
WebCore/bindings/js/JSGeolocationCustom.cpp
WebCore/bindings/js/JSHTMLAllCollectionCustom.cpp
WebCore/bindings/js/JSHTMLCanvasElementCustom.cpp
WebCore/bindings/js/JSHTMLCollectionCustom.cpp
WebCore/bindings/js/JSHTMLDocumentCustom.cpp
WebCore/bindings/js/JSHTMLInputElementCustom.cpp
WebCore/bindings/js/JSHTMLOptionsCollectionCustom.cpp
WebCore/bindings/js/JSHTMLSelectElementCustom.cpp
WebCore/bindings/js/JSHistoryCustom.cpp
WebCore/bindings/js/JSInjectedScriptHostCustom.cpp
WebCore/bindings/js/JSInspectorFrontendHostCustom.cpp
WebCore/bindings/js/JSInt16ArrayCustom.cpp
WebCore/bindings/js/JSInt32ArrayCustom.cpp
WebCore/bindings/js/JSInt8ArrayCustom.cpp
WebCore/bindings/js/JSJavaScriptCallFrameCustom.cpp
WebCore/bindings/js/JSLocationCustom.cpp
WebCore/bindings/js/JSMessageEventCustom.cpp
WebCore/bindings/js/JSMessagePortCustom.cpp
WebCore/bindings/js/JSMessagePortCustom.h
WebCore/bindings/js/JSNodeCustom.cpp
WebCore/bindings/js/JSNodeListCustom.cpp
WebCore/bindings/js/JSPluginElementFunctions.cpp
WebCore/bindings/js/JSSQLResultSetRowListCustom.cpp
WebCore/bindings/js/JSSQLTransactionCustom.cpp
WebCore/bindings/js/JSSQLTransactionSyncCustom.cpp
WebCore/bindings/js/JSSVGLengthCustom.cpp
WebCore/bindings/js/JSSVGMatrixCustom.cpp
WebCore/bindings/js/JSSVGPODListCustom.h
WebCore/bindings/js/JSSVGPathSegListCustom.cpp
WebCore/bindings/js/JSUint16ArrayCustom.cpp
WebCore/bindings/js/JSUint32ArrayCustom.cpp
WebCore/bindings/js/JSUint8ArrayCustom.cpp
WebCore/bindings/js/JSWebGLRenderingContextCustom.cpp
WebCore/bindings/js/JSWebSocketCustom.cpp
WebCore/bindings/js/JSWorkerContextCustom.cpp
WebCore/bindings/js/JSWorkerCustom.cpp
WebCore/bindings/js/JSXMLHttpRequestCustom.cpp
WebCore/bindings/js/JSXSLTProcessorCustom.cpp
WebCore/bindings/js/ScheduledAction.cpp
WebCore/bindings/js/ScheduledAction.h
WebCore/bindings/js/ScriptCallFrame.cpp
WebCore/bindings/js/ScriptCallFrame.h
WebCore/bindings/js/ScriptCallStack.cpp
WebCore/bindings/js/ScriptCallStack.h
WebCore/bindings/scripts/CodeGeneratorJS.pm
WebCore/bridge/c/c_instance.cpp
WebCore/bridge/c/c_instance.h
WebCore/bridge/jni/jsc/JavaInstanceJSC.cpp
WebCore/bridge/jni/jsc/JavaInstanceJSC.h
WebCore/bridge/jsc/BridgeJSC.h
WebCore/bridge/objc/objc_instance.h
WebCore/bridge/objc/objc_instance.mm
WebCore/bridge/objc/objc_runtime.mm
WebCore/bridge/runtime_method.cpp
WebCore/bridge/runtime_object.cpp
WebKit/mac/ChangeLog
WebKit/mac/Plugins/Hosted/ProxyInstance.h
WebKit/mac/Plugins/Hosted/ProxyInstance.mm

index 4953010..9db9983 100644 (file)
@@ -47,22 +47,22 @@ JSCallbackFunction::JSCallbackFunction(ExecState* exec, JSGlobalObject* globalOb
 {
 }
 
-JSValue JSCallbackFunction::call(ExecState* exec, JSObject* functionObject, JSValue thisValue, const ArgList& args)
+JSValue JSCallbackFunction::call(ExecState* exec)
 {
     JSContextRef execRef = toRef(exec);
-    JSObjectRef functionRef = toRef(functionObject);
-    JSObjectRef thisObjRef = toRef(thisValue.toThisObject(exec));
+    JSObjectRef functionRef = toRef(exec->callee());
+    JSObjectRef thisObjRef = toRef(exec->hostThisValue().toThisObject(exec));
 
-    int argumentCount = static_cast<int>(args.size());
+    int argumentCount = static_cast<int>(exec->argumentCount());
     Vector<JSValueRef, 16> arguments(argumentCount);
     for (int i = 0; i < argumentCount; i++)
-        arguments[i] = toRef(exec, args.at(i));
+        arguments[i] = toRef(exec, exec->argument(i));
 
     JSValueRef exception = 0;
     JSValueRef result;
     {
         APICallbackShim callbackShim(exec);
-        result = static_cast<JSCallbackFunction*>(functionObject)->m_callback(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception);
+        result = static_cast<JSCallbackFunction*>(toJS(functionRef))->m_callback(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception);
     }
     if (exception)
         exec->setException(toJS(exec, exception));
index b0dc425..3940e7d 100644 (file)
@@ -48,7 +48,7 @@ private:
     virtual CallType getCallData(CallData&);
     virtual const ClassInfo* classInfo() const { return &info; }
 
-    static JSValue JSC_HOST_CALL call(ExecState*, JSObject*, JSValue, const ArgList&);
+    static JSValue JSC_HOST_CALL call(ExecState*);
 
     JSObjectCallAsFunctionCallback m_callback;
 };
index 0660b45..7216ac5 100644 (file)
@@ -182,7 +182,7 @@ private:
  
     static JSCallbackObject* asCallbackObject(JSValue);
  
-    static JSValue JSC_HOST_CALL call(ExecState*, JSObject* functionObject, JSValue thisValue, const ArgList&);
+    static JSValue JSC_HOST_CALL call(ExecState*);
     static JSObject* construct(ExecState*, JSObject* constructor, const ArgList&);
    
     static JSValue staticValueGetter(ExecState*, JSValue, const Identifier&);
index 6573ed9..ef1efd2 100644 (file)
@@ -29,6 +29,7 @@
 #include "Error.h"
 #include "JSCallbackFunction.h"
 #include "JSClassRef.h"
+#include "JSFunction.h"
 #include "JSGlobalObject.h"
 #include "JSLock.h"
 #include "JSObjectRef.h"
@@ -370,18 +371,18 @@ CallType JSCallbackObject<Base>::getCallData(CallData& callData)
 }
 
 template <class Base>
-JSValue JSCallbackObject<Base>::call(ExecState* exec, JSObject* functionObject, JSValue thisValue, const ArgList& args)
+JSValue JSCallbackObject<Base>::call(ExecState* exec)
 {
     JSContextRef execRef = toRef(exec);
-    JSObjectRef functionRef = toRef(functionObject);
-    JSObjectRef thisObjRef = toRef(thisValue.toThisObject(exec));
+    JSObjectRef functionRef = toRef(exec->callee());
+    JSObjectRef thisObjRef = toRef(exec->hostThisValue().toThisObject(exec));
     
-    for (JSClassRef jsClass = static_cast<JSCallbackObject<Base>*>(functionObject)->classRef(); jsClass; jsClass = jsClass->parentClass) {
+    for (JSClassRef jsClass = static_cast<JSCallbackObject<Base>*>(toJS(functionRef))->classRef(); jsClass; jsClass = jsClass->parentClass) {
         if (JSObjectCallAsFunctionCallback callAsFunction = jsClass->callAsFunction) {
-            int argumentCount = static_cast<int>(args.size());
+            int argumentCount = static_cast<int>(exec->argumentCount());
             Vector<JSValueRef, 16> arguments(argumentCount);
             for (int i = 0; i < argumentCount; i++)
-                arguments[i] = toRef(exec, args.at(i));
+                arguments[i] = toRef(exec, exec->argument(i));
             JSValueRef exception = 0;
             JSValue result;
             {
index 5f251e6..d57a570 100644 (file)
@@ -1,3 +1,383 @@
+2010-05-28  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.
+
+        Simplified the host calling convention.
+        
+        22.5% speedup on 32-bit host function calls. 9.5% speedup on 64-bit host
+        function calls.
+        
+        No change on SunSpider.
+        
+        All JS calls (but not constructs, yet) now go through the normal JS
+        calling convention via the RegisterFile. As a result, the host calling
+        convention, which used to be this
+
+            JSValue (JSC_HOST_CALL *NativeFunction)(ExecState*, JSObject*, JSValue thisValue, const ArgList&)
+            
+        is now this
+
+            JSValue (JSC_HOST_CALL *NativeFunction)(ExecState*)
+            
+        Callee, 'this', and argument access all hapen relative to the ExecState*,
+        which is a pointer into the RegisterFile.
+        
+        This patch comes in two parts.
+        
+        PART ONE: Functional code changes.
+        
+        * wtf/Platform.h: Disabled optimized calls on platforms I didn't test.
+        We can re-enable once we verify that host calls on these platforms are
+        correct.
+
+        * debugger/DebuggerCallFrame.cpp:
+        (JSC::DebuggerCallFrame::functionName):
+        (JSC::DebuggerCallFrame::calculatedFunctionName): Updated for change to
+        ExecState::callee().
+
+        (JSC::DebuggerCallFrame::thisObject): Updated for removal of ExecState::thisValue().
+
+        * interpreter/CallFrame.cpp:
+        * interpreter/CallFrame.h:
+        (JSC::ExecState::callee):
+        (JSC::ExecState::scopeChain):
+        (JSC::ExecState::init): Changed callee() to be JSObject* instead of
+        JSFunction* -- now, it might be some other callable host object.
+
+        (JSC::ExecState::hostThisRegister):
+        (JSC::ExecState::hostThisValue):
+        (JSC::ExecState::argumentCount):
+        (JSC::ExecState::argumentCountIncludingThis):
+        (JSC::ExecState::argument):
+        (JSC::ExecState::setArgumentCountIncludingThis):
+        (JSC::ExecState::setCallee): Added convenient accessors for arguments
+        from within a host function. Removed thisValue() because it was too
+        tempting to use incorrectly, and it only had one or two clients, anyway.
+
+        * interpreter/Interpreter.cpp:
+        (JSC::Interpreter::callEval): Updated for removal of ExecState::thisValue().
+
+        (JSC::Interpreter::throwException): Be sure to shrink the register file
+        before invoking the exception handler, to reduce the chances that the
+        handler will re-throw in the case of stack overflow. (Re-throwing is now
+        more likely than it used to be, since standardizing the calling convention
+        implicitly added stack overflow checks to some places where they used to be missing.)
+
+        (JSC::Interpreter::execute): Clarified the scope of DynamicGlobalObjectScope.
+        Updated for CallFrame::init API change.
+
+        (JSC::Interpreter::executeCall): Clarified scope of DynamicGlobalObjectScope.
+        Updated for CallFrame::init API change. Added support for calling a host
+        function.
+
+        (JSC::Interpreter::executeConstruct): Clarified scope of DynamicGlobalObjectScope.
+        Updated for CallFrame::init API change. 
+
+        (JSC::Interpreter::prepareForRepeatCall): Updated for CallFrame::init API change. 
+
+        (JSC::Interpreter::privateExecute): Updated for CallFrame::init API change.
+        Added some explicit JSValue(JSObject*) initialization, since relaxing
+        the JSFunction* restriction on callee has made register types more ambiguous.
+        Removed toThisObject() conversion, since all callees do it themselves now.
+        Updated host function call for new host function signature. Updated for
+        change to ExecState::argumentCount() API.
+
+        * interpreter/Register.h:
+        (JSC::Register::):
+        (JSC::Register::operator=):
+        (JSC::Register::function): Changed callee() to be JSObject* instead of
+        JSFunction* -- now, it might be some other callable host object.
+
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::privateCompileCTINativeCall):
+        * jit/JITOpcodes32_64.cpp:
+        (JSC::JIT::privateCompileCTINativeCall): Deleted a bunch of code that
+        set up the arguments to host functions -- all but one of the arguments
+        are gone now. This is the actual optimization.
+
+        * jit/JITStubs.cpp:
+        (JSC::DEFINE_STUB_FUNCTION): Updated for ExecState and Register API
+        changes noted above. Removed toThisObject() conversion, since all callees
+        do it themselves now.
+        
+        * runtime/ArgList.h:
+        (JSC::ArgList::ArgList): ArgList is getting close to unused. Added a
+        temporary shim for converting from ExecState* to ArgList where it's still
+        necessary.
+
+        * runtime/Arguments.h:
+        (JSC::Arguments::getArgumentsData):
+        (JSC::Arguments::Arguments): Updated for ExecState and Register API
+        changes noted above. 
+
+        * runtime/CallData.cpp:
+        (JSC::call): Changed call always to call Interpreter::executeCall, even
+        for host functions. This ensures that the normal calling convention is
+        set up in the RegsiterFile when calling from C++ to host function.
+
+        * runtime/CallData.h: Changed host function signature as described above.
+
+        * runtime/ConstructData.cpp:
+        (JSC::construct): Moved JSFunction::construct code here so I could nix
+        JSFunction::call and JSFunction::call. We want a JSFunction-agnostic
+        way to call and construct, so that everything works naturally for non-
+        JSFunction objects. 
+
+        * runtime/JSFunction.cpp:
+        (JSC::callHostFunctionAsConstructor):
+        * runtime/JSFunction.h: Updated for ExecState and Register API changes
+        noted above. Nixed JSFunction::call and JSFunction::construct, noted above.
+        * runtime/JSGlobalObject.cpp:
+        (JSC::JSGlobalObject::init): Ditto.
+
+        PART TWO: Global search and replace.
+        
+        In the areas below, I used global search-and-replace to change
+            (ExecState*, JSObject*, JSValue, const ArgList&) => (ExecState*)
+            args.size() => exec->argumentCount()
+            args.at(i) => exec->argument(i)
+
+        * API/JSCallbackFunction.cpp:
+        (JSC::JSCallbackFunction::call):
+        * API/JSCallbackFunction.h:
+        * API/JSCallbackObject.h:
+        * API/JSCallbackObjectFunctions.h:
+        (JSC::::call):
+        * JavaScriptCore.exp:
+        * jsc.cpp:
+        (functionPrint):
+        (functionDebug):
+        (functionGC):
+        (functionVersion):
+        (functionRun):
+        (functionLoad):
+        (functionCheckSyntax):
+        (functionSetSamplingFlags):
+        (functionClearSamplingFlags):
+        (functionReadline):
+        (functionQuit):
+        * runtime/ArrayConstructor.cpp:
+        (JSC::callArrayConstructor):
+        (JSC::arrayConstructorIsArray):
+        * runtime/ArrayPrototype.cpp:
+        (JSC::arrayProtoFuncToString):
+        (JSC::arrayProtoFuncToLocaleString):
+        (JSC::arrayProtoFuncJoin):
+        (JSC::arrayProtoFuncConcat):
+        (JSC::arrayProtoFuncPop):
+        (JSC::arrayProtoFuncPush):
+        (JSC::arrayProtoFuncReverse):
+        (JSC::arrayProtoFuncShift):
+        (JSC::arrayProtoFuncSlice):
+        (JSC::arrayProtoFuncSort):
+        (JSC::arrayProtoFuncSplice):
+        (JSC::arrayProtoFuncUnShift):
+        (JSC::arrayProtoFuncFilter):
+        (JSC::arrayProtoFuncMap):
+        (JSC::arrayProtoFuncEvery):
+        (JSC::arrayProtoFuncForEach):
+        (JSC::arrayProtoFuncSome):
+        (JSC::arrayProtoFuncReduce):
+        (JSC::arrayProtoFuncReduceRight):
+        (JSC::arrayProtoFuncIndexOf):
+        (JSC::arrayProtoFuncLastIndexOf):
+        * runtime/BooleanConstructor.cpp:
+        (JSC::callBooleanConstructor):
+        * runtime/BooleanPrototype.cpp:
+        (JSC::booleanProtoFuncToString):
+        (JSC::booleanProtoFuncValueOf):
+        * runtime/DateConstructor.cpp:
+        (JSC::callDate):
+        (JSC::dateParse):
+        (JSC::dateNow):
+        (JSC::dateUTC):
+        * runtime/DatePrototype.cpp:
+        (JSC::formatLocaleDate):
+        (JSC::fillStructuresUsingTimeArgs):
+        (JSC::fillStructuresUsingDateArgs):
+        (JSC::dateProtoFuncToString):
+        (JSC::dateProtoFuncToUTCString):
+        (JSC::dateProtoFuncToISOString):
+        (JSC::dateProtoFuncToDateString):
+        (JSC::dateProtoFuncToTimeString):
+        (JSC::dateProtoFuncToLocaleString):
+        (JSC::dateProtoFuncToLocaleDateString):
+        (JSC::dateProtoFuncToLocaleTimeString):
+        (JSC::dateProtoFuncGetTime):
+        (JSC::dateProtoFuncGetFullYear):
+        (JSC::dateProtoFuncGetUTCFullYear):
+        (JSC::dateProtoFuncToGMTString):
+        (JSC::dateProtoFuncGetMonth):
+        (JSC::dateProtoFuncGetUTCMonth):
+        (JSC::dateProtoFuncGetDate):
+        (JSC::dateProtoFuncGetUTCDate):
+        (JSC::dateProtoFuncGetDay):
+        (JSC::dateProtoFuncGetUTCDay):
+        (JSC::dateProtoFuncGetHours):
+        (JSC::dateProtoFuncGetUTCHours):
+        (JSC::dateProtoFuncGetMinutes):
+        (JSC::dateProtoFuncGetUTCMinutes):
+        (JSC::dateProtoFuncGetSeconds):
+        (JSC::dateProtoFuncGetUTCSeconds):
+        (JSC::dateProtoFuncGetMilliSeconds):
+        (JSC::dateProtoFuncGetUTCMilliseconds):
+        (JSC::dateProtoFuncGetTimezoneOffset):
+        (JSC::dateProtoFuncSetTime):
+        (JSC::setNewValueFromTimeArgs):
+        (JSC::setNewValueFromDateArgs):
+        (JSC::dateProtoFuncSetMilliSeconds):
+        (JSC::dateProtoFuncSetUTCMilliseconds):
+        (JSC::dateProtoFuncSetSeconds):
+        (JSC::dateProtoFuncSetUTCSeconds):
+        (JSC::dateProtoFuncSetMinutes):
+        (JSC::dateProtoFuncSetUTCMinutes):
+        (JSC::dateProtoFuncSetHours):
+        (JSC::dateProtoFuncSetUTCHours):
+        (JSC::dateProtoFuncSetDate):
+        (JSC::dateProtoFuncSetUTCDate):
+        (JSC::dateProtoFuncSetMonth):
+        (JSC::dateProtoFuncSetUTCMonth):
+        (JSC::dateProtoFuncSetFullYear):
+        (JSC::dateProtoFuncSetUTCFullYear):
+        (JSC::dateProtoFuncSetYear):
+        (JSC::dateProtoFuncGetYear):
+        (JSC::dateProtoFuncToJSON):
+        * runtime/ErrorConstructor.cpp:
+        (JSC::callErrorConstructor):
+        * runtime/ErrorPrototype.cpp:
+        (JSC::errorProtoFuncToString):
+        * runtime/FunctionConstructor.cpp:
+        (JSC::callFunctionConstructor):
+        * runtime/FunctionPrototype.cpp:
+        (JSC::callFunctionPrototype):
+        (JSC::functionProtoFuncToString):
+        (JSC::functionProtoFuncApply):
+        (JSC::functionProtoFuncCall):
+        * runtime/JSGlobalObjectFunctions.cpp:
+        (JSC::encode):
+        (JSC::decode):
+        (JSC::globalFuncEval):
+        (JSC::globalFuncParseInt):
+        (JSC::globalFuncParseFloat):
+        (JSC::globalFuncIsNaN):
+        (JSC::globalFuncIsFinite):
+        (JSC::globalFuncDecodeURI):
+        (JSC::globalFuncDecodeURIComponent):
+        (JSC::globalFuncEncodeURI):
+        (JSC::globalFuncEncodeURIComponent):
+        (JSC::globalFuncEscape):
+        (JSC::globalFuncUnescape):
+        (JSC::globalFuncJSCPrint):
+        * runtime/JSGlobalObjectFunctions.h:
+        * runtime/JSONObject.cpp:
+        (JSC::JSONProtoFuncParse):
+        (JSC::JSONProtoFuncStringify):
+        * runtime/JSString.h:
+        * runtime/MathObject.cpp:
+        (JSC::mathProtoFuncAbs):
+        (JSC::mathProtoFuncACos):
+        (JSC::mathProtoFuncASin):
+        (JSC::mathProtoFuncATan):
+        (JSC::mathProtoFuncATan2):
+        (JSC::mathProtoFuncCeil):
+        (JSC::mathProtoFuncCos):
+        (JSC::mathProtoFuncExp):
+        (JSC::mathProtoFuncFloor):
+        (JSC::mathProtoFuncLog):
+        (JSC::mathProtoFuncMax):
+        (JSC::mathProtoFuncMin):
+        (JSC::mathProtoFuncPow):
+        (JSC::mathProtoFuncRandom):
+        (JSC::mathProtoFuncRound):
+        (JSC::mathProtoFuncSin):
+        (JSC::mathProtoFuncSqrt):
+        (JSC::mathProtoFuncTan):
+        * runtime/NativeErrorConstructor.cpp:
+        (JSC::callNativeErrorConstructor):
+        * runtime/NumberConstructor.cpp:
+        (JSC::callNumberConstructor):
+        * runtime/NumberPrototype.cpp:
+        (JSC::numberProtoFuncToString):
+        (JSC::numberProtoFuncToLocaleString):
+        (JSC::numberProtoFuncValueOf):
+        (JSC::numberProtoFuncToFixed):
+        (JSC::numberProtoFuncToExponential):
+        (JSC::numberProtoFuncToPrecision):
+        * runtime/ObjectConstructor.cpp:
+        (JSC::callObjectConstructor):
+        (JSC::objectConstructorGetPrototypeOf):
+        (JSC::objectConstructorGetOwnPropertyDescriptor):
+        (JSC::objectConstructorGetOwnPropertyNames):
+        (JSC::objectConstructorKeys):
+        (JSC::objectConstructorDefineProperty):
+        (JSC::objectConstructorDefineProperties):
+        (JSC::objectConstructorCreate):
+        * runtime/ObjectPrototype.cpp:
+        (JSC::objectProtoFuncValueOf):
+        (JSC::objectProtoFuncHasOwnProperty):
+        (JSC::objectProtoFuncIsPrototypeOf):
+        (JSC::objectProtoFuncDefineGetter):
+        (JSC::objectProtoFuncDefineSetter):
+        (JSC::objectProtoFuncLookupGetter):
+        (JSC::objectProtoFuncLookupSetter):
+        (JSC::objectProtoFuncPropertyIsEnumerable):
+        (JSC::objectProtoFuncToLocaleString):
+        (JSC::objectProtoFuncToString):
+        * runtime/ObjectPrototype.h:
+        * runtime/Operations.h:
+        (JSC::jsString):
+        * runtime/RegExpConstructor.cpp:
+        (JSC::callRegExpConstructor):
+        * runtime/RegExpObject.cpp:
+        (JSC::RegExpObject::test):
+        (JSC::RegExpObject::exec):
+        (JSC::callRegExpObject):
+        (JSC::RegExpObject::match):
+        * runtime/RegExpObject.h:
+        * runtime/RegExpPrototype.cpp:
+        (JSC::regExpProtoFuncTest):
+        (JSC::regExpProtoFuncExec):
+        (JSC::regExpProtoFuncCompile):
+        (JSC::regExpProtoFuncToString):
+        * runtime/StringConstructor.cpp:
+        (JSC::stringFromCharCodeSlowCase):
+        (JSC::stringFromCharCode):
+        (JSC::callStringConstructor):
+        * runtime/StringPrototype.cpp:
+        (JSC::stringProtoFuncReplace):
+        (JSC::stringProtoFuncToString):
+        (JSC::stringProtoFuncCharAt):
+        (JSC::stringProtoFuncCharCodeAt):
+        (JSC::stringProtoFuncConcat):
+        (JSC::stringProtoFuncIndexOf):
+        (JSC::stringProtoFuncLastIndexOf):
+        (JSC::stringProtoFuncMatch):
+        (JSC::stringProtoFuncSearch):
+        (JSC::stringProtoFuncSlice):
+        (JSC::stringProtoFuncSplit):
+        (JSC::stringProtoFuncSubstr):
+        (JSC::stringProtoFuncSubstring):
+        (JSC::stringProtoFuncToLowerCase):
+        (JSC::stringProtoFuncToUpperCase):
+        (JSC::stringProtoFuncLocaleCompare):
+        (JSC::stringProtoFuncBig):
+        (JSC::stringProtoFuncSmall):
+        (JSC::stringProtoFuncBlink):
+        (JSC::stringProtoFuncBold):
+        (JSC::stringProtoFuncFixed):
+        (JSC::stringProtoFuncItalics):
+        (JSC::stringProtoFuncStrike):
+        (JSC::stringProtoFuncSub):
+        (JSC::stringProtoFuncSup):
+        (JSC::stringProtoFuncFontcolor):
+        (JSC::stringProtoFuncFontsize):
+        (JSC::stringProtoFuncAnchor):
+        (JSC::stringProtoFuncLink):
+        (JSC::stringProtoFuncTrim):
+        (JSC::stringProtoFuncTrimLeft):
+        (JSC::stringProtoFuncTrimRight):
+
 2010-05-28  Jedrzej Nowacki  <jedrzej.nowacki@nokia.com>
 
         Reviewed by Geoffrey Garen.
index e14af7f..3985d4e 100644 (file)
@@ -109,7 +109,7 @@ __ZN3JSC10Identifier4fromEPNS_9ExecStateEj
 __ZN3JSC10Identifier5equalEPKN7WebCore10StringImplEPKc
 __ZN3JSC10JSFunction4infoE
 __ZN3JSC10JSFunction4nameEPNS_9ExecStateE
-__ZN3JSC10JSFunctionC1EPNS_9ExecStateEPNS_14JSGlobalObjectEN3WTF17NonNullPassRefPtrINS_9StructureEEEiRKNS_10IdentifierEPFNS_7JSValueES2_PNS_8JSObjectESC_RKNS_7ArgListEE
+__ZN3JSC10JSFunctionC1EPNS_9ExecStateEPNS_14JSGlobalObjectEN3WTF17NonNullPassRefPtrINS_9StructureEEEiRKNS_10IdentifierEPFNS_7JSValueES2_E
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeE
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeEPKc
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeERKNS_7UStringE
@@ -174,7 +174,7 @@ __ZN3JSC16JSVariableObject19getOwnPropertyNamesEPNS_9ExecStateERNS_17PropertyNam
 __ZN3JSC16toUInt32SlowCaseEdRb
 __ZN3JSC17BytecodeGenerator21setDumpsGeneratedCodeEb
 __ZN3JSC17PropertyNameArray3addEPN7WebCore10StringImplE
-__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEPNS_14JSGlobalObjectEN3WTF17NonNullPassRefPtrINS_9StructureEEEiRKNS_10IdentifierEPFNS_7JSValueES2_PNS_8JSObjectESC_RKNS_7ArgListEE
+__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEPNS_14JSGlobalObjectEN3WTF17NonNullPassRefPtrINS_9StructureEEEiRKNS_10IdentifierEPFNS_7JSValueES2_E
 __ZN3JSC17constructFunctionEPNS_9ExecStateERKNS_7ArgListERKNS_10IdentifierERKNS_7UStringEi
 __ZN3JSC18DebuggerActivationC1EPNS_8JSObjectE
 __ZN3JSC18PropertyDescriptor11setWritableEb
@@ -189,10 +189,11 @@ __ZN3JSC18PropertyDescriptor9setSetterENS_7JSValueE
 __ZN3JSC19initializeThreadingEv
 __ZN3JSC20MarkedArgumentBuffer10slowAppendENS_7JSValueE
 __ZN3JSC23AbstractSamplingCounter4dumpEv
-__ZN3JSC23objectProtoFuncToStringEPNS_9ExecStateEPNS_8JSObjectENS_7JSValueERKNS_7ArgListE
+__ZN3JSC23objectProtoFuncToStringEPNS_9ExecStateE
 __ZN3JSC23setUpStaticFunctionSlotEPNS_9ExecStateEPKNS_9HashEntryEPNS_8JSObjectERKNS_10IdentifierERNS_12PropertySlotE
 __ZN3JSC24JSObjectWithGlobalObjectC2EPNS_14JSGlobalObjectEN3WTF17NonNullPassRefPtrINS_9StructureEEE
 __ZN3JSC24createStackOverflowErrorEPNS_9ExecStateE
+__ZN3JSC24createStackOverflowErrorEPNS_9ExecStateE
 __ZN3JSC25evaluateInGlobalCallFrameERKNS_7UStringERNS_7JSValueEPNS_14JSGlobalObjectE
 __ZN3JSC35createInterruptedExecutionExceptionEPNS_12JSGlobalDataE
 __ZN3JSC3NaNE
index a734b1d..da9cb52 100644 (file)
@@ -44,10 +44,10 @@ const UString* DebuggerCallFrame::functionName() const
     if (!m_callFrame->callee())
         return 0;
 
-    JSFunction* function = asFunction(m_callFrame->callee());
-    if (!function)
+    JSObject* function = m_callFrame->callee();
+    if (!function || !function->inherits(&JSFunction::info))
         return 0;
-    return &function->name(m_callFrame);
+    return &asFunction(function)->name(m_callFrame);
 }
     
 UString DebuggerCallFrame::calculatedFunctionName() const
@@ -55,13 +55,11 @@ UString DebuggerCallFrame::calculatedFunctionName() const
     if (!m_callFrame->codeBlock())
         return UString();
 
-    if (!m_callFrame->callee())
-        return UString();
+    JSObject* function = m_callFrame->callee();
+    if (!function || !function->inherits(&JSFunction::info))
+        return 0;
 
-    JSFunction* function = asFunction(m_callFrame->callee());
-    if (!function)
-        return UString();
-    return function->calculatedDisplayName(m_callFrame);
+    return asFunction(function)->calculatedDisplayName(m_callFrame);
 }
 
 DebuggerCallFrame::Type DebuggerCallFrame::type() const
@@ -74,10 +72,15 @@ DebuggerCallFrame::Type DebuggerCallFrame::type() const
 
 JSObject* DebuggerCallFrame::thisObject() const
 {
-    if (!m_callFrame->codeBlock())
+    CodeBlock* codeBlock = m_callFrame->codeBlock();
+    if (!codeBlock)
+        return 0;
+
+    JSValue thisValue = m_callFrame->r(codeBlock->thisRegister()).jsValue();
+    if (!thisValue.isObject())
         return 0;
 
-    return asObject(m_callFrame->thisValue());
+    return asObject(thisValue);
 }
 
 JSValue DebuggerCallFrame::evaluate(const UString& script, JSValue& exception) const
index 9724875..f53e6f4 100644 (file)
 
 namespace JSC {
 
-JSValue CallFrame::thisValue()
-{
-    return this[codeBlock()->thisRegister()].jsValue();
-}
-
 #ifndef NDEBUG
 void CallFrame::dumpCaller()
 {
index 66045e2..2a7bce2 100644 (file)
@@ -38,16 +38,13 @@ namespace JSC  {
     // Passed as the first argument to most functions.
     class ExecState : private Register {
     public:
-        JSFunction* callee() const { return this[RegisterFile::Callee].function(); }
+        JSObject* callee() const { return this[RegisterFile::Callee].function(); }
         CodeBlock* codeBlock() const { return this[RegisterFile::CodeBlock].Register::codeBlock(); }
         ScopeChainNode* scopeChain() const
         {
             ASSERT(this[RegisterFile::ScopeChain].Register::scopeChain());
             return this[RegisterFile::ScopeChain].Register::scopeChain();
         }
-        int argumentCount() const { return this[RegisterFile::ArgumentCount].i(); }
-
-        JSValue thisValue();
 
         // Global object in which execution began.
         JSGlobalObject* dynamicGlobalObject();
@@ -118,7 +115,7 @@ namespace JSC  {
         void setScopeChain(ScopeChainNode* scopeChain) { static_cast<Register*>(this)[RegisterFile::ScopeChain] = scopeChain; }
 
         ALWAYS_INLINE void init(CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain,
-            CallFrame* callerFrame, int, int argc, JSFunction* function)
+            CallFrame* callerFrame, int argc, JSObject* callee)
         {
             ASSERT(callerFrame); // Use noCaller() rather than 0 for the outer host call frame caller.
 
@@ -126,21 +123,34 @@ namespace JSC  {
             setScopeChain(scopeChain);
             setCallerFrame(callerFrame);
             setReturnPC(vPC); // This is either an Instruction* or a pointer into JIT generated code stored as an Instruction*.
-            setArgumentCount(argc); // original argument count (for the sake of the "arguments" object)
-            setCallee(function);
+            setArgumentCountIncludingThis(argc); // original argument count (for the sake of the "arguments" object)
+            setCallee(callee);
         }
 
         // Read a register from the codeframe (or constant from the CodeBlock).
         inline Register& r(int);
 
+        // Access to arguments.
+        int hostThisRegister() { return -RegisterFile::CallFrameHeaderSize - argumentCountIncludingThis(); }
+        JSValue hostThisValue() { return this[hostThisRegister()].jsValue(); }
+        size_t argumentCount() const { return argumentCountIncludingThis() - 1; }
+        size_t argumentCountIncludingThis() const { return this[RegisterFile::ArgumentCount].i(); }
+        JSValue argument(int argumentNumber)
+        {
+            int argumentIndex = -RegisterFile::CallFrameHeaderSize - this[RegisterFile::ArgumentCount].i() + argumentNumber + 1;
+            if (argumentIndex >= -RegisterFile::CallFrameHeaderSize)
+                return jsUndefined();
+            return this[argumentIndex].jsValue();
+        }
+
         static CallFrame* noCaller() { return reinterpret_cast<CallFrame*>(HostCallFrameFlag); }
 
         bool hasHostCallFrameFlag() const { return reinterpret_cast<intptr_t>(this) & HostCallFrameFlag; }
         CallFrame* addHostCallFrameFlag() const { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) | HostCallFrameFlag); }
         CallFrame* removeHostCallFrameFlag() { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) & ~HostCallFrameFlag); }
 
-        void setArgumentCount(int count) { static_cast<Register*>(this)[RegisterFile::ArgumentCount] = Register::withInt(count); }
-        void setCallee(JSFunction* callee) { static_cast<Register*>(this)[RegisterFile::Callee] = callee; }
+        void setArgumentCountIncludingThis(int count) { static_cast<Register*>(this)[RegisterFile::ArgumentCount] = Register::withInt(count); }
+        void setCallee(JSObject* callee) { static_cast<Register*>(this)[RegisterFile::Callee] = Register::withCallee(callee); }
         void setCodeBlock(CodeBlock* codeBlock) { static_cast<Register*>(this)[RegisterFile::CodeBlock] = codeBlock; }
         void setReturnPC(void* value) { static_cast<Register*>(this)[RegisterFile::ReturnPC] = (Instruction*)value; }
 
index d2fe2a5..12ac323 100644 (file)
@@ -375,7 +375,7 @@ NEVER_INLINE JSValue Interpreter::callEval(CallFrame* callFrame, RegisterFile* r
 
     JSValue result = jsUndefined();
     if (eval)
-        result = callFrame->globalData().interpreter->execute(eval.get(), callFrame, callFrame->thisValue().toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue);
+        result = callFrame->globalData().interpreter->execute(eval.get(), callFrame, callFrame->r(codeBlock->thisRegister()).jsValue().toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue);
 
     return result;
 }
@@ -628,8 +628,10 @@ NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSV
             return 0;
     }
 
-    // Now unwind the scope chain within the exception handler's call frame.
+    // Shrink the JS stack, in case stack overflow made it huge.
+    m_registerFile.shrink(callFrame->registers() + callFrame->codeBlock()->m_numCalleeRegisters);
 
+    // Unwind the scope chain within the exception handler's call frame.
     ScopeChainNode* scopeChain = callFrame->scopeChain();
     ScopeChain sc(scopeChain);
     int scopeDelta = depth(codeBlock, sc) - handler->scopeDepth;
@@ -661,19 +663,20 @@ JSValue Interpreter::execute(ProgramExecutable* program, CallFrame* callFrame, S
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject);
-
     JSGlobalObject* lastGlobalObject = m_registerFile.globalObject();
     JSGlobalObject* globalObject = callFrame->dynamicGlobalObject();
     globalObject->copyGlobalsTo(m_registerFile);
 
     CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->m_numParameters + RegisterFile::CallFrameHeaderSize);
-    newCallFrame->r(codeBlock->thisRegister()) = JSValue(thisObj);
-    newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), 0, 0, 0);
+    ASSERT(codeBlock->m_numParameters == 1); // 1 parameter for 'this'.
+    newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), codeBlock->m_numParameters, 0);
+    newCallFrame->r(newCallFrame->hostThisRegister()) = JSValue(thisObj);
 
     if (codeBlock->needsFullScopeChain())
         scopeChain->ref();
 
+    DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject);
+
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
         (*profiler)->willExecute(newCallFrame, program->sourceURL(), program->lineNo());
@@ -702,9 +705,9 @@ JSValue Interpreter::execute(ProgramExecutable* program, CallFrame* callFrame, S
     return result;
 }
 
-JSValue Interpreter::executeCall(FunctionExecutable* functionExecutable, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue* exception)
+JSValue Interpreter::executeCall(CallFrame* callFrame, JSObject* function, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args, JSValue* exception)
 {
-    ASSERT(!scopeChain->globalData->exception);
+    ASSERT(!callFrame->hadException());
 
     if (m_reentryDepth >= MaxSmallThreadReentryDepth) {
         if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) {
@@ -714,51 +717,79 @@ JSValue Interpreter::executeCall(FunctionExecutable* functionExecutable, CallFra
     }
 
     Register* oldEnd = m_registerFile.end();
-    int argc = 1 + args.size(); // implicit "this" parameter
+    int argCount = 1 + args.size(); // implicit "this" parameter
+    size_t registerOffset = argCount + RegisterFile::CallFrameHeaderSize;
 
-    if (!m_registerFile.grow(oldEnd + argc)) {
+    if (!m_registerFile.grow(oldEnd + registerOffset)) {
         *exception = createStackOverflowError(callFrame);
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject);
-
     CallFrame* newCallFrame = CallFrame::create(oldEnd);
     size_t dst = 0;
-    newCallFrame->r(0) = JSValue(thisObj);
+    newCallFrame->r(0) = thisValue;
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
         newCallFrame->r(++dst) = *it;
 
-    CodeBlock* codeBlock = &functionExecutable->bytecodeForCall(callFrame, scopeChain);
-    newCallFrame = slideRegisterWindowForCall(codeBlock, &m_registerFile, newCallFrame, argc + RegisterFile::CallFrameHeaderSize, argc);
-    if (UNLIKELY(!newCallFrame)) {
-        *exception = createStackOverflowError(callFrame);
+    if (callType == CallTypeJS) {
+        ScopeChainNode* callDataScopeChain = callData.js.scopeChain;
+        CodeBlock* newCodeBlock = &callData.js.functionExecutable->bytecodeForCall(callFrame, callDataScopeChain);
+
+        newCallFrame = slideRegisterWindowForCall(newCodeBlock, &m_registerFile, newCallFrame, registerOffset, argCount);
+        if (UNLIKELY(!newCallFrame)) {
+            *exception = createStackOverflowError(callFrame);
+            m_registerFile.shrink(oldEnd);
+            return jsNull();
+        }
+
+        newCallFrame->init(newCodeBlock, 0, callDataScopeChain, callFrame->addHostCallFrameFlag(), argCount, function);
+
+        DynamicGlobalObjectScope globalObjectScope(newCallFrame, callDataScopeChain->globalObject);
+
+        Profiler** profiler = Profiler::enabledProfilerReference();
+        if (*profiler)
+            (*profiler)->willExecute(newCallFrame, function);
+
+        JSValue result;
+        {
+            SamplingTool::CallRecord callRecord(m_sampler.get());
+
+            m_reentryDepth++;
+    #if ENABLE(JIT)
+            result = callData.js.functionExecutable->jitCodeForCall(newCallFrame, callDataScopeChain).execute(&m_registerFile, newCallFrame, callDataScopeChain->globalData, exception);
+    #else
+            result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
+    #endif
+            m_reentryDepth--;
+        }
+
+        if (*profiler)
+            (*profiler)->didExecute(newCallFrame, function);
+
         m_registerFile.shrink(oldEnd);
-        return jsNull();
+        return result;
     }
-    // a 0 codeBlock indicates a built-in caller
-    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, argc, function);
+
+    ASSERT(callType == CallTypeHost);
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    newCallFrame = CallFrame::create(newCallFrame->registers() + registerOffset);
+    newCallFrame->init(0, 0, scopeChain, callFrame->addHostCallFrameFlag(), argCount, function);
+
+    DynamicGlobalObjectScope globalObjectScope(newCallFrame, scopeChain->globalObject);
 
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(callFrame, function);
+        (*profiler)->willExecute(newCallFrame, function);
 
     JSValue result;
     {
-        SamplingTool::CallRecord callRecord(m_sampler.get());
-
-        m_reentryDepth++;
-#if ENABLE(JIT)
-        result = functionExecutable->jitCodeForCall(newCallFrame, scopeChain).execute(&m_registerFile, newCallFrame, scopeChain->globalData, exception);
-#else
-        result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
-#endif
-        m_reentryDepth--;
+        SamplingTool::HostCallRecord callRecord(m_sampler.get());
+        result = callData.native.function(newCallFrame);
     }
 
     if (*profiler)
-        (*profiler)->didExecute(callFrame, function);
+        (*profiler)->didExecute(newCallFrame, function);
 
     m_registerFile.shrink(oldEnd);
     return result;
@@ -783,8 +814,6 @@ JSValue Interpreter::executeConstruct(FunctionExecutable* functionExecutable, Ca
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject);
-
     CallFrame* newCallFrame = CallFrame::create(oldEnd);
     size_t dst = 0;
     newCallFrame->r(0) = JSValue(thisObj);
@@ -800,7 +829,9 @@ JSValue Interpreter::executeConstruct(FunctionExecutable* functionExecutable, Ca
         return jsNull();
     }
     // a 0 codeBlock indicates a built-in caller
-    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, argc, function);
+    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), argc, function);
+
+    DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject);
 
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
@@ -858,7 +889,7 @@ CallFrameClosure Interpreter::prepareForRepeatCall(FunctionExecutable* FunctionE
         return CallFrameClosure();
     }
     // a 0 codeBlock indicates a built-in caller
-    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, argc, function);
+    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), argc, function);
 #if ENABLE(JIT)
     FunctionExecutable->jitCodeForCall(newCallFrame, scopeChain);
 #endif
@@ -957,8 +988,9 @@ JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSObjec
     CallFrame* newCallFrame = CallFrame::create(m_registerFile.start() + globalRegisterOffset);
 
     // a 0 codeBlock indicates a built-in caller
-    newCallFrame->r(codeBlock->thisRegister()) = JSValue(thisObj);
-    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, 0, 0);
+    ASSERT(codeBlock->m_numParameters == 1); // 1 parameter for 'this'.
+    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), codeBlock->m_numParameters, 0);
+    newCallFrame->r(newCallFrame->hostThisRegister()) = JSValue(thisObj);
 
     if (codeBlock->needsFullScopeChain())
         scopeChain->ref();
@@ -2938,7 +2970,7 @@ skip_id_custom_self:
         JSValue result;
         int offset = 0;
         if (subscript == expectedSubscript && baseValue.isCell() && (baseValue.asCell()->structure() == it->cachedStructure()) && it->getOffset(index, offset)) {
-            callFrame->r(dst) = asObject(baseValue)->getDirectOffset(offset);
+            callFrame->r(dst) = JSValue(asObject(baseValue)->getDirectOffset(offset));
             vPC += OPCODE_LENGTH(op_get_by_pname);
             NEXT_INSTRUCTION();
         }
@@ -3577,7 +3609,7 @@ skip_id_custom_self:
                 goto vm_throw;
             }
 
-            callFrame->init(newCodeBlock, vPC + OPCODE_LENGTH(op_call), callDataScopeChain, previousCallFrame, 0, argCount, asFunction(v));
+            callFrame->init(newCodeBlock, vPC + OPCODE_LENGTH(op_call), callDataScopeChain, previousCallFrame, argCount, asFunction(v));
             codeBlock = newCodeBlock;
             ASSERT(codeBlock == callFrame->codeBlock());
             vPC = newCodeBlock->instructions().begin();
@@ -3592,20 +3624,15 @@ skip_id_custom_self:
         if (callType == CallTypeHost) {
             ScopeChainNode* scopeChain = callFrame->scopeChain();
             CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset);
-            newCallFrame->init(0, vPC + OPCODE_LENGTH(op_call), scopeChain, callFrame, 0, argCount, 0);
+            newCallFrame->init(0, vPC + OPCODE_LENGTH(op_call), scopeChain, callFrame, argCount, asObject(v));
 
             Register* thisRegister = newCallFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
             ArgList args(thisRegister + 1, argCount - 1);
 
-            // FIXME: All host methods should be calling toThisObject, but this is not presently the case.
-            JSValue thisValue = thisRegister->jsValue();
-            if (thisValue == jsNull())
-                thisValue = callFrame->globalThisValue();
-
             JSValue returnValue;
             {
                 SamplingTool::HostCallRecord callRecord(m_sampler.get());
-                returnValue = callData.native.function(newCallFrame, asObject(v), thisValue, args);
+                returnValue = callData.native.function(newCallFrame);
             }
             CHECK_FOR_EXCEPTION();
 
@@ -3627,15 +3654,15 @@ skip_id_custom_self:
         JSValue arguments = callFrame->r(argsOffset).jsValue();
         int32_t argCount = 0;
         if (!arguments) {
-            argCount = (uint32_t)(callFrame->argumentCount()) - 1;
+            argCount = (uint32_t)(callFrame->argumentCount());
             int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize;
             Register* newEnd = callFrame->registers() + sizeDelta;
             if (!registerFile->grow(newEnd) || ((newEnd - callFrame->registers()) != sizeDelta)) {
                 exceptionValue = createStackOverflowError(callFrame);
                 goto vm_throw;
             }
-            ASSERT(!callFrame->callee()->isHostFunction());
-            int32_t expectedParams = callFrame->callee()->jsExecutable()->parameterCount();
+            ASSERT(!asFunction(callFrame->callee())->isHostFunction());
+            int32_t expectedParams = asFunction(callFrame->callee())->jsExecutable()->parameterCount();
             int32_t inplaceArgs = min(argCount, expectedParams);
             int32_t i = 0;
             Register* argStore = callFrame->registers() + argsOffset;
@@ -3732,7 +3759,7 @@ skip_id_custom_self:
                 goto vm_throw;
             }
             
-            callFrame->init(newCodeBlock, vPC + OPCODE_LENGTH(op_call_varargs), callDataScopeChain, previousCallFrame, 0, argCount, asFunction(v));
+            callFrame->init(newCodeBlock, vPC + OPCODE_LENGTH(op_call_varargs), callDataScopeChain, previousCallFrame, argCount, asFunction(v));
             codeBlock = newCodeBlock;
             ASSERT(codeBlock == callFrame->codeBlock());
             vPC = newCodeBlock->instructions().begin();
@@ -3747,20 +3774,15 @@ skip_id_custom_self:
         if (callType == CallTypeHost) {
             ScopeChainNode* scopeChain = callFrame->scopeChain();
             CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset);
-            newCallFrame->init(0, vPC + OPCODE_LENGTH(op_call_varargs), scopeChain, callFrame, 0, argCount, 0);
+            newCallFrame->init(0, vPC + OPCODE_LENGTH(op_call_varargs), scopeChain, callFrame, argCount, asObject(v));
             
             Register* thisRegister = newCallFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
             ArgList args(thisRegister + 1, argCount - 1);
             
-            // FIXME: All host methods should be calling toThisObject, but this is not presently the case.
-            JSValue thisValue = thisRegister->jsValue();
-            if (thisValue == jsNull())
-                thisValue = callFrame->globalThisValue();
-            
             JSValue returnValue;
             {
                 SamplingTool::HostCallRecord callRecord(m_sampler.get());
-                returnValue = callData.native.function(newCallFrame, asObject(v), thisValue, args);
+                returnValue = callData.native.function(newCallFrame);
             }
             CHECK_FOR_EXCEPTION();
             
@@ -3965,7 +3987,7 @@ skip_id_custom_self:
             structure = asObject(proto)->inheritorID();
         else
             structure = constructor->scope().node()->globalObject->emptyObjectStructure();
-        callFrame->r(thisRegister) = new (&callFrame->globalData()) JSObject(structure);
+        callFrame->r(thisRegister) = JSValue(new (&callFrame->globalData()) JSObject(structure));
 
         vPC += OPCODE_LENGTH(op_create_this);
         NEXT_INSTRUCTION();
@@ -4059,7 +4081,7 @@ skip_id_custom_self:
                 goto vm_throw;
             }
 
-            callFrame->init(newCodeBlock, vPC + OPCODE_LENGTH(op_construct), callDataScopeChain, previousCallFrame, 0, argCount, asFunction(v));
+            callFrame->init(newCodeBlock, vPC + OPCODE_LENGTH(op_construct), callDataScopeChain, previousCallFrame, argCount, asFunction(v));
             codeBlock = newCodeBlock;
             vPC = newCodeBlock->instructions().begin();
 
@@ -4073,7 +4095,7 @@ skip_id_custom_self:
         if (constructType == ConstructTypeHost) {
             ScopeChainNode* scopeChain = callFrame->scopeChain();
             CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset);
-            newCallFrame->init(0, vPC + OPCODE_LENGTH(op_construct), scopeChain, callFrame, 0, argCount, 0);
+            newCallFrame->init(0, vPC + OPCODE_LENGTH(op_construct), scopeChain, callFrame, argCount, 0);
 
             Register* thisRegister = newCallFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
             ArgList args(thisRegister + 1, argCount - 1);
index 3572617..13df468 100644 (file)
@@ -95,7 +95,7 @@ namespace JSC {
         bool isOpcode(Opcode);
         
         JSValue execute(ProgramExecutable*, CallFrame*, ScopeChainNode*, JSObject* thisObj, JSValue* exception);
-        JSValue executeCall(FunctionExecutable*, CallFrame*, JSFunction*, JSObject* thisObj, const ArgList& args, ScopeChainNode*, JSValue* exception);
+        JSValue executeCall(CallFrame*, JSObject* function, CallType, const CallData&, JSValue thisValue, const ArgList&, JSValue* exception);
         JSValue executeConstruct(FunctionExecutable*, CallFrame*, JSFunction*, JSObject* thisObj, const ArgList& args, ScopeChainNode*, JSValue* exception);
         JSValue execute(EvalExecutable* evalNode, CallFrame* exec, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue* exception);
 
index 723112e..38d1647 100644 (file)
@@ -39,7 +39,7 @@ namespace JSC {
     class CodeBlock;
     class ExecState;
     class JSActivation;
-    class JSFunction;
+    class JSObject;
     class JSPropertyNameIterator;
     class ScopeChainNode;
 
@@ -58,7 +58,6 @@ namespace JSC {
         Register& operator=(JSActivation*);
         Register& operator=(CallFrame*);
         Register& operator=(CodeBlock*);
-        Register& operator=(JSFunction*);
         Register& operator=(JSPropertyNameIterator*);
         Register& operator=(ScopeChainNode*);
         Register& operator=(Instruction*);
@@ -67,7 +66,7 @@ namespace JSC {
         JSActivation* activation() const;
         CallFrame* callFrame() const;
         CodeBlock* codeBlock() const;
-        JSFunction* function() const;
+        JSObject* function() const;
         JSPropertyNameIterator* propertyNameIterator() const;
         ScopeChainNode* scopeChain() const;
         Instruction* vPC() const;
@@ -79,6 +78,13 @@ namespace JSC {
             return r;
         }
 
+        static Register withCallee(JSObject* callee)
+        {
+            Register r;
+            r.u.function = callee;
+            return r;
+        }
+
     private:
         union {
             int32_t i;
@@ -87,7 +93,7 @@ namespace JSC {
             JSActivation* activation;
             CallFrame* callFrame;
             CodeBlock* codeBlock;
-            JSFunction* function;
+            JSObject* function;
             JSPropertyNameIterator* propertyNameIterator;
             ScopeChainNode* scopeChain;
             Instruction* vPC;
@@ -143,12 +149,6 @@ namespace JSC {
         return *this;
     }
 
-    ALWAYS_INLINE Register& Register::operator=(JSFunction* function)
-    {
-        u.function = function;
-        return *this;
-    }
-
     ALWAYS_INLINE Register& Register::operator=(Instruction* vPC)
     {
         u.vPC = vPC;
@@ -187,7 +187,7 @@ namespace JSC {
         return u.codeBlock;
     }
     
-    ALWAYS_INLINE JSFunction* Register::function() const
+    ALWAYS_INLINE JSObject* Register::function() const
     {
         return u.function;
     }
index 7da7e28..64e1f3c 100644 (file)
@@ -180,263 +180,29 @@ JIT::Label JIT::privateCompileCTINativeCall(JSGlobalData* globalData, bool isCon
     int executableOffsetToFunction = isConstruct ? OBJECT_OFFSETOF(NativeExecutable, m_constructor) : OBJECT_OFFSETOF(NativeExecutable, m_function);
 
     Label nativeCallThunk = align();
-    preserveReturnAddressAfterCall(regT0);
-    emitPutToCallFrameHeader(regT0, RegisterFile::ReturnPC); // Push return address
 
     // Load caller frame's scope chain into this callframe so that whatever we call can
     // get to its global data.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT1);
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT1);
+    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
+    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
     emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
-    
 
-#if CPU(X86_64)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, X86Registers::ecx);
+    peek(regT1);
+    emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);
 
-    // Allocate stack space for our arglist
-    subPtr(Imm32(sizeof(ArgList)), stackPointerRegister);
-    COMPILE_ASSERT((sizeof(ArgList) & 0xf) == 0, ArgList_should_by_16byte_aligned);
-    
-    // Set up arguments
-    subPtr(Imm32(1), X86Registers::ecx); // Don't include 'this' in argcount
+#if CPU(X86_64)
+    // Calling convention:      f(edi, esi, edx, ecx, ...);
+    // Host function signature: f(ExecState*);
+    move(callFrameRegister, X86Registers::edi);
 
-    // Push argcount
-    storePtr(X86Registers::ecx, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_argCount)));
+    subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
 
-    // Calculate the start of the callframe header, and store in edx
-    addPtr(Imm32(-RegisterFile::CallFrameHeaderSize * (int32_t)sizeof(Register)), callFrameRegister, X86Registers::edx);
-    
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (ecx)
-    mul32(Imm32(sizeof(Register)), X86Registers::ecx, X86Registers::ecx);
-    subPtr(X86Registers::ecx, X86Registers::edx);
-
-    // push pointer to arguments
-    storePtr(X86Registers::edx, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_args)));
-    
-    // ArgList is passed by reference so is stackPointerRegister
-    move(stackPointerRegister, X86Registers::ecx);
-    
-    // edx currently points to the first argument, edx-sizeof(Register) points to 'this'
-    loadPtr(Address(X86Registers::edx, -(int32_t)sizeof(Register)), X86Registers::edx);
-    
     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::esi);
-
-    move(callFrameRegister, X86Registers::edi); 
-
     loadPtr(Address(X86Registers::esi, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::r9);
+    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
     call(Address(X86Registers::r9, executableOffsetToFunction));
-    
-    addPtr(Imm32(sizeof(ArgList)), stackPointerRegister);
-#elif CPU(X86)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
-
-    /* We have two structs that we use to describe the stackframe we set up for our
-     * call to native code.  NativeCallFrameStructure describes the how we set up the stack
-     * in advance of the call.  NativeFunctionCalleeSignature describes the callframe
-     * as the native code expects it.  We do this as we are using the fastcall calling
-     * convention which results in the callee popping its arguments off the stack, but
-     * not the rest of the callframe so we need a nice way to ensure we increment the
-     * stack pointer by the right amount after the call.
-     */
-#if COMPILER(MSVC) || OS(LINUX)
-    struct NativeCallFrameStructure {
-      //  CallFrame* callFrame; // passed in EDX
-        JSObject* callee;
-        JSValue thisValue;
-        ArgList* argPointer;
-        ArgList args;
-        JSValue result;
-    };
-    struct NativeFunctionCalleeSignature {
-        JSObject* callee;
-        JSValue thisValue;
-        ArgList* argPointer;
-    };
-#else
-    struct NativeCallFrameStructure {
-      //  CallFrame* callFrame; // passed in ECX
-      //  JSObject* callee; // passed in EDX
-        JSValue thisValue;
-        ArgList* argPointer;
-        ArgList args;
-    };
-    struct NativeFunctionCalleeSignature {
-        JSValue thisValue;
-        ArgList* argPointer;
-    };
-#endif
-    const int NativeCallFrameSize = (sizeof(NativeCallFrameStructure) + 15) & ~15;
-    // Allocate system stack frame
-    subPtr(Imm32(NativeCallFrameSize), stackPointerRegister);
-
-    // Set up arguments
-    subPtr(Imm32(1), regT0); // Don't include 'this' in argcount
-
-    // push argcount
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, args) + OBJECT_OFFSETOF(ArgList, m_argCount)));
-    
-    // Calculate the start of the callframe header, and store in regT1
-    addPtr(Imm32(-RegisterFile::CallFrameHeaderSize * (int)sizeof(Register)), callFrameRegister, regT1);
-    
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (regT0)
-    mul32(Imm32(sizeof(Register)), regT0, regT0);
-    subPtr(regT0, regT1);
-    storePtr(regT1, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, args) + OBJECT_OFFSETOF(ArgList, m_args)));
-
-    // ArgList is passed by reference so is stackPointerRegister + 4 * sizeof(Register)
-    addPtr(Imm32(OBJECT_OFFSETOF(NativeCallFrameStructure, args)), stackPointerRegister, regT0);
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, argPointer)));
-
-    // regT1 currently points to the first argument, regT1 - sizeof(Register) points to 'this'
-    loadPtr(Address(regT1, -(int)sizeof(Register)), regT1);
-    storePtr(regT1, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, thisValue)));
-
-#if COMPILER(MSVC) || OS(LINUX)
-    // ArgList is passed by reference so is stackPointerRegister + 4 * sizeof(Register)
-    addPtr(Imm32(OBJECT_OFFSETOF(NativeCallFrameStructure, result)), stackPointerRegister, X86Registers::ecx);
-
-    // Plant callee
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::eax);
-    storePtr(X86Registers::eax, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, callee)));
-
-    // Plant callframe
-    move(callFrameRegister, X86Registers::edx);
-
-    loadPtr(Address(X86Registers::eax, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::ebx);
-    call(Address(X86Registers::ebx, executableOffsetToFunction));
-
-    // JSValue is a non-POD type
-    loadPtr(Address(X86Registers::eax), X86Registers::eax);
-#else
-    // Plant callee
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::edx);
-
-    // Plant callframe
-    move(callFrameRegister, X86Registers::ecx);
-    loadPtr(Address(X86Registers::edx, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::ebx);
-    call(Address(X86Registers::ebx, executableOffsetToFunction));
-#endif
-
-    // We've put a few temporaries on the stack in addition to the actual arguments
-    // so pull them off now
-    addPtr(Imm32(NativeCallFrameSize - sizeof(NativeFunctionCalleeSignature)), stackPointerRegister);
-
-#elif CPU(ARM)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
-
-    // Allocate stack space for our arglist
-    COMPILE_ASSERT((sizeof(ArgList) & 0x7) == 0, ArgList_should_by_8byte_aligned);
-    subPtr(Imm32(sizeof(ArgList)), stackPointerRegister);
-
-    // Set up arguments
-    subPtr(Imm32(1), regT0); // Don't include 'this' in argcount
-
-    // Push argcount
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_argCount)));
-
-    // Calculate the start of the callframe header, and store in regT1
-    move(callFrameRegister, regT1);
-    sub32(Imm32(RegisterFile::CallFrameHeaderSize * (int32_t)sizeof(Register)), regT1);
-
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (regT1)
-    mul32(Imm32(sizeof(Register)), regT0, regT0);
-    subPtr(regT0, regT1);
-
-    // push pointer to arguments
-    storePtr(regT1, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_args)));
 
-    // regT1 currently points to the first argument, regT1-sizeof(Register) points to 'this'
-
-#if OS(WINCE)
-    // Setup arg3:
-    loadPtr(Address(regT1, -(int32_t)sizeof(Register)), ARMRegisters::r3);
-
-    // Setup arg2:
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT2);
-
-    // Setup arg1:
-    move(callFrameRegister, regT1);
-
-    // Setup arg0:
-    move(stackPointerRegister, regT0);
-    subPtr(Imm32(sizeof(Register)), stackPointerRegister);
-    storePtr(regT0, Address(stackPointerRegister));
-
-    loadPtr(Address(regT2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT3);
-    call(Address(regT3, executableOffsetToFunction));
-
-    loadPtr(Address(regT0), regT0);
-
-    addPtr(Imm32(sizeof(Register) + sizeof(ArgList)), stackPointerRegister);
-#else // OS(WINCE)
-    // Setup arg3:
-    loadPtr(Address(regT1, -(int32_t)sizeof(Register)), regT2);
-
-    // Setup arg2:
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT1);
-
-    // Setup arg1:
-    move(callFrameRegister, regT0);
-
-    // Setup arg4: This is a plain hack
-    move(stackPointerRegister, ARMRegisters::r3);
-
-    loadPtr(Address(regT1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT3);
-    call(Address(regT3, executableOffsetToFunction));
-
-    addPtr(Imm32(sizeof(ArgList)), stackPointerRegister);
-#endif // OS(WINCE)
-
-#elif CPU(MIPS)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
-
-    // Allocate stack space for our arglist
-    COMPILE_ASSERT(!(sizeof(ArgList) & 0x7), ArgList_should_by_8byte_aligned);
-    subPtr(Imm32(sizeof(ArgList) + 24), stackPointerRegister);
-
-    // Set up arguments
-    subPtr(Imm32(1), regT0); // Don't include 'this' in argcount
-
-    // Push argcount to 24 + offset($sp)
-    storePtr(regT0, Address(stackPointerRegister, 24 + OBJECT_OFFSETOF(ArgList, m_argCount)));
-
-    // Calculate the start of the callframe header, and store in regT1
-    move(callFrameRegister, regT1);
-    sub32(Imm32(RegisterFile::CallFrameHeaderSize * (int32_t)sizeof(Register)), regT1);
-
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (regT1)
-    mul32(Imm32(sizeof(Register)), regT0, regT0);
-    subPtr(regT0, regT1);
-
-    // push pointer to arguments to 24 + offset($sp)
-    storePtr(regT1, Address(stackPointerRegister, 24 + OBJECT_OFFSETOF(ArgList, m_args)));
-
-    // Setup arg3: regT1 currently points to the first argument, regT1-sizeof(Register) points to 'this'
-    loadPtr(Address(regT1, -(int32_t)sizeof(Register)), MIPSRegisters::a3);
-
-    // Setup arg2:
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, MIPSRegisters::a2);
-
-    // Setup arg1:
-    move(callFrameRegister, MIPSRegisters::a1);
-
-    // Setup arg4: ArgList is passed by reference.  At 16($sp), store ($sp + 24)
-    addPtr(Imm32(24), stackPointerRegister, regT2);
-    storePtr(regT2, Address(stackPointerRegister, 16));
-
-    // Setup arg0 as 20($sp) to hold the returned structure.
-    ASSERT(sizeof(JSValue) == 4);
-    addPtr(Imm32(20), stackPointerRegister, MIPSRegisters::a0);
-
-    // Call
-    loadPtr(Address(MIPSRegisters::a2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
-    call(Address(regT2, executableOffsetToFunction));
-
-    // Get returned value from 0($v0) which is the same as 20($sp)
-    loadPtr(Address(returnValueRegister, 0), returnValueRegister);
-
-    // Restore stack space
-    addPtr(Imm32(sizeof(ArgList) + 24), stackPointerRegister);
+    addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);
 
 #elif ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
 #error "JIT_OPTIMIZE_NATIVE_CALL not yet supported on this platform."
@@ -448,26 +214,17 @@ JIT::Label JIT::privateCompileCTINativeCall(JSGlobalData* globalData, bool isCon
     loadPtr(&(globalData->exception), regT2);
     Jump exceptionHandler = branchTestPtr(NonZero, regT2);
 
-    // Grab the return address.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
-    
-    // Restore our caller's "r".
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
-    
     // Return.
-    restoreReturnAddressBeforeReturn(regT1);
     ret();
 
     // Handle an exception
     exceptionHandler.link(this);
     // Grab the return address.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
+    peek(regT1);
     move(ImmPtr(&globalData->exceptionLocation), regT2);
     storePtr(regT1, regT2);
-    move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT2);
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
-    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));
-    restoreReturnAddressBeforeReturn(regT2);
+    poke(callFrameRegister, 1 + OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));
+    poke(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));
     ret();
 
     return nativeCallThunk;
index d743286..507de6e 100644 (file)
@@ -180,484 +180,123 @@ JIT::Label JIT::privateCompileCTINativeCall(JSGlobalData* globalData, bool isCon
     int executableOffsetToFunction = isConstruct ? OBJECT_OFFSETOF(NativeExecutable, m_constructor) : OBJECT_OFFSETOF(NativeExecutable, m_function);
 
     Label nativeCallThunk = align();
-#if CPU(X86) || CPU(ARM_TRADITIONAL)
-    preserveReturnAddressAfterCall(regT0);
-    emitPutToCallFrameHeader(regT0, RegisterFile::ReturnPC); // Push return address
 
     // Load caller frame's scope chain into this callframe so that whatever we call can
     // get to its global data.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT1);
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT1);
+    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
+    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
     emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
 
-#if CPU(X86)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
-
-    /* We have two structs that we use to describe the stackframe we set up for our
-     * call to native code.  NativeCallFrameStructure describes the how we set up the stack
-     * in advance of the call.  NativeFunctionCalleeSignature describes the callframe
-     * as the native code expects it.  We do this as we are using the fastcall calling
-     * convention which results in the callee popping its arguments off the stack, but
-     * not the rest of the callframe so we need a nice way to ensure we increment the
-     * stack pointer by the right amount after the call.
-     */
-
-#if COMPILER(MSVC) || OS(LINUX)
-#if COMPILER(MSVC)
-#pragma pack(push)
-#pragma pack(4)
-#endif // COMPILER(MSVC)
-    struct NativeCallFrameStructure {
-        //  CallFrame* callFrame; // passed in EDX
-        JSObject* callee;
-        JSValue thisValue;
-        ArgList* argPointer;
-        ArgList args;
-        JSValue result;
-    };
-    struct NativeFunctionCalleeSignature {
-        JSObject* callee;
-        JSValue thisValue;
-        ArgList* argPointer;
-    };
-#if COMPILER(MSVC)
-#pragma pack(pop)
-#endif // COMPILER(MSVC)
-#else
-    struct NativeCallFrameStructure {
-        //  CallFrame* callFrame; // passed in ECX
-        //  JSObject* callee; // passed in EDX
-        JSValue thisValue;
-        ArgList* argPointer;
-        ArgList args;
-    };
-    struct NativeFunctionCalleeSignature {
-        JSValue thisValue;
-        ArgList* argPointer;
-    };
-#endif
-
-    const int NativeCallFrameSize = (sizeof(NativeCallFrameStructure) + 15) & ~15;
-    // Allocate system stack frame
-    subPtr(Imm32(NativeCallFrameSize), stackPointerRegister);
-
-    // Set up arguments
-    subPtr(Imm32(1), regT0); // Don't include 'this' in argcount
-
-    // push argcount
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, args) + OBJECT_OFFSETOF(ArgList, m_argCount)));
-
-    // Calculate the start of the callframe header, and store in regT1
-    addPtr(Imm32(-RegisterFile::CallFrameHeaderSize * (int)sizeof(Register)), callFrameRegister, regT1);
-
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (regT0)
-    mul32(Imm32(sizeof(Register)), regT0, regT0);
-    subPtr(regT0, regT1);
-    storePtr(regT1, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, args) + OBJECT_OFFSETOF(ArgList, m_args)));
-
-    // ArgList is passed by reference so is stackPointerRegister + 4 * sizeof(Register)
-    addPtr(Imm32(OBJECT_OFFSETOF(NativeCallFrameStructure, args)), stackPointerRegister, regT0);
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, argPointer)));
-
-    // regT1 currently points to the first argument, regT1 - sizeof(Register) points to 'this'
-    loadPtr(Address(regT1, -(int)sizeof(Register) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT2);
-    loadPtr(Address(regT1, -(int)sizeof(Register) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT3);
-    storePtr(regT2, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, thisValue) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
-    storePtr(regT3, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, thisValue) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
+    peek(regT1);
+    emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);
 
+#if CPU(X86)
 #if COMPILER(MSVC) || OS(LINUX)
-    // ArgList is passed by reference so is stackPointerRegister + 4 * sizeof(Register)
-    addPtr(Imm32(OBJECT_OFFSETOF(NativeCallFrameStructure, result)), stackPointerRegister, X86Registers::ecx);
-
-    // Plant callee
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::eax);
-    storePtr(X86Registers::eax, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, callee)));
-
-    // Plant callframe
+    // Calling convention:      f(edx, ...);
+    // Host function signature: f(ExecState*);
     move(callFrameRegister, X86Registers::edx);
 
-    loadPtr(Address(X86Registers::eax, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::ebx);
-    call(Address(X86Registers::ebx, executableOffsetToFunction));
-
-    // JSValue is a non-POD type, so eax points to it
-    emitLoad(0, regT1, regT0, X86Registers::eax);
 #else
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::edx); // callee
-    move(callFrameRegister, X86Registers::ecx); // callFrame
-    loadPtr(Address(X86Registers::edx, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::ebx);
-    call(Address(X86Registers::ebx, executableOffsetToFunction));
-#endif
-
-    // We've put a few temporaries on the stack in addition to the actual arguments
-    // so pull them off now
-    addPtr(Imm32(NativeCallFrameSize - sizeof(NativeFunctionCalleeSignature)), stackPointerRegister);
-
-#elif CPU(ARM_TRADITIONAL)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
-
-    // Allocate stack space for our arglist
-    COMPILE_ASSERT((sizeof(ArgList) & 0x7) == 0 && sizeof(JSValue) == 8 && sizeof(Register) == 8, ArgList_should_by_8byte_aligned);
-    subPtr(Imm32(sizeof(ArgList)), stackPointerRegister);
-
-    // Set up arguments
-    subPtr(Imm32(1), regT0); // Don't include 'this' in argcount
-
-    // Push argcount
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_argCount)));
-
-    // Calculate the start of the callframe header, and store in regT1
-    move(callFrameRegister, regT1);
-    sub32(Imm32(RegisterFile::CallFrameHeaderSize * (int32_t)sizeof(Register)), regT1);
-
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (regT1)
-    mul32(Imm32(sizeof(Register)), regT0, regT0);
-    subPtr(regT0, regT1);
-
-    // push pointer to arguments
-    storePtr(regT1, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_args)));
-
-    // Argument passing method:
-    // r0 - points to return value
-    // r1 - callFrame
-    // r2 - callee
-    // stack: this(JSValue) and a pointer to ArgList
+    // Calling convention:      f(ecx, edx, ...);
+    // Host function signature: f(ExecState*);
+    move(callFrameRegister, X86Registers::ecx);
 
-#if OS(WINCE)
-    // Setup arg4:
-    push(stackPointerRegister);
+#endif // COMPILER(MSVC) || OS(LINUX)
 
-    // Setup arg3:
-    // regT1 currently points to the first argument, regT1-sizeof(Register) points to 'this'
-    load32(Address(regT1, -(int32_t)sizeof(void*) * 2), ARMRegisters::r3);
-    push(ARMRegisters::r3);
-    load32(Address(regT1, -(int32_t)sizeof(void*)), regT3);
-    storePtr(regT3, Address(stackPointerRegister));
+    subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
 
-    // Setup arg2:
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT2);
+    // call the function
+    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT1);
+    loadPtr(Address(regT1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT1);
+    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
+    call(Address(regT1, executableOffsetToFunction));
 
-    // Setup arg1:
-    move(callFrameRegister, regT1);
+    addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);
 
-    // Setup arg0:
-    move(stackPointerRegister, regT0);
-
-    loadPtr(Address(regT2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT3);
-    call(Address(regT3, executableOffsetToFunction));
-
-    load32(Address(stackPointerRegister, 0), regT0);
-    load32(Address(stackPointerRegister, 4), regT1);
-
-    addPtr(Imm32(sizeof(ArgList) + 8), stackPointerRegister);
-#else // OS(WINCE)
-    move(stackPointerRegister, regT3);
-    subPtr(Imm32(8), stackPointerRegister);
-    move(stackPointerRegister, regT0);
-    subPtr(Imm32(8 + 4 + 4 /* padding */), stackPointerRegister);
-
-    // Setup arg4:
-    storePtr(regT3, Address(stackPointerRegister, 8));
-
-    // Setup arg3:
-    // regT1 currently points to the first argument, regT1-sizeof(Register) points to 'this'
-    load32(Address(regT1, -(int32_t)sizeof(void*) * 2), regT3);
-    storePtr(regT3, Address(stackPointerRegister, 0));
-    load32(Address(regT1, -(int32_t)sizeof(void*)), regT3);
-    storePtr(regT3, Address(stackPointerRegister, 4));
-
-    // Setup arg2:
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT2);
-
-    // Setup arg1:
-    move(callFrameRegister, regT1);
-
-    loadPtr(Address(regT2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT3);
-    call(Address(regT3, executableOffsetToFunction));
-
-    // Load return value
-    load32(Address(stackPointerRegister, 16), regT0);
-    load32(Address(stackPointerRegister, 20), regT1);
-
-    addPtr(Imm32(sizeof(ArgList) + 16 + 8), stackPointerRegister);
-#endif // OS(WINCE)
-
-#endif
+#elif ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
+#error "JIT_OPTIMIZE_NATIVE_CALL not yet supported on this platform."
+#else
+    breakpoint();
+#endif // CPU(X86)
 
     // Check for an exception
-    move(ImmPtr(&globalData->exception), regT2);
-    Jump sawException = branch32(NotEqual, tagFor(0, regT2), Imm32(JSValue::EmptyValueTag));
-
-    // Grab the return address.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT3);
-
-    // Restore our caller's "r".
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
+    Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::EmptyValueTag));
 
     // Return.
-    restoreReturnAddressBeforeReturn(regT3);
     ret();
 
     // Handle an exception
     sawException.link(this);
-    // Grab the return address.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
+    peek(regT1);
     move(ImmPtr(&globalData->exceptionLocation), regT2);
     storePtr(regT1, regT2);
-    move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT2);
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
-    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
-    restoreReturnAddressBeforeReturn(regT2);
+    poke(callFrameRegister, 1 + OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
+    poke(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));
     ret();
 
-#elif ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
-#error "JIT_OPTIMIZE_NATIVE_CALL not yet supported on this platform."
-#else
-    breakpoint();
-#endif
-
     return nativeCallThunk;
 }
 
 JIT::CodePtr JIT::privateCompileCTINativeCall(PassRefPtr<ExecutablePool> executablePool, JSGlobalData* globalData, NativeFunction func)
 {
-#if CPU(X86) || CPU(ARM_TRADITIONAL)
     Label nativeCallThunk = align();
-    preserveReturnAddressAfterCall(regT0);
-    emitPutToCallFrameHeader(regT0, RegisterFile::ReturnPC); // Push return address
 
+#if CPU(X86)
     // Load caller frame's scope chain into this callframe so that whatever we call can
     // get to its global data.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT1);
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT1);
+    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
+    emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
     emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
 
-#if CPU(X86)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
-
-    /* We have two structs that we use to describe the stackframe we set up for our
-     * call to native code.  NativeCallFrameStructure describes the how we set up the stack
-     * in advance of the call.  NativeFunctionCalleeSignature describes the callframe
-     * as the native code expects it.  We do this as we are using the fastcall calling
-     * convention which results in the callee popping its arguments off the stack, but
-     * not the rest of the callframe so we need a nice way to ensure we increment the
-     * stack pointer by the right amount after the call.
-     */
-
-#if COMPILER(MSVC) || OS(LINUX)
-#if COMPILER(MSVC)
-#pragma pack(push)
-#pragma pack(4)
-#endif // COMPILER(MSVC)
-    struct NativeCallFrameStructure {
-        //  CallFrame* callFrame; // passed in EDX
-        JSObject* callee;
-        JSValue thisValue;
-        ArgList* argPointer;
-        ArgList args;
-        JSValue result;
-    };
-    struct NativeFunctionCalleeSignature {
-        JSObject* callee;
-        JSValue thisValue;
-        ArgList* argPointer;
-    };
-#if COMPILER(MSVC)
-#pragma pack(pop)
-#endif // COMPILER(MSVC)
-#else
-    struct NativeCallFrameStructure {
-        //  CallFrame* callFrame; // passed in ECX
-        //  JSObject* callee; // passed in EDX
-        JSValue thisValue;
-        ArgList* argPointer;
-        ArgList args;
-    };
-    struct NativeFunctionCalleeSignature {
-        JSValue thisValue;
-        ArgList* argPointer;
-    };
-#endif
-
-    const int NativeCallFrameSize = (sizeof(NativeCallFrameStructure) + 15) & ~15;
-    // Allocate system stack frame
-    subPtr(Imm32(NativeCallFrameSize), stackPointerRegister);
-
-    // Set up arguments
-    subPtr(Imm32(1), regT0); // Don't include 'this' in argcount
-
-    // push argcount
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, args) + OBJECT_OFFSETOF(ArgList, m_argCount)));
-
-    // Calculate the start of the callframe header, and store in regT1
-    addPtr(Imm32(-RegisterFile::CallFrameHeaderSize * (int)sizeof(Register)), callFrameRegister, regT1);
-
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (regT0)
-    mul32(Imm32(sizeof(Register)), regT0, regT0);
-    subPtr(regT0, regT1);
-    storePtr(regT1, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, args) + OBJECT_OFFSETOF(ArgList, m_args)));
-
-    // ArgList is passed by reference so is stackPointerRegister + 4 * sizeof(Register)
-    addPtr(Imm32(OBJECT_OFFSETOF(NativeCallFrameStructure, args)), stackPointerRegister, regT0);
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, argPointer)));
-
-    // regT1 currently points to the first argument, regT1 - sizeof(Register) points to 'this'
-    loadPtr(Address(regT1, -(int)sizeof(Register) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT2);
-    loadPtr(Address(regT1, -(int)sizeof(Register) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT3);
-    storePtr(regT2, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, thisValue) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
-    storePtr(regT3, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, thisValue) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
+    peek(regT1);
+    emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);
 
 #if COMPILER(MSVC) || OS(LINUX)
-    // ArgList is passed by reference so is stackPointerRegister + 4 * sizeof(Register)
-    addPtr(Imm32(OBJECT_OFFSETOF(NativeCallFrameStructure, result)), stackPointerRegister, X86Registers::ecx);
-
-    // Plant callee
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::eax);
-    storePtr(X86Registers::eax, Address(stackPointerRegister, OBJECT_OFFSETOF(NativeCallFrameStructure, callee)));
-
-    // Plant callframe
+    // Calling convention:      f(edx, ...);
+    // Host function signature: f(ExecState*);
     move(callFrameRegister, X86Registers::edx);
 
-    Call nativeCall = call();
-
-    // JSValue is a non-POD type, so eax points to it
-    emitLoad(0, regT1, regT0, X86Registers::eax);
 #else
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::edx); // callee
-    move(callFrameRegister, X86Registers::ecx); // callFrame
-    Call nativeCall = call();
-#endif
-
-    // We've put a few temporaries on the stack in addition to the actual arguments
-    // so pull them off now
-    addPtr(Imm32(NativeCallFrameSize - sizeof(NativeFunctionCalleeSignature)), stackPointerRegister);
-
-#elif CPU(ARM_TRADITIONAL)
-    emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
-
-    // Allocate stack space for our arglist
-    COMPILE_ASSERT((sizeof(ArgList) & 0x7) == 0 && sizeof(JSValue) == 8 && sizeof(Register) == 8, ArgList_should_by_8byte_aligned);
-    subPtr(Imm32(sizeof(ArgList)), stackPointerRegister);
-
-    // Set up arguments
-    subPtr(Imm32(1), regT0); // Don't include 'this' in argcount
-
-    // Push argcount
-    storePtr(regT0, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_argCount)));
-
-    // Calculate the start of the callframe header, and store in regT1
-    move(callFrameRegister, regT1);
-    sub32(Imm32(RegisterFile::CallFrameHeaderSize * (int32_t)sizeof(Register)), regT1);
-
-    // Calculate start of arguments as callframe header - sizeof(Register) * argcount (regT1)
-    mul32(Imm32(sizeof(Register)), regT0, regT0);
-    subPtr(regT0, regT1);
-
-    // push pointer to arguments
-    storePtr(regT1, Address(stackPointerRegister, OBJECT_OFFSETOF(ArgList, m_args)));
-
-    // Argument passing method:
-    // r0 - points to return value
-    // r1 - callFrame
-    // r2 - callee
-    // stack: this(JSValue) and a pointer to ArgList
+    // Calling convention:      f(ecx, edx, ...);
+    // Host function signature: f(ExecState*);
+    move(callFrameRegister, X86Registers::ecx);
 
-#if OS(WINCE)
-    // Setup arg4:
-    push(stackPointerRegister);
+#endif // COMPILER(MSVC) || OS(LINUX)
 
-    // Setup arg3:
-    // regT1 currently points to the first argument, regT1-sizeof(Register) points to 'this'
-    load32(Address(regT1, -(int32_t)sizeof(void*) * 2), ARMRegisters::r3);
-    push(ARMRegisters::r3);
-    load32(Address(regT1, -(int32_t)sizeof(void*)), regT3);
-    storePtr(regT3, Address(stackPointerRegister));
+    subPtr(Imm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
 
-    // Setup arg2:
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT2);
-
-    // Setup arg1:
-    move(callFrameRegister, regT1);
-
-    // Setup arg0:
-    move(stackPointerRegister, regT0);
+    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
 
+    // call the function
     Call nativeCall = call();
 
-    load32(Address(stackPointerRegister, 0), regT0);
-    load32(Address(stackPointerRegister, 4), regT1);
-
-    addPtr(Imm32(sizeof(ArgList) + 8), stackPointerRegister);
-#else // OS(WINCE)
-    move(stackPointerRegister, regT3);
-    subPtr(Imm32(8), stackPointerRegister);
-    move(stackPointerRegister, regT0);
-    subPtr(Imm32(8 + 4 + 4 /* padding */), stackPointerRegister);
-
-    // Setup arg4:
-    storePtr(regT3, Address(stackPointerRegister, 8));
-
-    // Setup arg3:
-    // regT1 currently points to the first argument, regT1-sizeof(Register) points to 'this'
-    load32(Address(regT1, -(int32_t)sizeof(void*) * 2), regT3);
-    storePtr(regT3, Address(stackPointerRegister, 0));
-    load32(Address(regT1, -(int32_t)sizeof(void*)), regT3);
-    storePtr(regT3, Address(stackPointerRegister, 4));
-
-    // Setup arg2:
-    emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT2);
-
-    // Setup arg1:
-    move(callFrameRegister, regT1);
+    addPtr(Imm32(16 - sizeof(void*)), stackPointerRegister);
 
-    Call nativeCall = call();
-
-    // Load return value
-    load32(Address(stackPointerRegister, 16), regT0);
-    load32(Address(stackPointerRegister, 20), regT1);
-
-    addPtr(Imm32(sizeof(ArgList) + 16 + 8), stackPointerRegister);
-#endif // OS(WINCE)
-
-#endif
+#elif ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
+#error "JIT_OPTIMIZE_NATIVE_CALL not yet supported on this platform."
+#else
+    breakpoint();
+#endif // CPU(X86)
 
     // Check for an exception
-    move(ImmPtr(&globalData->exception), regT2);
-    Jump sawException = branch32(NotEqual, tagFor(0, regT2), Imm32(JSValue::EmptyValueTag));
-
-    // Grab the return address.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT3);
-
-    // Restore our caller's "r".
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
+    Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), Imm32(JSValue::EmptyValueTag));
 
     // Return.
-    restoreReturnAddressBeforeReturn(regT3);
     ret();
 
     // Handle an exception
     sawException.link(this);
-    // Grab the return address.
-    emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
+    peek(regT1);
     move(ImmPtr(&globalData->exceptionLocation), regT2);
     storePtr(regT1, regT2);
-    move(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT2);
-    emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
-    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
-    restoreReturnAddressBeforeReturn(regT2);
+    poke(callFrameRegister, 1 + OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
+    poke(ImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()));
     ret();
 
-#elif ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
-#error "JIT_OPTIMIZE_NATIVE_CALL not yet supported on this platform."
-#else
-    breakpoint();
-#endif
-
     // All trampolines constructed! copy the code, link up calls, and set the pointers on the Machine object.
     LinkBuffer patchBuffer(this, executablePool);
 
-#if ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
     patchBuffer.link(nativeCall, FunctionPtr(func));
-#endif
 
     CodeRef finalCode = patchBuffer.finalizeCode();
     return trampolineAt(finalCode, nativeCallThunk);
index 03354e1..9da3c40 100644 (file)
@@ -1808,7 +1808,7 @@ DEFINE_STUB_FUNCTION(void*, op_call_jitCompile)
     ASSERT(stackFrame.callFrame->callee()->getCallData(callData) == CallTypeJS);
 #endif
 
-    JSFunction* function = stackFrame.callFrame->callee();
+    JSFunction* function = asFunction(stackFrame.callFrame->callee());
     ASSERT(!function->isHostFunction());
     FunctionExecutable* executable = function->jsExecutable();
     ScopeChainNode* callDataScopeChain = function->scope().node();
@@ -1823,10 +1823,10 @@ DEFINE_STUB_FUNCTION(void*, op_construct_jitCompile)
 
 #if !ASSERT_DISABLED
     ConstructData constructData;
-    ASSERT(stackFrame.callFrame->callee()->getConstructData(constructData) == ConstructTypeJS);
+    ASSERT(asFunction(stackFrame.callFrame->callee())->getConstructData(constructData) == ConstructTypeJS);
 #endif
 
-    JSFunction* function = stackFrame.callFrame->callee();
+    JSFunction* function = asFunction(stackFrame.callFrame->callee());
     ASSERT(!function->isHostFunction());
     FunctionExecutable* executable = function->jsExecutable();
     ScopeChainNode* callDataScopeChain = function->scope().node();
@@ -1840,10 +1840,10 @@ DEFINE_STUB_FUNCTION(void*, op_call_arityCheck)
     STUB_INIT_STACK_FRAME(stackFrame);
 
     CallFrame* callFrame = stackFrame.callFrame;
-    JSFunction* callee = callFrame->callee();
+    JSFunction* callee = asFunction(callFrame->callee());
     ASSERT(!callee->isHostFunction());
     CodeBlock* newCodeBlock = &callee->jsExecutable()->generatedBytecodeForCall();
-    int argCount = callFrame->argumentCount();
+    int argCount = callFrame->argumentCountIncludingThis();
     ReturnAddressPtr pc = callFrame->returnPC();
 
     ASSERT(argCount != newCodeBlock->m_numParameters);
@@ -1885,7 +1885,7 @@ DEFINE_STUB_FUNCTION(void*, op_call_arityCheck)
 
     callFrame = CallFrame::create(r);
     callFrame->setCallerFrame(oldCallFrame);
-    callFrame->setArgumentCount(argCount);
+    callFrame->setArgumentCountIncludingThis(argCount);
     callFrame->setCallee(callee);
     callFrame->setScopeChain(callee->scope().node());
     callFrame->setReturnPC(pc.value());
@@ -1899,10 +1899,10 @@ DEFINE_STUB_FUNCTION(void*, op_construct_arityCheck)
     STUB_INIT_STACK_FRAME(stackFrame);
 
     CallFrame* callFrame = stackFrame.callFrame;
-    JSFunction* callee = callFrame->callee();
+    JSFunction* callee = asFunction(callFrame->callee());
     ASSERT(!callee->isHostFunction());
     CodeBlock* newCodeBlock = &callee->jsExecutable()->generatedBytecodeForConstruct();
-    int argCount = callFrame->argumentCount();
+    int argCount = callFrame->argumentCountIncludingThis();
     ReturnAddressPtr pc = callFrame->returnPC();
 
     ASSERT(argCount != newCodeBlock->m_numParameters);
@@ -1944,7 +1944,7 @@ DEFINE_STUB_FUNCTION(void*, op_construct_arityCheck)
 
     callFrame = CallFrame::create(r);
     callFrame->setCallerFrame(oldCallFrame);
-    callFrame->setArgumentCount(argCount);
+    callFrame->setArgumentCountIncludingThis(argCount);
     callFrame->setCallee(callee);
     callFrame->setScopeChain(callee->scope().node());
     callFrame->setReturnPC(pc.value());
@@ -1958,7 +1958,7 @@ DEFINE_STUB_FUNCTION(void*, vm_lazyLinkCall)
 {
     STUB_INIT_STACK_FRAME(stackFrame);
     CallFrame* callFrame = stackFrame.callFrame;
-    JSFunction* callee = callFrame->callee();
+    JSFunction* callee = asFunction(callFrame->callee());
     ExecutableBase* executable = callee->executable();
 
     MacroAssemblerCodePtr codePtr;
@@ -1969,7 +1969,7 @@ DEFINE_STUB_FUNCTION(void*, vm_lazyLinkCall)
         FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
         codeBlock = &functionExecutable->bytecodeForCall(stackFrame.callFrame, callee->scope().node());
         functionExecutable->jitCodeForCall(callFrame, callee->scope().node());
-        if (callFrame->argumentCount() == codeBlock->m_numParameters)
+        if (callFrame->argumentCountIncludingThis() == static_cast<size_t>(codeBlock->m_numParameters))
             codePtr = functionExecutable->generatedJITCodeForCall().addressForCall();
         else
             codePtr = functionExecutable->generatedJITCodeForCallWithArityCheck();
@@ -1979,7 +1979,7 @@ DEFINE_STUB_FUNCTION(void*, vm_lazyLinkCall)
     if (!callLinkInfo->seenOnce())
         callLinkInfo->setSeen();
     else
-        JIT::linkCall(callee, stackFrame.callFrame->callerFrame()->codeBlock(), codeBlock, codePtr, callLinkInfo, callFrame->argumentCount(), stackFrame.globalData);
+        JIT::linkCall(callee, stackFrame.callFrame->callerFrame()->codeBlock(), codeBlock, codePtr, callLinkInfo, callFrame->argumentCountIncludingThis(), stackFrame.globalData);
 
     return codePtr.executableAddress();
 }
@@ -1988,7 +1988,7 @@ DEFINE_STUB_FUNCTION(void*, vm_lazyLinkConstruct)
 {
     STUB_INIT_STACK_FRAME(stackFrame);
     CallFrame* callFrame = stackFrame.callFrame;
-    JSFunction* callee = callFrame->callee();
+    JSFunction* callee = asFunction(callFrame->callee());
     ExecutableBase* executable = callee->executable();
 
     MacroAssemblerCodePtr codePtr;
@@ -1999,7 +1999,7 @@ DEFINE_STUB_FUNCTION(void*, vm_lazyLinkConstruct)
         FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
         codeBlock = &functionExecutable->bytecodeForConstruct(stackFrame.callFrame, callee->scope().node());
         functionExecutable->jitCodeForConstruct(callFrame, callee->scope().node());
-        if (callFrame->argumentCount() == codeBlock->m_numParameters)
+        if (callFrame->argumentCountIncludingThis() == static_cast<size_t>(codeBlock->m_numParameters))
             codePtr = functionExecutable->generatedJITCodeForConstruct().addressForCall();
         else
             codePtr = functionExecutable->generatedJITCodeForConstructWithArityCheck();
@@ -2009,7 +2009,7 @@ DEFINE_STUB_FUNCTION(void*, vm_lazyLinkConstruct)
     if (!callLinkInfo->seenOnce())
         callLinkInfo->setSeen();
     else
-        JIT::linkConstruct(callee, stackFrame.callFrame->callerFrame()->codeBlock(), codeBlock, codePtr, callLinkInfo, callFrame->argumentCount(), stackFrame.globalData);
+        JIT::linkConstruct(callee, stackFrame.callFrame->callerFrame()->codeBlock(), codeBlock, codePtr, callLinkInfo, callFrame->argumentCountIncludingThis(), stackFrame.globalData);
 
     return codePtr.executableAddress();
 }
@@ -2041,22 +2041,13 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_call_NotJSFunction)
         CallFrame* previousCallFrame = stackFrame.callFrame;
         CallFrame* callFrame = CallFrame::create(previousCallFrame->registers() + registerOffset);
 
-        callFrame->init(0, static_cast<Instruction*>((STUB_RETURN_ADDRESS).value()), previousCallFrame->scopeChain(), previousCallFrame, 0, argCount, 0);
+        callFrame->init(0, static_cast<Instruction*>((STUB_RETURN_ADDRESS).value()), previousCallFrame->scopeChain(), previousCallFrame, argCount, asObject(funcVal));
         stackFrame.callFrame = callFrame;
 
-        Register* argv = stackFrame.callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
-        ArgList argList(argv + 1, argCount - 1);
-
         JSValue returnValue;
         {
             SamplingTool::HostCallRecord callRecord(CTI_SAMPLER);
-
-            // FIXME: All host methods should be calling toThisObject, but this is not presently the case.
-            JSValue thisValue = argv[0].jsValue();
-            if (thisValue == jsNull())
-                thisValue = callFrame->globalThisValue();
-
-            returnValue = callData.native.function(callFrame, asObject(funcVal), thisValue, argList);
+            returnValue = callData.native.function(callFrame);
         }
         stackFrame.callFrame = previousCallFrame;
         CHECK_FOR_EXCEPTION();
@@ -2447,7 +2438,7 @@ DEFINE_STUB_FUNCTION(int, op_load_varargs)
             stackFrame.globalData->exception = createStackOverflowError(callFrame);
             VM_THROW_EXCEPTION();
         }
-        int32_t expectedParams = callFrame->callee()->jsExecutable()->parameterCount();
+        int32_t expectedParams = asFunction(callFrame->callee())->jsExecutable()->parameterCount();
         int32_t inplaceArgs = min(providedParams, expectedParams);
         
         Register* inplaceArgsDst = callFrame->registers() + argsOffset;
@@ -3034,10 +3025,10 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_call_eval)
 
     Register* newCallFrame = callFrame->registers() + registerOffset;
     Register* argv = newCallFrame - RegisterFile::CallFrameHeaderSize - argCount;
-    JSValue thisValue = argv[0].jsValue();
+    JSValue baseValue = argv[0].jsValue();
     JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject;
 
-    if (thisValue == globalObject && funcVal == globalObject->evalFunction()) {
+    if (baseValue == globalObject && funcVal == globalObject->evalFunction()) {
         JSValue exceptionValue;
         JSValue result = interpreter->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
         if (UNLIKELY(exceptionValue)) {
index 46eaccc..35ac7f4 100644 (file)
@@ -71,19 +71,19 @@ using namespace WTF;
 static void cleanupGlobalData(JSGlobalData*);
 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
 
-static JSValue JSC_HOST_CALL functionPrint(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionDebug(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionGC(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionVersion(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionRun(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionLoad(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionCheckSyntax(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionReadline(ExecState*, JSObject*, JSValue, const ArgList&);
-static NO_RETURN_WITH_VALUE JSValue JSC_HOST_CALL functionQuit(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL functionPrint(ExecState*);
+static JSValue JSC_HOST_CALL functionDebug(ExecState*);
+static JSValue JSC_HOST_CALL functionGC(ExecState*);
+static JSValue JSC_HOST_CALL functionVersion(ExecState*);
+static JSValue JSC_HOST_CALL functionRun(ExecState*);
+static JSValue JSC_HOST_CALL functionLoad(ExecState*);
+static JSValue JSC_HOST_CALL functionCheckSyntax(ExecState*);
+static JSValue JSC_HOST_CALL functionReadline(ExecState*);
+static NO_RETURN_WITH_VALUE JSValue JSC_HOST_CALL functionQuit(ExecState*);
 
 #if ENABLE(SAMPLING_FLAGS)
-static JSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*);
+static JSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState*);
 #endif
 
 struct Script {
@@ -171,13 +171,13 @@ GlobalObject::GlobalObject(const Vector<UString>& arguments)
     putDirect(Identifier(globalExec(), "arguments"), array);
 }
 
-JSValue JSC_HOST_CALL functionPrint(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL functionPrint(ExecState* exec)
 {
-    for (unsigned i = 0; i < args.size(); ++i) {
+    for (unsigned i = 0; i < exec->argumentCount(); ++i) {
         if (i)
             putchar(' ');
 
-        printf("%s", args.at(i).toString(exec).UTF8String().data());
+        printf("%s", exec->argument(i).toString(exec).UTF8String().data());
     }
 
     putchar('\n');
@@ -185,30 +185,30 @@ JSValue JSC_HOST_CALL functionPrint(ExecState* exec, JSObject*, JSValue, const A
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL functionDebug(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL functionDebug(ExecState* exec)
 {
-    fprintf(stderr, "--> %s\n", args.at(0).toString(exec).UTF8String().data());
+    fprintf(stderr, "--> %s\n", exec->argument(0).toString(exec).UTF8String().data());
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL functionGC(ExecState* exec, JSObject*, JSValue, const ArgList&)
+JSValue JSC_HOST_CALL functionGC(ExecState* exec)
 {
     JSLock lock(SilenceAssertionsOnly);
     exec->heap()->collectAllGarbage();
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL functionVersion(ExecState*, JSObject*, JSValue, const ArgList&)
+JSValue JSC_HOST_CALL functionVersion(ExecState*)
 {
     // We need this function for compatibility with the Mozilla JS tests but for now
     // we don't actually do any version-specific handling
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL functionRun(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL functionRun(ExecState* exec)
 {
     StopWatch stopWatch;
-    UString fileName = args.at(0).toString(exec);
+    UString fileName = exec->argument(0).toString(exec);
     Vector<char> script;
     if (!fillBufferWithContentsOfFile(fileName, script))
         return throwError(exec, GeneralError, "Could not open file.");
@@ -222,11 +222,9 @@ JSValue JSC_HOST_CALL functionRun(ExecState* exec, JSObject*, JSValue, const Arg
     return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS());
 }
 
-JSValue JSC_HOST_CALL functionLoad(ExecState* exec, JSObject* o, JSValue v, const ArgList& args)
+JSValue JSC_HOST_CALL functionLoad(ExecState* exec)
 {
-    UNUSED_PARAM(o);
-    UNUSED_PARAM(v);
-    UString fileName = args.at(0).toString(exec);
+    UString fileName = exec->argument(0).toString(exec);
     Vector<char> script;
     if (!fillBufferWithContentsOfFile(fileName, script))
         return throwError(exec, GeneralError, "Could not open file.");
@@ -238,11 +236,9 @@ JSValue JSC_HOST_CALL functionLoad(ExecState* exec, JSObject* o, JSValue v, cons
     return result.value();
 }
 
-JSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec, JSObject* o, JSValue v, const ArgList& args)
+JSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec)
 {
-    UNUSED_PARAM(o);
-    UNUSED_PARAM(v);
-    UString fileName = args.at(0).toString(exec);
+    UString fileName = exec->argument(0).toString(exec);
     Vector<char> script;
     if (!fillBufferWithContentsOfFile(fileName, script))
         return throwError(exec, GeneralError, "Could not open file.");
@@ -255,20 +251,20 @@ JSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec, JSObject* o, JSValue
 }
 
 #if ENABLE(SAMPLING_FLAGS)
-JSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState* exec)
 {
-    for (unsigned i = 0; i < args.size(); ++i) {
-        unsigned flag = static_cast<unsigned>(args.at(i).toNumber(exec));
+    for (unsigned i = 0; i < exec->argumentCount(); ++i) {
+        unsigned flag = static_cast<unsigned>(exec->argument(i).toNumber(exec));
         if ((flag >= 1) && (flag <= 32))
             SamplingFlags::setFlag(flag);
     }
     return jsNull();
 }
 
-JSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec)
 {
-    for (unsigned i = 0; i < args.size(); ++i) {
-        unsigned flag = static_cast<unsigned>(args.at(i).toNumber(exec));
+    for (unsigned i = 0; i < exec->argumentCount(); ++i) {
+        unsigned flag = static_cast<unsigned>(exec->argument(i).toNumber(exec));
         if ((flag >= 1) && (flag <= 32))
             SamplingFlags::clearFlag(flag);
     }
@@ -276,7 +272,7 @@ JSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec, JSObject*, JSV
 }
 #endif
 
-JSValue JSC_HOST_CALL functionReadline(ExecState* exec, JSObject*, JSValue, const ArgList&)
+JSValue JSC_HOST_CALL functionReadline(ExecState* exec)
 {
     Vector<char, 256> line;
     int c;
@@ -290,7 +286,7 @@ JSValue JSC_HOST_CALL functionReadline(ExecState* exec, JSObject*, JSValue, cons
     return jsString(exec, line.data());
 }
 
-JSValue JSC_HOST_CALL functionQuit(ExecState* exec, JSObject*, JSValue, const ArgList&)
+JSValue JSC_HOST_CALL functionQuit(ExecState* exec)
 {
     // Technically, destroying the heap in the middle of JS execution is a no-no,
     // but we want to maintain compatibility with the Mozilla test suite, so
index 8e1fdbe..cd563a2 100644 (file)
@@ -22,6 +22,7 @@
 #ifndef ArgList_h
 #define ArgList_h
 
+#include "CallFrame.h"
 #include "Register.h"
 #include <wtf/HashSet.h>
 #include <wtf/Noncopyable.h>
@@ -187,6 +188,12 @@ namespace JSC {
         {
         }
         
+        ArgList(ExecState* exec)
+            : m_args(reinterpret_cast<JSValue*>(&exec[exec->hostThisRegister() + 1]))
+            , m_argCount(exec->argumentCount())
+        {
+        }
+        
         ArgList(JSValue* args, unsigned argCount)
             : m_args(args)
             , m_argCount(argCount)
index 5b8e51c..169c6f6 100644 (file)
@@ -119,10 +119,10 @@ namespace JSC {
 
     ALWAYS_INLINE void Arguments::getArgumentsData(CallFrame* callFrame, JSFunction*& function, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc)
     {
-        function = callFrame->callee();
+        function = asFunction(callFrame->callee());
 
         int numParameters = function->jsExecutable()->parameterCount();
-        argc = callFrame->argumentCount();
+        argc = callFrame->argumentCountIncludingThis();
 
         if (argc <= numParameters)
             argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numParameters;
@@ -174,9 +174,9 @@ namespace JSC {
         : JSObject(callFrame->lexicalGlobalObject()->argumentsStructure())
         , d(new ArgumentsData)
     {
-        ASSERT(!callFrame->callee()->jsExecutable()->parameterCount());
+        ASSERT(!asFunction(callFrame->callee())->jsExecutable()->parameterCount());
 
-        unsigned numArguments = callFrame->argumentCount() - 1;
+        unsigned numArguments = callFrame->argumentCount();
 
         d->numParameters = 0;
         d->numArguments = numArguments;
@@ -194,7 +194,7 @@ namespace JSC {
 
         d->extraArguments = extraArguments;
 
-        d->callee = callFrame->callee();
+        d->callee = asFunction(callFrame->callee());
         d->overrodeLength = false;
         d->overrodeCallee = false;
     }
index c159be4..674d00a 100644 (file)
@@ -35,7 +35,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ArrayConstructor);
     
-static JSValue JSC_HOST_CALL arrayConstructorIsArray(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL arrayConstructorIsArray(ExecState*);
 
 ArrayConstructor::ArrayConstructor(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, ArrayPrototype* arrayPrototype, Structure* prototypeFunctionStructure)
     : InternalFunction(&exec->globalData(), globalObject, structure, Identifier(exec, arrayPrototype->classInfo()->className))
@@ -76,8 +76,9 @@ ConstructType ArrayConstructor::getConstructData(ConstructData& constructData)
     return ConstructTypeHost;
 }
 
-static JSValue JSC_HOST_CALL callArrayConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callArrayConstructor(ExecState* exec)
 {
+    ArgList args(exec);
     return constructArrayWithSizeQuirk(exec, args);
 }
 
@@ -89,9 +90,9 @@ CallType ArrayConstructor::getCallData(CallData& callData)
     return CallTypeHost;
 }
 
-JSValue JSC_HOST_CALL arrayConstructorIsArray(ExecState*, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayConstructorIsArray(ExecState* exec)
 {
-    return jsBoolean(args.at(0).inherits(&JSArray::info));
+    return jsBoolean(exec->argument(0).inherits(&JSArray::info));
 }
 
 } // namespace JSC
index 70ce69f..c7dea3b 100644 (file)
@@ -40,27 +40,27 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ArrayPrototype);
 
-static JSValue JSC_HOST_CALL arrayProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncToLocaleString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncConcat(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncJoin(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncPop(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncPush(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncReverse(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncShift(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncSort(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncUnShift(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncEvery(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncForEach(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncSome(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncIndexOf(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncFilter(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncMap(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncReduce(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncReduceRight(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL arrayProtoFuncLastIndexOf(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL arrayProtoFuncToString(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncToLocaleString(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncConcat(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncJoin(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncPop(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncPush(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncReverse(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncShift(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncSort(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncUnShift(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncEvery(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncForEach(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncSome(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncIndexOf(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncFilter(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncMap(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncReduce(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncReduceRight(ExecState*);
+static JSValue JSC_HOST_CALL arrayProtoFuncLastIndexOf(ExecState*);
 
 }
 
@@ -149,8 +149,9 @@ static void putProperty(ExecState* exec, JSObject* obj, const Identifier& proper
     obj->put(exec, propertyName, value, slot);
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL arrayProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     bool isRealArray = isJSArray(&exec->globalData(), thisValue);
     if (!isRealArray && !thisValue.inherits(&JSArray::info))
         return throwError(exec, TypeError);
@@ -208,8 +209,9 @@ JSValue JSC_HOST_CALL arrayProtoFuncToString(ExecState* exec, JSObject*, JSValue
     return jsString(exec, UString::adopt(buffer));
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncToLocaleString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL arrayProtoFuncToLocaleString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&JSArray::info))
         return throwError(exec, TypeError);
     JSObject* thisObj = asArray(thisValue);
@@ -248,8 +250,9 @@ JSValue JSC_HOST_CALL arrayProtoFuncToLocaleString(ExecState* exec, JSObject*, J
     return strBuffer.build(exec);
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncJoin(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncJoin(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
     HashSet<JSObject*>& arrayVisitedElements = exec->globalData().arrayVisitedElements;
@@ -265,8 +268,8 @@ JSValue JSC_HOST_CALL arrayProtoFuncJoin(ExecState* exec, JSObject*, JSValue thi
     JSStringBuilder strBuffer;
 
     UString separator;
-    if (!args.at(0).isUndefined())
-        separator = args.at(0).toString(exec);
+    if (!exec->argument(0).isUndefined())
+        separator = exec->argument(0).toString(exec);
 
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
     unsigned k = 0;
@@ -319,13 +322,14 @@ JSValue JSC_HOST_CALL arrayProtoFuncJoin(ExecState* exec, JSObject*, JSValue thi
     return strBuffer.build(exec);
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncConcat(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncConcat(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSArray* arr = constructEmptyArray(exec);
     int n = 0;
     JSValue curArg = thisValue.toThisObject(exec);
-    ArgList::const_iterator it = args.begin();
-    ArgList::const_iterator end = args.end();
+    size_t i = 0;
+    size_t argCount = exec->argumentCount();
     while (1) {
         if (curArg.inherits(&JSArray::info)) {
             unsigned length = curArg.get(exec, exec->propertyNames().length).toUInt32(exec);
@@ -339,17 +343,18 @@ JSValue JSC_HOST_CALL arrayProtoFuncConcat(ExecState* exec, JSObject*, JSValue t
             arr->put(exec, n, curArg);
             n++;
         }
-        if (it == end)
+        if (i == argCount)
             break;
-        curArg = (*it);
-        ++it;
+        curArg = (exec->argument(i));
+        ++i;
     }
     arr->setLength(n);
     return arr;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncPop(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL arrayProtoFuncPop(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (isJSArray(&exec->globalData(), thisValue))
         return asArray(thisValue)->pop();
 
@@ -367,25 +372,27 @@ JSValue JSC_HOST_CALL arrayProtoFuncPop(ExecState* exec, JSObject*, JSValue this
     return result;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncPush(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncPush(ExecState* exec)
 {
-    if (isJSArray(&exec->globalData(), thisValue) && args.size() == 1) {
+    JSValue thisValue = exec->hostThisValue();
+    if (isJSArray(&exec->globalData(), thisValue) && exec->argumentCount() == 1) {
         JSArray* array = asArray(thisValue);
-        array->push(exec, *args.begin());
+        array->push(exec, exec->argument(0));
         return jsNumber(exec, array->length());
     }
 
     JSObject* thisObj = thisValue.toThisObject(exec);
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
-    for (unsigned n = 0; n < args.size(); n++)
-        thisObj->put(exec, length + n, args.at(n));
-    length += args.size();
+    for (unsigned n = 0; n < exec->argumentCount(); n++)
+        thisObj->put(exec, length + n, exec->argument(n));
+    length += exec->argumentCount();
     putProperty(exec, thisObj, exec->propertyNames().length, jsNumber(exec, length));
     return jsNumber(exec, length);
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncReverse(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL arrayProtoFuncReverse(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
     unsigned middle = length / 2;
@@ -408,8 +415,9 @@ JSValue JSC_HOST_CALL arrayProtoFuncReverse(ExecState* exec, JSObject*, JSValue
     return thisObj;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncShift(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL arrayProtoFuncShift(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
     JSValue result;
 
@@ -431,8 +439,9 @@ JSValue JSC_HOST_CALL arrayProtoFuncShift(ExecState* exec, JSObject*, JSValue th
     return result;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     // http://developer.netscape.com/docs/manuals/js/client/jsref/array.htm#1193713 or 15.4.4.10
 
     JSObject* thisObj = thisValue.toThisObject(exec);
@@ -440,7 +449,7 @@ JSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState* exec, JSObject*, JSValue th
     // We return a new array
     JSArray* resObj = constructEmptyArray(exec);
     JSValue result = resObj;
-    double begin = args.at(0).toInteger(exec);
+    double begin = exec->argument(0).toInteger(exec);
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
     if (begin >= 0) {
         if (begin > length)
@@ -451,10 +460,10 @@ JSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState* exec, JSObject*, JSValue th
             begin = 0;
     }
     double end;
-    if (args.at(1).isUndefined())
+    if (exec->argument(1).isUndefined())
         end = length;
     else {
-        end = args.at(1).toInteger(exec);
+        end = exec->argument(1).toInteger(exec);
         if (end < 0) {
             end += length;
             if (end < 0)
@@ -476,11 +485,12 @@ JSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState* exec, JSObject*, JSValue th
     return result;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncSort(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncSort(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
 
@@ -534,8 +544,9 @@ JSValue JSC_HOST_CALL arrayProtoFuncSort(ExecState* exec, JSObject*, JSValue thi
     return thisObj;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
     // 15.4.4.12
@@ -543,11 +554,11 @@ JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState* exec, JSObject*, JSValue t
     JSValue result = resObj;
 
     // FIXME: Firefox returns an empty array.
-    if (!args.size())
+    if (!exec->argumentCount())
         return jsUndefined();
 
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
-    double relativeBegin = args.at(0).toInteger(exec);
+    double relativeBegin = exec->argument(0).toInteger(exec);
     unsigned begin;
     if (relativeBegin < 0) {
         relativeBegin += length;
@@ -556,8 +567,8 @@ JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState* exec, JSObject*, JSValue t
         begin = std::min<unsigned>(static_cast<unsigned>(relativeBegin), length);
 
     unsigned deleteCount;
-    if (args.size() > 1)
-        deleteCount = std::min<int>(std::max<int>(args.at(1).toUInt32(exec), 0), length - begin);
+    if (exec->argumentCount() > 1)
+        deleteCount = std::min<int>(std::max<int>(exec->argument(1).toUInt32(exec), 0), length - begin);
     else
         deleteCount = length - begin;
 
@@ -567,7 +578,7 @@ JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState* exec, JSObject*, JSValue t
     }
     resObj->setLength(deleteCount);
 
-    unsigned additionalArgs = std::max<int>(args.size() - 2, 0);
+    unsigned additionalArgs = std::max<int>(exec->argumentCount() - 2, 0);
     if (additionalArgs != deleteCount) {
         if (additionalArgs < deleteCount) {
             for (unsigned k = begin; k < length - deleteCount; ++k) {
@@ -588,19 +599,20 @@ JSValue JSC_HOST_CALL arrayProtoFuncSplice(ExecState* exec, JSObject*, JSValue t
         }
     }
     for (unsigned k = 0; k < additionalArgs; ++k)
-        thisObj->put(exec, k + begin, args.at(k + 2));
+        thisObj->put(exec, k + begin, exec->argument(k + 2));
 
     putProperty(exec, thisObj, exec->propertyNames().length, jsNumber(exec, length - deleteCount + additionalArgs));
     return result;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncUnShift(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncUnShift(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
     // 15.4.4.13
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
-    unsigned nrArgs = args.size();
+    unsigned nrArgs = exec->argumentCount();
     if (nrArgs) {
         for (unsigned k = length; k > 0; --k) {
             if (JSValue v = getProperty(exec, thisObj, k - 1))
@@ -610,23 +622,24 @@ JSValue JSC_HOST_CALL arrayProtoFuncUnShift(ExecState* exec, JSObject*, JSValue
         }
     }
     for (unsigned k = 0; k < nrArgs; ++k)
-        thisObj->put(exec, k, args.at(k));
+        thisObj->put(exec, k, exec->argument(k));
     JSValue result = jsNumber(exec, length + nrArgs);
     putProperty(exec, thisObj, exec->propertyNames().length, result);
     return result;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncFilter(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncFilter(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
         return throwError(exec, TypeError);
 
-    JSObject* applyThis = args.at(1).isUndefinedOrNull() ? exec->globalThisValue() : args.at(1).toObject(exec);
+    JSObject* applyThis = exec->argument(1).isUndefinedOrNull() ? exec->globalThisValue() : exec->argument(1).toObject(exec);
     JSArray* resultArray = constructEmptyArray(exec);
 
     unsigned filterIndex = 0;
@@ -674,17 +687,18 @@ JSValue JSC_HOST_CALL arrayProtoFuncFilter(ExecState* exec, JSObject*, JSValue t
     return resultArray;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncMap(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncMap(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
         return throwError(exec, TypeError);
 
-    JSObject* applyThis = args.at(1).isUndefinedOrNull() ? exec->globalThisValue() : args.at(1).toObject(exec);
+    JSObject* applyThis = exec->argument(1).isUndefinedOrNull() ? exec->globalThisValue() : exec->argument(1).toObject(exec);
 
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
 
@@ -731,17 +745,18 @@ JSValue JSC_HOST_CALL arrayProtoFuncMap(ExecState* exec, JSObject*, JSValue this
 // http://developer-test.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:forEach
 // http://developer-test.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:some
 
-JSValue JSC_HOST_CALL arrayProtoFuncEvery(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncEvery(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
         return throwError(exec, TypeError);
 
-    JSObject* applyThis = args.at(1).isUndefinedOrNull() ? exec->globalThisValue() : args.at(1).toObject(exec);
+    JSObject* applyThis = exec->argument(1).isUndefinedOrNull() ? exec->globalThisValue() : exec->argument(1).toObject(exec);
 
     JSValue result = jsBoolean(true);
 
@@ -787,17 +802,18 @@ JSValue JSC_HOST_CALL arrayProtoFuncEvery(ExecState* exec, JSObject*, JSValue th
     return result;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncForEach(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncForEach(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
         return throwError(exec, TypeError);
 
-    JSObject* applyThis = args.at(1).isUndefinedOrNull() ? exec->globalThisValue() : args.at(1).toObject(exec);
+    JSObject* applyThis = exec->argument(1).isUndefinedOrNull() ? exec->globalThisValue() : exec->argument(1).toObject(exec);
 
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
     unsigned k = 0;
@@ -832,17 +848,18 @@ JSValue JSC_HOST_CALL arrayProtoFuncForEach(ExecState* exec, JSObject*, JSValue
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncSome(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncSome(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
         return throwError(exec, TypeError);
 
-    JSObject* applyThis = args.at(1).isUndefinedOrNull() ? exec->globalThisValue() : args.at(1).toObject(exec);
+    JSObject* applyThis = exec->argument(1).isUndefinedOrNull() ? exec->globalThisValue() : exec->argument(1).toObject(exec);
 
     JSValue result = jsBoolean(false);
 
@@ -885,11 +902,12 @@ JSValue JSC_HOST_CALL arrayProtoFuncSome(ExecState* exec, JSObject*, JSValue thi
     return result;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncReduce(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncReduce(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
     
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
@@ -898,14 +916,14 @@ JSValue JSC_HOST_CALL arrayProtoFuncReduce(ExecState* exec, JSObject*, JSValue t
     unsigned i = 0;
     JSValue rv;
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
-    if (!length && args.size() == 1)
+    if (!length && exec->argumentCount() == 1)
         return throwError(exec, TypeError);
     JSArray* array = 0;
     if (isJSArray(&exec->globalData(), thisObj))
         array = asArray(thisObj);
 
-    if (args.size() >= 2)
-        rv = args.at(1);
+    if (exec->argumentCount() >= 2)
+        rv = exec->argument(1);
     else if (array && array->canGetIndex(0)){
         rv = array->getIndex(0);
         i = 1;
@@ -955,11 +973,12 @@ JSValue JSC_HOST_CALL arrayProtoFuncReduce(ExecState* exec, JSObject*, JSValue t
     return rv;
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncReduceRight(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncReduceRight(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
     
-    JSValue function = args.at(0);
+    JSValue function = exec->argument(0);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
@@ -968,14 +987,14 @@ JSValue JSC_HOST_CALL arrayProtoFuncReduceRight(ExecState* exec, JSObject*, JSVa
     unsigned i = 0;
     JSValue rv;
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
-    if (!length && args.size() == 1)
+    if (!length && exec->argumentCount() == 1)
         return throwError(exec, TypeError);
     JSArray* array = 0;
     if (isJSArray(&exec->globalData(), thisObj))
         array = asArray(thisObj);
     
-    if (args.size() >= 2)
-        rv = args.at(1);
+    if (exec->argumentCount() >= 2)
+        rv = exec->argument(1);
     else if (array && array->canGetIndex(length - 1)){
         rv = array->getIndex(length - 1);
         i = 1;
@@ -1024,15 +1043,16 @@ JSValue JSC_HOST_CALL arrayProtoFuncReduceRight(ExecState* exec, JSObject*, JSVa
     return rv;        
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncIndexOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncIndexOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     // JavaScript 1.5 Extension by Mozilla
     // Documentation: http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf
 
     JSObject* thisObj = thisValue.toThisObject(exec);
 
     unsigned index = 0;
-    double d = args.at(1).toInteger(exec);
+    double d = exec->argument(1).toInteger(exec);
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
     if (d < 0)
         d += length;
@@ -1043,7 +1063,7 @@ JSValue JSC_HOST_CALL arrayProtoFuncIndexOf(ExecState* exec, JSObject*, JSValue
             index = static_cast<unsigned>(d);
     }
 
-    JSValue searchElement = args.at(0);
+    JSValue searchElement = exec->argument(0);
     for (; index < length; ++index) {
         JSValue e = getProperty(exec, thisObj, index);
         if (!e)
@@ -1055,8 +1075,9 @@ JSValue JSC_HOST_CALL arrayProtoFuncIndexOf(ExecState* exec, JSObject*, JSValue
     return jsNumber(exec, -1);
 }
 
-JSValue JSC_HOST_CALL arrayProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL arrayProtoFuncLastIndexOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     // JavaScript 1.6 Extension by Mozilla
     // Documentation: http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf
 
@@ -1064,7 +1085,7 @@ JSValue JSC_HOST_CALL arrayProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSVa
 
     unsigned length = thisObj->get(exec, exec->propertyNames().length).toUInt32(exec);
     int index = length - 1;
-    double d = args.at(1).toIntegerPreserveNaN(exec);
+    double d = exec->argument(1).toIntegerPreserveNaN(exec);
 
     if (d < 0) {
         d += length;
@@ -1074,7 +1095,7 @@ JSValue JSC_HOST_CALL arrayProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSVa
     if (d < length)
         index = static_cast<int>(d);
 
-    JSValue searchElement = args.at(0);
+    JSValue searchElement = exec->argument(0);
     for (; index >= 0; --index) {
         JSValue e = getProperty(exec, thisObj, index);
         if (!e)
index 07bcc97..bc12858 100644 (file)
@@ -57,9 +57,9 @@ ConstructType BooleanConstructor::getConstructData(ConstructData& constructData)
 }
 
 // ECMA 15.6.1
-static JSValue JSC_HOST_CALL callBooleanConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callBooleanConstructor(ExecState* exec)
 {
-    return jsBoolean(args.at(0).toBoolean(exec));
+    return jsBoolean(exec->argument(0).toBoolean(exec));
 }
 
 CallType BooleanConstructor::getCallData(CallData& callData)
index 4378164..dbb27b2 100644 (file)
@@ -32,8 +32,8 @@ namespace JSC {
 ASSERT_CLASS_FITS_IN_CELL(BooleanPrototype);
 
 // Functions
-static JSValue JSC_HOST_CALL booleanProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL booleanProtoFuncValueOf(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL booleanProtoFuncToString(ExecState*);
+static JSValue JSC_HOST_CALL booleanProtoFuncValueOf(ExecState*);
 
 // ECMA 15.6.4
 
@@ -51,8 +51,9 @@ BooleanPrototype::BooleanPrototype(ExecState* exec, JSGlobalObject* globalObject
 
 // ECMA 15.6.4.2 + 15.6.4.3
 
-JSValue JSC_HOST_CALL booleanProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL booleanProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (thisValue == jsBoolean(false))
         return jsNontrivialString(exec, "false");
 
@@ -69,8 +70,9 @@ JSValue JSC_HOST_CALL booleanProtoFuncToString(ExecState* exec, JSObject*, JSVal
     return jsNontrivialString(exec, "true");
 }
 
-JSValue JSC_HOST_CALL booleanProtoFuncValueOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL booleanProtoFuncValueOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (thisValue.isBoolean())
         return thisValue;
 
index 62e42fe..2b9302a 100644 (file)
 #include "config.h"
 #include "CallData.h"
 
+#include "Executable.h"
+#include "Interpreter.h"
 #include "JSFunction.h"
 
 namespace JSC {
 
 JSValue call(ExecState* exec, JSValue functionObject, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args)
 {
-    if (callType == CallTypeHost)
-        return callData.native.function(exec, asObject(functionObject), thisValue, args);
-    ASSERT(callType == CallTypeJS);
-    // FIXME: Can this be done more efficiently using the callData?
-    return asFunction(functionObject)->call(exec, thisValue, args);
+    ASSERT(callType == CallTypeJS || callType == CallTypeHost);
+    return exec->interpreter()->executeCall(exec, asObject(functionObject), callType, callData, thisValue, args, exec->exceptionSlot());
 }
 
 } // namespace JSC
index 24c19f9..5294e54 100644 (file)
@@ -46,7 +46,7 @@ namespace JSC {
         CallTypeJS
     };
 
-    typedef JSValue (JSC_HOST_CALL *NativeFunction)(ExecState*, JSObject*, JSValue thisValue, const ArgList&);
+    typedef JSValue (JSC_HOST_CALL *NativeFunction)(ExecState*);
 
     union CallData {
         struct {
index 7ee59d7..a7b97e6 100644 (file)
 #include "config.h"
 #include "ConstructData.h"
 
+#include "Executable.h"
+#include "Interpreter.h"
 #include "JSFunction.h"
+#include "JSGlobalObject.h"
 
 namespace JSC {
 
@@ -34,9 +37,23 @@ JSObject* construct(ExecState* exec, JSValue object, ConstructType constructType
 {
     if (constructType == ConstructTypeHost)
         return constructData.native.function(exec, asObject(object), args);
+
     ASSERT(constructType == ConstructTypeJS);
-    // FIXME: Can this be done more efficiently using the constructData?
-    return asFunction(object)->construct(exec, args);
+    JSFunction* jsFunction = asFunction(object);
+
+    ASSERT(!jsFunction->isHostFunction());
+    Structure* structure;
+    JSValue prototype = jsFunction->get(exec, exec->propertyNames().prototype);
+    if (prototype.isObject())
+        structure = asObject(prototype)->inheritorID();
+    else
+        structure = exec->lexicalGlobalObject()->emptyObjectStructure();
+    JSObject* thisObj = new (exec) JSObject(structure);
+
+    JSValue result = exec->interpreter()->executeConstruct(jsFunction->jsExecutable(), exec, jsFunction, thisObj, args, jsFunction->scope().node(), exec->exceptionSlot());
+    if (exec->hadException() || !result.isObject())
+        return thisObj;
+    return asObject(result);
 }
 
 } // namespace JSC
index d732a4f..015a01a 100644 (file)
@@ -54,9 +54,9 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(DateConstructor);
 
-static JSValue JSC_HOST_CALL dateParse(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateNow(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateUTC(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL dateParse(ExecState*);
+static JSValue JSC_HOST_CALL dateNow(ExecState*);
+static JSValue JSC_HOST_CALL dateUTC(ExecState*);
 
 DateConstructor::DateConstructor(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, Structure* prototypeFunctionStructure, DatePrototype* datePrototype)
     : InternalFunction(&exec->globalData(), globalObject, structure, Identifier(exec, datePrototype->classInfo()->className))
@@ -128,7 +128,7 @@ ConstructType DateConstructor::getConstructData(ConstructData& constructData)
 }
 
 // ECMA 15.9.2
-static JSValue JSC_HOST_CALL callDate(ExecState* exec, JSObject*, JSValue, const ArgList&)
+static JSValue JSC_HOST_CALL callDate(ExecState* exec)
 {
     time_t localTime = time(0);
     tm localTM;
@@ -147,37 +147,37 @@ CallType DateConstructor::getCallData(CallData& callData)
     return CallTypeHost;
 }
 
-static JSValue JSC_HOST_CALL dateParse(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL dateParse(ExecState* exec)
 {
-    return jsNumber(exec, parseDate(exec, args.at(0).toString(exec)));
+    return jsNumber(exec, parseDate(exec, exec->argument(0).toString(exec)));
 }
 
-static JSValue JSC_HOST_CALL dateNow(ExecState* exec, JSObject*, JSValue, const ArgList&)
+static JSValue JSC_HOST_CALL dateNow(ExecState* exec)
 {
     return jsNumber(exec, jsCurrentTime());
 }
 
-static JSValue JSC_HOST_CALL dateUTC(ExecState* exec, JSObject*, JSValue, const ArgList& args
+static JSValue JSC_HOST_CALL dateUTC(ExecState* exec) 
 {
-    int n = args.size();
-    if (isnan(args.at(0).toNumber(exec))
-            || isnan(args.at(1).toNumber(exec))
-            || (n >= 3 && isnan(args.at(2).toNumber(exec)))
-            || (n >= 4 && isnan(args.at(3).toNumber(exec)))
-            || (n >= 5 && isnan(args.at(4).toNumber(exec)))
-            || (n >= 6 && isnan(args.at(5).toNumber(exec)))
-            || (n >= 7 && isnan(args.at(6).toNumber(exec))))
+    int n = exec->argumentCount();
+    if (isnan(exec->argument(0).toNumber(exec))
+            || isnan(exec->argument(1).toNumber(exec))
+            || (n >= 3 && isnan(exec->argument(2).toNumber(exec)))
+            || (n >= 4 && isnan(exec->argument(3).toNumber(exec)))
+            || (n >= 5 && isnan(exec->argument(4).toNumber(exec)))
+            || (n >= 6 && isnan(exec->argument(5).toNumber(exec)))
+            || (n >= 7 && isnan(exec->argument(6).toNumber(exec))))
         return jsNaN(exec);
 
     GregorianDateTime t;
-    int year = args.at(0).toInt32(exec);
+    int year = exec->argument(0).toInt32(exec);
     t.year = (year >= 0 && year <= 99) ? year : year - 1900;
-    t.month = args.at(1).toInt32(exec);
-    t.monthDay = (n >= 3) ? args.at(2).toInt32(exec) : 1;
-    t.hour = args.at(3).toInt32(exec);
-    t.minute = args.at(4).toInt32(exec);
-    t.second = args.at(5).toInt32(exec);
-    double ms = (n >= 7) ? args.at(6).toNumber(exec) : 0;
+    t.month = exec->argument(1).toInt32(exec);
+    t.monthDay = (n >= 3) ? exec->argument(2).toInt32(exec) : 1;
+    t.hour = exec->argument(3).toInt32(exec);
+    t.minute = exec->argument(4).toInt32(exec);
+    t.second = exec->argument(5).toInt32(exec);
+    double ms = (n >= 7) ? exec->argument(6).toNumber(exec) : 0;
     return jsNumber(exec, timeClip(gregorianDateTimeToMS(exec, t, ms, true)));
 }
 
index a5dfabd..c31a4d0 100644 (file)
@@ -73,52 +73,51 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(DatePrototype);
 
-static JSValue JSC_HOST_CALL dateProtoFuncGetDate(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetDay(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetFullYear(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetHours(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetMilliSeconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetMinutes(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetMonth(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetSeconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetTime(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetTimezoneOffset(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCDate(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCDay(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCFullYear(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCHours(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCMilliseconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCMinutes(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCMonth(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetUTCSeconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncGetYear(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetDate(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetFullYear(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetHours(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetMilliSeconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetMinutes(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetMonth(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetSeconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetTime(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetUTCDate(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetUTCFullYear(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetUTCHours(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetUTCMilliseconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetUTCMinutes(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetUTCMonth(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetUTCSeconds(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncSetYear(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToDateString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToGMTString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToLocaleDateString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToLocaleString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToLocaleTimeString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToTimeString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToUTCString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL dateProtoFuncToISOString(ExecState*, JSObject*, JSValue, const ArgList&);
-
-static JSValue JSC_HOST_CALL dateProtoFuncToJSON(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL dateProtoFuncGetDate(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetDay(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetFullYear(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetHours(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetMilliSeconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetMinutes(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetMonth(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetSeconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetTime(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetTimezoneOffset(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCDate(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCDay(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCFullYear(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCHours(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCMilliseconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCMinutes(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCMonth(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetUTCSeconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncGetYear(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetDate(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetFullYear(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetHours(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetMilliSeconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetMinutes(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetMonth(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetSeconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetTime(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetUTCDate(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetUTCFullYear(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetUTCHours(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetUTCMilliseconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetUTCMinutes(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetUTCMonth(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetUTCSeconds(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncSetYear(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToDateString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToGMTString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToLocaleDateString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToLocaleString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToLocaleTimeString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToTimeString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToUTCString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToISOString(ExecState*);
+static JSValue JSC_HOST_CALL dateProtoFuncToJSON(ExecState*);
 
 }
 
@@ -146,7 +145,7 @@ static CFDateFormatterStyle styleFromArgString(const UString& string, CFDateForm
     return defaultStyle;
 }
 
-static JSCell* formatLocaleDate(ExecState* exec, DateInstance*, double timeInMilliseconds, LocaleDateTimeFormat format, const ArgList& args)
+static JSCell* formatLocaleDate(ExecState* exec, DateInstance*, double timeInMilliseconds, LocaleDateTimeFormat format)
 {
     CFDateFormatterStyle dateStyle = (format != LocaleTime ? kCFDateFormatterLongStyle : kCFDateFormatterNoStyle);
     CFDateFormatterStyle timeStyle = (format != LocaleDate ? kCFDateFormatterLongStyle : kCFDateFormatterNoStyle);
@@ -154,16 +153,16 @@ static JSCell* formatLocaleDate(ExecState* exec, DateInstance*, double timeInMil
     bool useCustomFormat = false;
     UString customFormatString;
 
-    UString arg0String = args.at(0).toString(exec);
-    if (arg0String == "custom" && !args.at(1).isUndefined()) {
+    UString arg0String = exec->argument(0).toString(exec);
+    if (arg0String == "custom" && !exec->argument(1).isUndefined()) {
         useCustomFormat = true;
-        customFormatString = args.at(1).toString(exec);
-    } else if (format == LocaleDateAndTime && !args.at(1).isUndefined()) {
+        customFormatString = exec->argument(1).toString(exec);
+    } else if (format == LocaleDateAndTime && !exec->argument(1).isUndefined()) {
         dateStyle = styleFromArgString(arg0String, dateStyle);
-        timeStyle = styleFromArgString(args.at(1).toString(exec), timeStyle);
-    } else if (format != LocaleTime && !args.at(0).isUndefined())
+        timeStyle = styleFromArgString(exec->argument(1).toString(exec), timeStyle);
+    } else if (format != LocaleTime && !exec->argument(0).isUndefined())
         dateStyle = styleFromArgString(arg0String, dateStyle);
-    else if (format != LocaleDate && !args.at(0).isUndefined())
+    else if (format != LocaleDate && !exec->argument(0).isUndefined())
         timeStyle = styleFromArgString(arg0String, timeStyle);
 
     CFLocaleRef locale = CFLocaleCopyCurrent();
@@ -274,7 +273,7 @@ static JSCell* formatLocaleDate(ExecState* exec, const GregorianDateTime& gdt, L
     return jsNontrivialString(exec, timebuffer);
 }
 
-static JSCell* formatLocaleDate(ExecState* exec, DateInstance* dateObject, double, LocaleDateTimeFormat format, const ArgList&)
+static JSCell* formatLocaleDate(ExecState* exec, DateInstance* dateObject, double, LocaleDateTimeFormat format)
 {
     const GregorianDateTime* gregorianDateTime = dateObject->gregorianDateTime(exec);
     if (!gregorianDateTime)
@@ -288,12 +287,12 @@ static JSCell* formatLocaleDate(ExecState* exec, DateInstance* dateObject, doubl
 // ms (representing milliseconds) and t (representing the rest of the date structure) appropriately.
 //
 // Format of member function: f([hour,] [min,] [sec,] [ms])
-static bool fillStructuresUsingTimeArgs(ExecState* exec, const ArgList& args, int maxArgs, double* ms, GregorianDateTime* t)
+static bool fillStructuresUsingTimeArgs(ExecState* exec, int maxArgs, double* ms, GregorianDateTime* t)
 {
     double milliseconds = 0;
     bool ok = true;
     int idx = 0;
-    int numArgs = args.size();
+    int numArgs = exec->argumentCount();
     
     // JS allows extra trailing arguments -- ignore them
     if (numArgs > maxArgs)
@@ -302,19 +301,19 @@ static bool fillStructuresUsingTimeArgs(ExecState* exec, const ArgList& args, in
     // hours
     if (maxArgs >= 4 && idx < numArgs) {
         t->hour = 0;
-        milliseconds += args.at(idx++).toInt32(exec, ok) * msPerHour;
+        milliseconds += exec->argument(idx++).toInt32(exec, ok) * msPerHour;
     }
 
     // minutes
     if (maxArgs >= 3 && idx < numArgs && ok) {
         t->minute = 0;
-        milliseconds += args.at(idx++).toInt32(exec, ok) * msPerMinute;
+        milliseconds += exec->argument(idx++).toInt32(exec, ok) * msPerMinute;
     }
     
     // seconds
     if (maxArgs >= 2 && idx < numArgs && ok) {
         t->second = 0;
-        milliseconds += args.at(idx++).toInt32(exec, ok) * msPerSecond;
+        milliseconds += exec->argument(idx++).toInt32(exec, ok) * msPerSecond;
     }
     
     if (!ok)
@@ -322,7 +321,7 @@ static bool fillStructuresUsingTimeArgs(ExecState* exec, const ArgList& args, in
         
     // milliseconds
     if (idx < numArgs) {
-        double millis = args.at(idx).toNumber(exec);
+        double millis = exec->argument(idx).toNumber(exec);
         ok = isfinite(millis);
         milliseconds += millis;
     } else
@@ -336,11 +335,11 @@ static bool fillStructuresUsingTimeArgs(ExecState* exec, const ArgList& args, in
 // ms (representing milliseconds) and t (representing the rest of the date structure) appropriately.
 //
 // Format of member function: f([years,] [months,] [days])
-static bool fillStructuresUsingDateArgs(ExecState *exec, const ArgList& args, int maxArgs, double *ms, GregorianDateTime *t)
+static bool fillStructuresUsingDateArgs(ExecState *exec, int maxArgs, double *ms, GregorianDateTime *t)
 {
     int idx = 0;
     bool ok = true;
-    int numArgs = args.size();
+    int numArgs = exec->argumentCount();
   
     // JS allows extra trailing arguments -- ignore them
     if (numArgs > maxArgs)
@@ -348,16 +347,16 @@ static bool fillStructuresUsingDateArgs(ExecState *exec, const ArgList& args, in
   
     // years
     if (maxArgs >= 3 && idx < numArgs)
-        t->year = args.at(idx++).toInt32(exec, ok) - 1900;
+        t->year = exec->argument(idx++).toInt32(exec, ok) - 1900;
     
     // months
     if (maxArgs >= 2 && idx < numArgs && ok)   
-        t->month = args.at(idx++).toInt32(exec, ok);
+        t->month = exec->argument(idx++).toInt32(exec, ok);
     
     // days
     if (idx < numArgs && ok) {   
         t->monthDay = 0;
-        *ms += args.at(idx).toInt32(exec, ok) * msPerDay;
+        *ms += exec->argument(idx).toInt32(exec, ok) * msPerDay;
     }
     
     return ok;
@@ -438,8 +437,9 @@ bool DatePrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier&
 
 // Functions
 
-JSValue JSC_HOST_CALL dateProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -455,8 +455,9 @@ JSValue JSC_HOST_CALL dateProtoFuncToString(ExecState* exec, JSObject*, JSValue
     return jsMakeNontrivialString(exec, date, " ", time);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToUTCString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncToUTCString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -472,8 +473,9 @@ JSValue JSC_HOST_CALL dateProtoFuncToUTCString(ExecState* exec, JSObject*, JSVal
     return jsMakeNontrivialString(exec, date, " ", time);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToISOString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncToISOString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
     
@@ -490,8 +492,9 @@ JSValue JSC_HOST_CALL dateProtoFuncToISOString(ExecState* exec, JSObject*, JSVal
     return jsNontrivialString(exec, buffer);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToDateString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncToDateString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -505,8 +508,9 @@ JSValue JSC_HOST_CALL dateProtoFuncToDateString(ExecState* exec, JSObject*, JSVa
     return jsNontrivialString(exec, date);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToTimeString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncToTimeString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -520,43 +524,48 @@ JSValue JSC_HOST_CALL dateProtoFuncToTimeString(ExecState* exec, JSObject*, JSVa
     return jsNontrivialString(exec, time);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToLocaleString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncToLocaleString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     DateInstance* thisDateObj = asDateInstance(thisValue); 
-    return formatLocaleDate(exec, thisDateObj, thisDateObj->internalNumber(), LocaleDateAndTime, args);
+    return formatLocaleDate(exec, thisDateObj, thisDateObj->internalNumber(), LocaleDateAndTime);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToLocaleDateString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncToLocaleDateString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     DateInstance* thisDateObj = asDateInstance(thisValue); 
-    return formatLocaleDate(exec, thisDateObj, thisDateObj->internalNumber(), LocaleDate, args);
+    return formatLocaleDate(exec, thisDateObj, thisDateObj->internalNumber(), LocaleDate);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToLocaleTimeString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncToLocaleTimeString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     DateInstance* thisDateObj = asDateInstance(thisValue); 
-    return formatLocaleDate(exec, thisDateObj, thisDateObj->internalNumber(), LocaleTime, args);
+    return formatLocaleDate(exec, thisDateObj, thisDateObj->internalNumber(), LocaleTime);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetTime(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetTime(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     return asDateInstance(thisValue)->internalValue(); 
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetFullYear(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetFullYear(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -568,8 +577,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetFullYear(ExecState* exec, JSObject*, JSVal
     return jsNumber(exec, 1900 + gregorianDateTime->year);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCFullYear(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCFullYear(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -581,8 +591,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCFullYear(ExecState* exec, JSObject*, JS
     return jsNumber(exec, 1900 + gregorianDateTime->year);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToGMTString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncToGMTString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -598,8 +609,9 @@ JSValue JSC_HOST_CALL dateProtoFuncToGMTString(ExecState* exec, JSObject*, JSVal
     return jsMakeNontrivialString(exec, date, " ", time);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetMonth(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetMonth(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -611,8 +623,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetMonth(ExecState* exec, JSObject*, JSValue
     return jsNumber(exec, gregorianDateTime->month);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCMonth(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCMonth(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -624,8 +637,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCMonth(ExecState* exec, JSObject*, JSVal
     return jsNumber(exec, gregorianDateTime->month);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetDate(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetDate(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -637,8 +651,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetDate(ExecState* exec, JSObject*, JSValue t
     return jsNumber(exec, gregorianDateTime->monthDay);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCDate(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCDate(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -650,8 +665,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCDate(ExecState* exec, JSObject*, JSValu
     return jsNumber(exec, gregorianDateTime->monthDay);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetDay(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetDay(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -663,8 +679,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetDay(ExecState* exec, JSObject*, JSValue th
     return jsNumber(exec, gregorianDateTime->weekDay);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCDay(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCDay(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -676,8 +693,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCDay(ExecState* exec, JSObject*, JSValue
     return jsNumber(exec, gregorianDateTime->weekDay);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetHours(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetHours(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -689,8 +707,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetHours(ExecState* exec, JSObject*, JSValue
     return jsNumber(exec, gregorianDateTime->hour);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCHours(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCHours(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -702,8 +721,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCHours(ExecState* exec, JSObject*, JSVal
     return jsNumber(exec, gregorianDateTime->hour);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetMinutes(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetMinutes(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -715,8 +735,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetMinutes(ExecState* exec, JSObject*, JSValu
     return jsNumber(exec, gregorianDateTime->minute);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCMinutes(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCMinutes(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -728,8 +749,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCMinutes(ExecState* exec, JSObject*, JSV
     return jsNumber(exec, gregorianDateTime->minute);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetSeconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetSeconds(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -741,8 +763,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetSeconds(ExecState* exec, JSObject*, JSValu
     return jsNumber(exec, gregorianDateTime->second);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCSeconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCSeconds(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -754,8 +777,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCSeconds(ExecState* exec, JSObject*, JSV
     return jsNumber(exec, gregorianDateTime->second);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetMilliSeconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetMilliSeconds(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -769,8 +793,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetMilliSeconds(ExecState* exec, JSObject*, J
     return jsNumber(exec, ms);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetUTCMilliseconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetUTCMilliseconds(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -784,8 +809,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetUTCMilliseconds(ExecState* exec, JSObject*
     return jsNumber(exec, ms);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetTimezoneOffset(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetTimezoneOffset(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -797,28 +823,30 @@ JSValue JSC_HOST_CALL dateProtoFuncGetTimezoneOffset(ExecState* exec, JSObject*,
     return jsNumber(exec, -gregorianDateTime->utcOffset / minutesPerHour);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetTime(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetTime(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     DateInstance* thisDateObj = asDateInstance(thisValue); 
 
-    double milli = timeClip(args.at(0).toNumber(exec));
+    double milli = timeClip(exec->argument(0).toNumber(exec));
     JSValue result = jsNumber(exec, milli);
     thisDateObj->setInternalValue(result);
     return result;
 }
 
-static JSValue setNewValueFromTimeArgs(ExecState* exec, JSValue thisValue, const ArgList& args, int numArgsToUse, bool inputIsUTC)
+static JSValue setNewValueFromTimeArgs(ExecState* exec, int numArgsToUse, bool inputIsUTC)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     DateInstance* thisDateObj = asDateInstance(thisValue);
     double milli = thisDateObj->internalNumber();
     
-    if (args.isEmpty() || isnan(milli)) {
+    if (!exec->argumentCount() || isnan(milli)) {
         JSValue result = jsNaN(exec);
         thisDateObj->setInternalValue(result);
         return result;
@@ -835,7 +863,7 @@ static JSValue setNewValueFromTimeArgs(ExecState* exec, JSValue thisValue, const
 
     GregorianDateTime gregorianDateTime;
     gregorianDateTime.copyFrom(*other);
-    if (!fillStructuresUsingTimeArgs(exec, args, numArgsToUse, &ms, &gregorianDateTime)) {
+    if (!fillStructuresUsingTimeArgs(exec, numArgsToUse, &ms, &gregorianDateTime)) {
         JSValue result = jsNaN(exec);
         thisDateObj->setInternalValue(result);
         return result;
@@ -846,13 +874,14 @@ static JSValue setNewValueFromTimeArgs(ExecState* exec, JSValue thisValue, const
     return result;
 }
 
-static JSValue setNewValueFromDateArgs(ExecState* exec, JSValue thisValue, const ArgList& args, int numArgsToUse, bool inputIsUTC)
+static JSValue setNewValueFromDateArgs(ExecState* exec, int numArgsToUse, bool inputIsUTC)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     DateInstance* thisDateObj = asDateInstance(thisValue);
-    if (args.isEmpty()) {
+    if (!exec->argumentCount()) {
         JSValue result = jsNaN(exec);
         thisDateObj->setInternalValue(result);
         return result;
@@ -874,7 +903,7 @@ static JSValue setNewValueFromDateArgs(ExecState* exec, JSValue thisValue, const
         gregorianDateTime.copyFrom(*other);
     }
     
-    if (!fillStructuresUsingDateArgs(exec, args, numArgsToUse, &ms, &gregorianDateTime)) {
+    if (!fillStructuresUsingDateArgs(exec, numArgsToUse, &ms, &gregorianDateTime)) {
         JSValue result = jsNaN(exec);
         thisDateObj->setInternalValue(result);
         return result;
@@ -885,97 +914,98 @@ static JSValue setNewValueFromDateArgs(ExecState* exec, JSValue thisValue, const
     return result;
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetMilliSeconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetMilliSeconds(ExecState* exec)
 {
     const bool inputIsUTC = false;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 1, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 1, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetUTCMilliseconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetUTCMilliseconds(ExecState* exec)
 {
     const bool inputIsUTC = true;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 1, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 1, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetSeconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetSeconds(ExecState* exec)
 {
     const bool inputIsUTC = false;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 2, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 2, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetUTCSeconds(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetUTCSeconds(ExecState* exec)
 {
     const bool inputIsUTC = true;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 2, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 2, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetMinutes(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetMinutes(ExecState* exec)
 {
     const bool inputIsUTC = false;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 3, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 3, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetUTCMinutes(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetUTCMinutes(ExecState* exec)
 {
     const bool inputIsUTC = true;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 3, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 3, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetHours(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetHours(ExecState* exec)
 {
     const bool inputIsUTC = false;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 4, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 4, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetUTCHours(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetUTCHours(ExecState* exec)
 {
     const bool inputIsUTC = true;
-    return setNewValueFromTimeArgs(exec, thisValue, args, 4, inputIsUTC);
+    return setNewValueFromTimeArgs(exec, 4, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetDate(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetDate(ExecState* exec)
 {
     const bool inputIsUTC = false;
-    return setNewValueFromDateArgs(exec, thisValue, args, 1, inputIsUTC);
+    return setNewValueFromDateArgs(exec, 1, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetUTCDate(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetUTCDate(ExecState* exec)
 {
     const bool inputIsUTC = true;
-    return setNewValueFromDateArgs(exec, thisValue, args, 1, inputIsUTC);
+    return setNewValueFromDateArgs(exec, 1, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetMonth(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetMonth(ExecState* exec)
 {
     const bool inputIsUTC = false;
-    return setNewValueFromDateArgs(exec, thisValue, args, 2, inputIsUTC);
+    return setNewValueFromDateArgs(exec, 2, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetUTCMonth(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetUTCMonth(ExecState* exec)
 {
     const bool inputIsUTC = true;
-    return setNewValueFromDateArgs(exec, thisValue, args, 2, inputIsUTC);
+    return setNewValueFromDateArgs(exec, 2, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetFullYear(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetFullYear(ExecState* exec)
 {
     const bool inputIsUTC = false;
-    return setNewValueFromDateArgs(exec, thisValue, args, 3, inputIsUTC);
+    return setNewValueFromDateArgs(exec, 3, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetUTCFullYear(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetUTCFullYear(ExecState* exec)
 {
     const bool inputIsUTC = true;
-    return setNewValueFromDateArgs(exec, thisValue, args, 3, inputIsUTC);
+    return setNewValueFromDateArgs(exec, 3, inputIsUTC);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncSetYear(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL dateProtoFuncSetYear(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
     DateInstance* thisDateObj = asDateInstance(thisValue);     
-    if (args.isEmpty()) { 
+    if (!exec->argumentCount()) { 
         JSValue result = jsNaN(exec);
         thisDateObj->setInternalValue(result);
         return result;
@@ -997,7 +1027,7 @@ JSValue JSC_HOST_CALL dateProtoFuncSetYear(ExecState* exec, JSObject*, JSValue t
     }
     
     bool ok = true;
-    int32_t year = args.at(0).toInt32(exec, ok);
+    int32_t year = exec->argument(0).toInt32(exec, ok);
     if (!ok) {
         JSValue result = jsNaN(exec);
         thisDateObj->setInternalValue(result);
@@ -1010,8 +1040,9 @@ JSValue JSC_HOST_CALL dateProtoFuncSetYear(ExecState* exec, JSObject*, JSValue t
     return result;
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncGetYear(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncGetYear(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&DateInstance::info))
         return throwError(exec, TypeError);
 
@@ -1025,8 +1056,9 @@ JSValue JSC_HOST_CALL dateProtoFuncGetYear(ExecState* exec, JSObject*, JSValue t
     return jsNumber(exec, gregorianDateTime->year);
 }
 
-JSValue JSC_HOST_CALL dateProtoFuncToJSON(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL dateProtoFuncToJSON(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* object = thisValue.toThisObject(exec);
     if (exec->hadException())
         return jsNull();
index 4a4559e..b4b0ba2 100644 (file)
@@ -57,10 +57,9 @@ ConstructType ErrorConstructor::getConstructData(ConstructData& constructData)
     return ConstructTypeHost;
 }
 
-// ECMA 15.9.2
-static JSValue JSC_HOST_CALL callErrorConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callErrorConstructor(ExecState* exec)
 {
-    // "Error()" gives the sames result as "new Error()"
+    ArgList args(exec);
     return constructError(exec, args);
 }
 
index 72fa4c4..4c895fa 100644 (file)
@@ -32,7 +32,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ErrorPrototype);
 
-static JSValue JSC_HOST_CALL errorProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL errorProtoFuncToString(ExecState*);
 
 // ECMA 15.9.4
 ErrorPrototype::ErrorPrototype(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, Structure* prototypeFunctionStructure)
@@ -46,9 +46,9 @@ ErrorPrototype::ErrorPrototype(ExecState* exec, JSGlobalObject* globalObject, No
     putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, globalObject, prototypeFunctionStructure, 0, exec->propertyNames().toString, errorProtoFuncToString), DontEnum);
 }
 
-JSValue JSC_HOST_CALL errorProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL errorProtoFuncToString(ExecState* exec)
 {
-    JSObject* thisObj = thisValue.toThisObject(exec);
+    JSObject* thisObj = exec->hostThisValue().toThisObject(exec);
     JSValue name = thisObj->get(exec, exec->propertyNames().name);
     JSValue message = thisObj->get(exec, exec->propertyNames().message);
 
index c8299a9..de9fff1 100644 (file)
@@ -55,8 +55,9 @@ ConstructType FunctionConstructor::getConstructData(ConstructData& constructData
     return ConstructTypeHost;
 }
 
-static JSValue JSC_HOST_CALL callFunctionConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callFunctionConstructor(ExecState* exec)
 {
+    ArgList args(exec);
     return constructFunction(exec, args);
 }
 
index 1762816..15392cf 100644 (file)
@@ -34,9 +34,9 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(FunctionPrototype);
 
-static JSValue JSC_HOST_CALL functionProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionProtoFuncApply(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL functionProtoFuncCall(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL functionProtoFuncToString(ExecState*);
+static JSValue JSC_HOST_CALL functionProtoFuncApply(ExecState*);
+static JSValue JSC_HOST_CALL functionProtoFuncCall(ExecState*);
 
 FunctionPrototype::FunctionPrototype(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure)
     : InternalFunction(&exec->globalData(), globalObject, structure, exec->propertyNames().nullIdentifier)
@@ -53,7 +53,7 @@ void FunctionPrototype::addFunctionProperties(ExecState* exec, JSGlobalObject* g
     putDirectFunctionWithoutTransition(exec, *callFunction, DontEnum);
 }
 
-static JSValue JSC_HOST_CALL callFunctionPrototype(ExecState*, JSObject*, JSValue, const ArgList&)
+static JSValue JSC_HOST_CALL callFunctionPrototype(ExecState*)
 {
     return jsUndefined();
 }
@@ -83,8 +83,9 @@ static inline void insertSemicolonIfNeeded(UString& functionBody)
     }
 }
 
-JSValue JSC_HOST_CALL functionProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL functionProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (thisValue.inherits(&JSFunction::info)) {
         JSFunction* function = asFunction(thisValue);
         if (function->isHostFunction())
@@ -103,14 +104,15 @@ JSValue JSC_HOST_CALL functionProtoFuncToString(ExecState* exec, JSObject*, JSVa
     return throwError(exec, TypeError);
 }
 
-JSValue JSC_HOST_CALL functionProtoFuncApply(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL functionProtoFuncApply(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     CallData callData;
     CallType callType = thisValue.getCallData(callData);
     if (callType == CallTypeNone)
         return throwError(exec, TypeError);
 
-    JSValue array = args.at(1);
+    JSValue array = exec->argument(1);
 
     MarkedArgumentBuffer applyArgs;
     if (!array.isUndefinedOrNull()) {
@@ -128,19 +130,21 @@ JSValue JSC_HOST_CALL functionProtoFuncApply(ExecState* exec, JSObject*, JSValue
             return throwError(exec, TypeError);
     }
 
-    return call(exec, thisValue, callType, callData, args.at(0), applyArgs);
+    return call(exec, thisValue, callType, callData, exec->argument(0), applyArgs);
 }
 
-JSValue JSC_HOST_CALL functionProtoFuncCall(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL functionProtoFuncCall(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     CallData callData;
     CallType callType = thisValue.getCallData(callData);
     if (callType == CallTypeNone)
         return throwError(exec, TypeError);
 
+    ArgList args(exec);
     ArgList callArgs;
     args.getSlice(1, callArgs);
-    return call(exec, thisValue, callType, callData, args.at(0), callArgs);
+    return call(exec, thisValue, callType, callData, exec->argument(0), callArgs);
 }
 
 } // namespace JSC
index 1176984..f44ca2f 100644 (file)
@@ -31,6 +31,7 @@
 #include "ExceptionHelpers.h"
 #include "FunctionPrototype.h"
 #include "JSGlobalObject.h"
+#include "JSNotAnObject.h"
 #include "Interpreter.h"
 #include "ObjectPrototype.h"
 #include "Parser.h"
@@ -42,11 +43,11 @@ using namespace Unicode;
 
 namespace JSC {
 
-JSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState* exec, JSObject* constructor, JSValue, const ArgList&)
+JSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState* exec)
 {
     CodeBlock* codeBlock = exec->callerFrame()->codeBlock();
     unsigned vPCIndex = codeBlock->bytecodeOffset(exec, exec->returnPC());
-    exec->setException(createNotAConstructorError(exec, constructor, vPCIndex, codeBlock));
+    exec->setException(createNotAConstructorError(exec, exec->callee(), vPCIndex, codeBlock));
     return JSValue();
 }
 
@@ -168,12 +169,6 @@ CallType JSFunction::getCallData(CallData& callData)
     return CallTypeJS;
 }
 
-JSValue JSFunction::call(ExecState* exec, JSValue thisValue, const ArgList& args)
-{
-    ASSERT(!isHostFunction());
-    return exec->interpreter()->executeCall(jsExecutable(), exec, this, thisValue.toThisObject(exec), args, scope().node(), exec->exceptionSlot());
-}
-
 JSValue JSFunction::argumentsGetter(ExecState* exec, JSValue slotBase, const Identifier&)
 {
     JSFunction* thisObj = asFunction(slotBase);
@@ -301,21 +296,4 @@ ConstructType JSFunction::getConstructData(ConstructData& constructData)
     return ConstructTypeJS;
 }
 
-JSObject* JSFunction::construct(ExecState* exec, const ArgList& args)
-{
-    ASSERT(!isHostFunction());
-    Structure* structure;
-    JSValue prototype = get(exec, exec->propertyNames().prototype);
-    if (prototype.isObject())
-        structure = asObject(prototype)->inheritorID();
-    else
-        structure = exec->lexicalGlobalObject()->emptyObjectStructure();
-    JSObject* thisObj = new (exec) JSObject(structure);
-
-    JSValue result = exec->interpreter()->executeConstruct(jsExecutable(), exec, this, thisObj, args, scope().node(), exec->exceptionSlot());
-    if (exec->hadException() || !result.isObject())
-        return thisObj;
-    return asObject(result);
-}
-
 } // namespace JSC
index b66a0d0..a906b2e 100644 (file)
@@ -35,7 +35,7 @@ namespace JSC {
     class JSGlobalObject;
     class NativeExecutable;
 
-    JSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*, JSObject*, JSValue, const ArgList&);
+    JSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
 
     class JSFunction : public JSObjectWithGlobalObject {
         friend class JIT;
@@ -51,9 +51,6 @@ namespace JSC {
         JSFunction(ExecState*, NonNullPassRefPtr<FunctionExecutable>, ScopeChainNode*);
         virtual ~JSFunction();
 
-        JSObject* construct(ExecState*, const ArgList&);
-        JSValue call(ExecState*, JSValue thisValue, const ArgList&);
-
         const UString& name(ExecState*);
         const UString displayName(ExecState*);
         const UString calculatedDisplayName(ExecState*);
index fb9b3eb..69e09c1 100644 (file)
@@ -131,7 +131,7 @@ void JSGlobalObject::init(JSObject* thisValue)
     d()->globalData = Heap::heap(this)->globalData();
     d()->globalScopeChain = ScopeChain(this, d()->globalData.get(), this, thisValue);
 
-    JSGlobalObject::globalExec()->init(0, 0, d()->globalScopeChain.node(), CallFrame::noCaller(), 0, 0, 0);
+    JSGlobalObject::globalExec()->init(0, 0, d()->globalScopeChain.node(), CallFrame::noCaller(), 0, 0);
 
     if (JSGlobalObject*& headObject = head()) {
         d()->prev = headObject;
index 722e167..21d06b7 100644 (file)
@@ -51,9 +51,9 @@ using namespace Unicode;
 
 namespace JSC {
 
-static JSValue encode(ExecState* exec, const ArgList& args, const char* doNotEscape)
+static JSValue encode(ExecState* exec, const char* doNotEscape)
 {
-    UString str = args.at(0).toString(exec);
+    UString str = exec->argument(0).toString(exec);
     CString cstr = str.UTF8String(true);
     if (!cstr.data())
         return throwError(exec, URIError, "String contained an illegal UTF-16 sequence.");
@@ -73,10 +73,10 @@ static JSValue encode(ExecState* exec, const ArgList& args, const char* doNotEsc
     return builder.build(exec);
 }
 
-static JSValue decode(ExecState* exec, const ArgList& args, const char* doNotUnescape, bool strict)
+static JSValue decode(ExecState* exec, const char* doNotUnescape, bool strict)
 {
     JSStringBuilder builder;
-    UString str = args.at(0).toString(exec);
+    UString str = exec->argument(0).toString(exec);
     int k = 0;
     int len = str.size();
     const UChar* d = str.data();
@@ -272,14 +272,14 @@ static double parseFloat(const UString& s)
     return s.toDouble(true /*tolerant*/, false /* NaN for empty string */);
 }
 
-JSValue JSC_HOST_CALL globalFuncEval(ExecState* exec, JSObject* function, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncEval(ExecState* exec)
 {
-    JSObject* thisObject = thisValue.toThisObject(exec);
+    JSObject* thisObject = exec->hostThisValue().toThisObject(exec);
     JSObject* unwrappedObject = thisObject->unwrappedObject();
-    if (!unwrappedObject->isGlobalObject() || static_cast<JSGlobalObject*>(unwrappedObject)->evalFunction() != function)
+    if (!unwrappedObject->isGlobalObject() || static_cast<JSGlobalObject*>(unwrappedObject)->evalFunction() != exec->callee())
         return throwError(exec, EvalError, "The \"this\" value passed to eval must be the global object from which eval originated");
 
-    JSValue x = args.at(0);
+    JSValue x = exec->argument(0);
     if (!x.isString())
         return x;
 
@@ -297,10 +297,10 @@ JSValue JSC_HOST_CALL globalFuncEval(ExecState* exec, JSObject* function, JSValu
     return exec->interpreter()->execute(eval.get(), exec, thisObject, static_cast<JSGlobalObject*>(unwrappedObject)->globalScopeChain().node(), exec->exceptionSlot());
 }
 
-JSValue JSC_HOST_CALL globalFuncParseInt(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncParseInt(ExecState* exec)
 {
-    JSValue value = args.at(0);
-    int32_t radix = args.at(1).toInt32(exec);
+    JSValue value = exec->argument(0);
+    int32_t radix = exec->argument(1).toInt32(exec);
 
     if (radix != 0 && radix != 10)
         return jsNumber(exec, parseInt(value.toString(exec), radix));
@@ -320,36 +320,36 @@ JSValue JSC_HOST_CALL globalFuncParseInt(ExecState* exec, JSObject*, JSValue, co
     return jsNumber(exec, parseInt(value.toString(exec), radix));
 }
 
-JSValue JSC_HOST_CALL globalFuncParseFloat(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncParseFloat(ExecState* exec)
 {
-    return jsNumber(exec, parseFloat(args.at(0).toString(exec)));
+    return jsNumber(exec, parseFloat(exec->argument(0).toString(exec)));
 }
 
-JSValue JSC_HOST_CALL globalFuncIsNaN(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncIsNaN(ExecState* exec)
 {
-    return jsBoolean(isnan(args.at(0).toNumber(exec)));
+    return jsBoolean(isnan(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL globalFuncIsFinite(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncIsFinite(ExecState* exec)
 {
-    double n = args.at(0).toNumber(exec);
+    double n = exec->argument(0).toNumber(exec);
     return jsBoolean(!isnan(n) && !isinf(n));
 }
 
-JSValue JSC_HOST_CALL globalFuncDecodeURI(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncDecodeURI(ExecState* exec)
 {
     static const char do_not_unescape_when_decoding_URI[] =
         "#$&+,/:;=?@";
 
-    return decode(exec, args, do_not_unescape_when_decoding_URI, true);
+    return decode(exec, do_not_unescape_when_decoding_URI, true);
 }
 
-JSValue JSC_HOST_CALL globalFuncDecodeURIComponent(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncDecodeURIComponent(ExecState* exec)
 {
-    return decode(exec, args, "", true);
+    return decode(exec, "", true);
 }
 
-JSValue JSC_HOST_CALL globalFuncEncodeURI(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncEncodeURI(ExecState* exec)
 {
     static const char do_not_escape_when_encoding_URI[] =
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -357,10 +357,10 @@ JSValue JSC_HOST_CALL globalFuncEncodeURI(ExecState* exec, JSObject*, JSValue, c
         "0123456789"
         "!#$&'()*+,-./:;=?@_~";
 
-    return encode(exec, args, do_not_escape_when_encoding_URI);
+    return encode(exec, do_not_escape_when_encoding_URI);
 }
 
-JSValue JSC_HOST_CALL globalFuncEncodeURIComponent(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncEncodeURIComponent(ExecState* exec)
 {
     static const char do_not_escape_when_encoding_URI_component[] =
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -368,10 +368,10 @@ JSValue JSC_HOST_CALL globalFuncEncodeURIComponent(ExecState* exec, JSObject*, J
         "0123456789"
         "!'()*-._~";
 
-    return encode(exec, args, do_not_escape_when_encoding_URI_component);
+    return encode(exec, do_not_escape_when_encoding_URI_component);
 }
 
-JSValue JSC_HOST_CALL globalFuncEscape(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncEscape(ExecState* exec)
 {
     static const char do_not_escape[] =
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -380,7 +380,7 @@ JSValue JSC_HOST_CALL globalFuncEscape(ExecState* exec, JSObject*, JSValue, cons
         "*+-./@_";
 
     JSStringBuilder builder;
-    UString str = args.at(0).toString(exec);
+    UString str = exec->argument(0).toString(exec);
     const UChar* c = str.data();
     for (unsigned k = 0; k < str.size(); k++, c++) {
         int u = c[0];
@@ -400,10 +400,10 @@ JSValue JSC_HOST_CALL globalFuncEscape(ExecState* exec, JSObject*, JSValue, cons
     return builder.build(exec);
 }
 
-JSValue JSC_HOST_CALL globalFuncUnescape(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncUnescape(ExecState* exec)
 {
     StringBuilder builder;
-    UString str = args.at(0).toString(exec);
+    UString str = exec->argument(0).toString(exec);
     int k = 0;
     int len = str.size();
     while (k < len) {
@@ -428,9 +428,9 @@ JSValue JSC_HOST_CALL globalFuncUnescape(ExecState* exec, JSObject*, JSValue, co
 }
 
 #ifndef NDEBUG
-JSValue JSC_HOST_CALL globalFuncJSCPrint(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL globalFuncJSCPrint(ExecState* exec)
 {
-    CString string = args.at(0).toString(exec).UTF8String();
+    CString string = exec->argument(0).toString(exec).UTF8String();
     puts(string.data());
     return jsUndefined();
 }
index b1046f2..b1dada4 100644 (file)
@@ -36,19 +36,19 @@ namespace JSC {
     // FIXME: These functions should really be in JSGlobalObject.cpp, but putting them there
     // is a 0.5% reduction.
 
-    JSValue JSC_HOST_CALL globalFuncEval(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncParseInt(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncParseFloat(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncIsNaN(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncIsFinite(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncDecodeURI(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncDecodeURIComponent(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncEncodeURI(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncEncodeURIComponent(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncEscape(ExecState*, JSObject*, JSValue, const ArgList&);
-    JSValue JSC_HOST_CALL globalFuncUnescape(ExecState*, JSObject*, JSValue, const ArgList&);
+    JSValue JSC_HOST_CALL globalFuncEval(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncParseInt(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncParseFloat(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncIsNaN(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncIsFinite(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncDecodeURI(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncDecodeURIComponent(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncEncodeURI(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncEncodeURIComponent(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncEscape(ExecState*);
+    JSValue JSC_HOST_CALL globalFuncUnescape(ExecState*);
 #ifndef NDEBUG
-    JSValue JSC_HOST_CALL globalFuncJSCPrint(ExecState*, JSObject*, JSValue, const ArgList&);
+    JSValue JSC_HOST_CALL globalFuncJSCPrint(ExecState*);
 #endif
 
     static const double mantissaOverflowLowerBound = 9007199254740992.0;
index bd0e25f..86604d8 100644 (file)
@@ -41,8 +41,8 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(JSONObject);
 
-static JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL JSONProtoFuncStringify(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState*);
+static JSValue JSC_HOST_CALL JSONProtoFuncStringify(ExecState*);
 
 }
 
@@ -839,11 +839,11 @@ NEVER_INLINE JSValue Walker::walk(JSValue unfiltered)
 }
 
 // ECMA-262 v5 15.12.2
-JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState* exec)
 {
-    if (args.isEmpty())
+    if (!exec->argumentCount())
         return throwError(exec, GeneralError, "JSON.parse requires at least one parameter");
-    JSValue value = args.at(0);
+    JSValue value = exec->argument(0);
     UString source = value.toString(exec);
     if (exec->hadException())
         return jsNull();
@@ -853,10 +853,10 @@ JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState* exec, JSObject*, JSValue, co
     if (!unfiltered)
         return throwError(exec, SyntaxError, "Unable to parse JSON string");
     
-    if (args.size() < 2)
+    if (exec->argumentCount() < 2)
         return unfiltered;
     
-    JSValue function = args.at(1);
+    JSValue function = exec->argument(1);
     CallData callData;
     CallType callType = function.getCallData(callData);
     if (callType == CallTypeNone)
@@ -865,13 +865,13 @@ JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState* exec, JSObject*, JSValue, co
 }
 
 // ECMA-262 v5 15.12.3
-JSValue JSC_HOST_CALL JSONProtoFuncStringify(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL JSONProtoFuncStringify(ExecState* exec)
 {
-    if (args.isEmpty())
+    if (!exec->argumentCount())
         return throwError(exec, GeneralError, "No input to stringify");
-    JSValue value = args.at(0);
-    JSValue replacer = args.at(1);
-    JSValue space = args.at(2);
+    JSValue value = exec->argument(0);
+    JSValue replacer = exec->argument(1);
+    JSValue space = exec->argument(2);
     return Stringifier(exec, replacer, space).stringify(value);
 }
 
index dec925d..975ef45 100644 (file)
@@ -433,7 +433,7 @@ namespace JSC {
         friend JSValue jsString(ExecState* exec, const UString& u1, JSString* s2);
         friend JSValue jsString(ExecState* exec, JSString* s1, const UString& u2);
         friend JSValue jsString(ExecState* exec, Register* strings, unsigned count);
-        friend JSValue jsString(ExecState* exec, JSValue thisValue, const ArgList& args);
+        friend JSValue jsString(ExecState* exec, JSValue thisValue);
         friend JSString* jsStringWithFinalizer(ExecState*, const UString&, JSStringFinalizerCallback callback, void* context);
     };
 
index be249e5..28997db 100644 (file)
@@ -34,24 +34,24 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(MathObject);
 
-static JSValue JSC_HOST_CALL mathProtoFuncAbs(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncACos(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncASin(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncATan(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncATan2(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncCeil(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncCos(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncExp(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncFloor(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncLog(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncMax(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncMin(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncPow(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncRound(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncSin(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncSqrt(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL mathProtoFuncTan(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL mathProtoFuncAbs(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncACos(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncASin(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncATan(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncATan2(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncCeil(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncCos(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncExp(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncFloor(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncLog(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncMax(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncMin(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncPow(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncRound(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncSin(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncSqrt(ExecState*);
+static JSValue JSC_HOST_CALL mathProtoFuncTan(ExecState*);
 
 }
 
@@ -113,62 +113,62 @@ bool MathObject::getOwnPropertyDescriptor(ExecState* exec, const Identifier& pro
 
 // ------------------------------ Functions --------------------------------
 
-JSValue JSC_HOST_CALL mathProtoFuncAbs(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncAbs(ExecState* exec)
 {
-    return jsNumber(exec, fabs(args.at(0).toNumber(exec)));
+    return jsNumber(exec, fabs(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncACos(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncACos(ExecState* exec)
 {
-    return jsDoubleNumber(exec, acos(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, acos(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncASin(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncASin(ExecState* exec)
 {
-    return jsDoubleNumber(exec, asin(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, asin(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncATan(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncATan(ExecState* exec)
 {
-    return jsDoubleNumber(exec, atan(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, atan(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncATan2(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncATan2(ExecState* exec)
 {
-    return jsDoubleNumber(exec, atan2(args.at(0).toNumber(exec), args.at(1).toNumber(exec)));
+    return jsDoubleNumber(exec, atan2(exec->argument(0).toNumber(exec), exec->argument(1).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncCeil(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncCeil(ExecState* exec)
 {
-    return jsNumber(exec, ceil(args.at(0).toNumber(exec)));
+    return jsNumber(exec, ceil(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncCos(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncCos(ExecState* exec)
 {
-    return jsDoubleNumber(exec, cos(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, cos(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncExp(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncExp(ExecState* exec)
 {
-    return jsDoubleNumber(exec, exp(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, exp(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncFloor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncFloor(ExecState* exec)
 {
-    return jsNumber(exec, floor(args.at(0).toNumber(exec)));
+    return jsNumber(exec, floor(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncLog(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncLog(ExecState* exec)
 {
-    return jsDoubleNumber(exec, log(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, log(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncMax(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncMax(ExecState* exec)
 {
-    unsigned argsCount = args.size();
+    unsigned argsCount = exec->argumentCount();
     double result = -Inf;
     for (unsigned k = 0; k < argsCount; ++k) {
-        double val = args.at(k).toNumber(exec);
+        double val = exec->argument(k).toNumber(exec);
         if (isnan(val)) {
             result = NaN;
             break;
@@ -179,12 +179,12 @@ JSValue JSC_HOST_CALL mathProtoFuncMax(ExecState* exec, JSObject*, JSValue, cons
     return jsNumber(exec, result);
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncMin(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncMin(ExecState* exec)
 {
-    unsigned argsCount = args.size();
+    unsigned argsCount = exec->argumentCount();
     double result = +Inf;
     for (unsigned k = 0; k < argsCount; ++k) {
-        double val = args.at(k).toNumber(exec);
+        double val = exec->argument(k).toNumber(exec);
         if (isnan(val)) {
             result = NaN;
             break;
@@ -195,12 +195,12 @@ JSValue JSC_HOST_CALL mathProtoFuncMin(ExecState* exec, JSObject*, JSValue, cons
     return jsNumber(exec, result);
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncPow(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncPow(ExecState* exec)
 {
     // ECMA 15.8.2.1.13
 
-    double arg = args.at(0).toNumber(exec);
-    double arg2 = args.at(1).toNumber(exec);
+    double arg = exec->argument(0).toNumber(exec);
+    double arg2 = exec->argument(1).toNumber(exec);
 
     if (isnan(arg2))
         return jsNaN(exec);
@@ -209,31 +209,31 @@ JSValue JSC_HOST_CALL mathProtoFuncPow(ExecState* exec, JSObject*, JSValue, cons
     return jsNumber(exec, pow(arg, arg2));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState* exec, JSObject*, JSValue, const ArgList&)
+JSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState* exec)
 {
     return jsDoubleNumber(exec, exec->globalData().weakRandom.get());
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncRound(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncRound(ExecState* exec)
 {
-    double arg = args.at(0).toNumber(exec);
+    double arg = exec->argument(0).toNumber(exec);
     double integer = ceil(arg);
     return jsNumber(exec, integer - (integer - arg > 0.5));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncSin(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncSin(ExecState* exec)
 {
-    return exec->globalData().cachedSin(exec, args.at(0).toNumber(exec));
+    return exec->globalData().cachedSin(exec, exec->argument(0).toNumber(exec));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncSqrt(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncSqrt(ExecState* exec)
 {
-    return jsDoubleNumber(exec, sqrt(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, sqrt(exec->argument(0).toNumber(exec)));
 }
 
-JSValue JSC_HOST_CALL mathProtoFuncTan(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL mathProtoFuncTan(ExecState* exec)
 {
-    return jsDoubleNumber(exec, tan(args.at(0).toNumber(exec)));
+    return jsDoubleNumber(exec, tan(exec->argument(0).toNumber(exec)));
 }
 
 } // namespace JSC
index 0fa2218..32ae6b8 100644 (file)
@@ -62,9 +62,10 @@ ConstructType NativeErrorConstructor::getConstructData(ConstructData& constructD
     return ConstructTypeHost;
 }
     
-static JSValue JSC_HOST_CALL callNativeErrorConstructor(ExecState* exec, JSObject* constructor, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callNativeErrorConstructor(ExecState* exec)
 {
-    return static_cast<NativeErrorConstructor*>(constructor)->construct(exec, args);
+    ArgList args(exec);
+    return static_cast<NativeErrorConstructor*>(exec->callee())->construct(exec, args);
 }
 
 CallType NativeErrorConstructor::getCallData(CallData& callData)
index 482e87b..fe91f2e 100644 (file)
@@ -115,9 +115,9 @@ ConstructType NumberConstructor::getConstructData(ConstructData& constructData)
 }
 
 // ECMA 15.7.2
-static JSValue JSC_HOST_CALL callNumberConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callNumberConstructor(ExecState* exec)
 {
-    return jsNumber(exec, args.isEmpty() ? 0 : args.at(0).toNumber(exec));
+    return jsNumber(exec, !exec->argumentCount() ? 0 : exec->argument(0).toNumber(exec));
 }
 
 CallType NumberConstructor::getCallData(CallData& callData)
index efed90b..0f1590c 100644 (file)
@@ -38,12 +38,12 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(NumberPrototype);
 
-static JSValue JSC_HOST_CALL numberProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL numberProtoFuncToLocaleString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL numberProtoFuncValueOf(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL numberProtoFuncToFixed(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL numberProtoFuncToPrecision(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL numberProtoFuncToString(ExecState*);
+static JSValue JSC_HOST_CALL numberProtoFuncToLocaleString(ExecState*);
+static JSValue JSC_HOST_CALL numberProtoFuncValueOf(ExecState*);
+static JSValue JSC_HOST_CALL numberProtoFuncToFixed(ExecState*);
+static JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState*);
+static JSValue JSC_HOST_CALL numberProtoFuncToPrecision(ExecState*);
 
 // ECMA 15.7.4
 
@@ -137,13 +137,14 @@ static double intPow10(int e)
     return static_cast<double>(result);
 }
 
-JSValue JSC_HOST_CALL numberProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL numberProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSValue v = thisValue.getJSNumber();
     if (!v)
         return throwError(exec, TypeError);
 
-    JSValue radixValue = args.at(0);
+    JSValue radixValue = exec->argument(0);
     int radix;
     if (radixValue.isInt32())
         radix = radixValue.asInt32();
@@ -220,8 +221,9 @@ JSValue JSC_HOST_CALL numberProtoFuncToString(ExecState* exec, JSObject*, JSValu
     return jsString(exec, startOfResultString);
 }
 
-JSValue JSC_HOST_CALL numberProtoFuncToLocaleString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL numberProtoFuncToLocaleString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     // FIXME: Not implemented yet.
 
     JSValue v = thisValue.getJSNumber();
@@ -231,8 +233,9 @@ JSValue JSC_HOST_CALL numberProtoFuncToLocaleString(ExecState* exec, JSObject*,
     return jsString(exec, v.toString(exec));
 }
 
-JSValue JSC_HOST_CALL numberProtoFuncValueOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL numberProtoFuncValueOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSValue v = thisValue.getJSNumber();
     if (!v)
         return throwError(exec, TypeError);
@@ -240,13 +243,14 @@ JSValue JSC_HOST_CALL numberProtoFuncValueOf(ExecState* exec, JSObject*, JSValue
     return v;
 }
 
-JSValue JSC_HOST_CALL numberProtoFuncToFixed(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL numberProtoFuncToFixed(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSValue v = thisValue.getJSNumber();
     if (!v)
         return throwError(exec, TypeError);
 
-    JSValue fractionDigits = args.at(0);
+    JSValue fractionDigits = exec->argument(0);
     double df = fractionDigits.toInteger(exec);
     if (!(df >= 0 && df <= 20))
         return throwError(exec, RangeError, "toFixed() digits argument must be between 0 and 20");
@@ -331,8 +335,9 @@ static void exponentialPartToString(char* buf, int& i, int decimalPoint)
     buf[i++] = static_cast<char>('0' + exponential % 10);
 }
 
-JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSValue v = thisValue.getJSNumber();
     if (!v)
         return throwError(exec, TypeError);
@@ -342,7 +347,7 @@ JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState* exec, JSObject*, J
     if (isnan(x) || isinf(x))
         return jsString(exec, UString::from(x));
 
-    JSValue fractionalDigitsValue = args.at(0);
+    JSValue fractionalDigitsValue = exec->argument(0);
     double df = fractionalDigitsValue.toInteger(exec);
     if (!(df >= 0 && df <= 20))
         return throwError(exec, RangeError, "toExponential() argument must between 0 and 20");
@@ -403,15 +408,16 @@ JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState* exec, JSObject*, J
     return jsString(exec, buf);
 }
 
-JSValue JSC_HOST_CALL numberProtoFuncToPrecision(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL numberProtoFuncToPrecision(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSValue v = thisValue.getJSNumber();
     if (!v)
         return throwError(exec, TypeError);
 
-    double doublePrecision = args.at(0).toIntegerPreserveNaN(exec);
+    double doublePrecision = exec->argument(0).toIntegerPreserveNaN(exec);
     double x = v.uncheckedGetNumber();
-    if (args.at(0).isUndefined() || isnan(x) || isinf(x))
+    if (exec->argument(0).isUndefined() || isnan(x) || isinf(x))
         return jsString(exec, v.toString(exec));
 
     UString s;
index fe98df3..c373f87 100644 (file)
@@ -34,13 +34,13 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ObjectConstructor);
 
-static JSValue JSC_HOST_CALL objectConstructorGetPrototypeOf(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyDescriptor(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyNames(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectConstructorKeys(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectConstructorDefineProperty(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectConstructorDefineProperties(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectConstructorCreate(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL objectConstructorGetPrototypeOf(ExecState*);
+static JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyDescriptor(ExecState*);
+static JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyNames(ExecState*);
+static JSValue JSC_HOST_CALL objectConstructorKeys(ExecState*);
+static JSValue JSC_HOST_CALL objectConstructorDefineProperty(ExecState*);
+static JSValue JSC_HOST_CALL objectConstructorDefineProperties(ExecState*);
+static JSValue JSC_HOST_CALL objectConstructorCreate(ExecState*);
 
 ObjectConstructor::ObjectConstructor(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, ObjectPrototype* objectPrototype, Structure* prototypeFunctionStructure)
 : InternalFunction(&exec->globalData(), globalObject, structure, Identifier(exec, "Object"))
@@ -80,8 +80,9 @@ ConstructType ObjectConstructor::getConstructData(ConstructData& constructData)
     return ConstructTypeHost;
 }
 
-static JSValue JSC_HOST_CALL callObjectConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callObjectConstructor(ExecState* exec)
 {
+    ArgList args(exec);
     return constructObject(exec, args);
 }
 
@@ -91,21 +92,21 @@ CallType ObjectConstructor::getCallData(CallData& callData)
     return CallTypeHost;
 }
 
-JSValue JSC_HOST_CALL objectConstructorGetPrototypeOf(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectConstructorGetPrototypeOf(ExecState* exec)
 {
-    if (!args.at(0).isObject())
+    if (!exec->argument(0).isObject())
         return throwError(exec, TypeError, "Requested prototype of a value that is not an object.");
-    return asObject(args.at(0))->prototype();
+    return asObject(exec->argument(0))->prototype();
 }
 
-JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyDescriptor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyDescriptor(ExecState* exec)
 {
-    if (!args.at(0).isObject())
+    if (!exec->argument(0).isObject())
         return throwError(exec, TypeError, "Requested property descriptor of a value that is not an object.");
-    UString propertyName = args.at(1).toString(exec);
+    UString propertyName = exec->argument(1).toString(exec);
     if (exec->hadException())
         return jsNull();
-    JSObject* object = asObject(args.at(0));
+    JSObject* object = asObject(exec->argument(0));
     PropertyDescriptor descriptor;
     if (!object->getOwnPropertyDescriptor(exec, Identifier(exec, propertyName), descriptor))
         return jsUndefined();
@@ -128,12 +129,12 @@ JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyDescriptor(ExecState* exec,
 }
 
 // FIXME: Use the enumeration cache.
-JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyNames(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyNames(ExecState* exec)
 {
-    if (!args.at(0).isObject())
+    if (!exec->argument(0).isObject())
         return throwError(exec, TypeError, "Requested property names of a value that is not an object.");
     PropertyNameArray properties(exec);
-    asObject(args.at(0))->getOwnPropertyNames(exec, properties, IncludeDontEnumProperties);
+    asObject(exec->argument(0))->getOwnPropertyNames(exec, properties, IncludeDontEnumProperties);
     JSArray* names = constructEmptyArray(exec);
     size_t numProperties = properties.size();
     for (size_t i = 0; i < numProperties; i++)
@@ -142,12 +143,12 @@ JSValue JSC_HOST_CALL objectConstructorGetOwnPropertyNames(ExecState* exec, JSOb
 }
 
 // FIXME: Use the enumeration cache.
-JSValue JSC_HOST_CALL objectConstructorKeys(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectConstructorKeys(ExecState* exec)
 {
-    if (!args.at(0).isObject())
+    if (!exec->argument(0).isObject())
         return throwError(exec, TypeError, "Requested keys of a value that is not an object.");
     PropertyNameArray properties(exec);
-    asObject(args.at(0))->getOwnPropertyNames(exec, properties);
+    asObject(exec->argument(0))->getOwnPropertyNames(exec, properties);
     JSArray* keys = constructEmptyArray(exec);
     size_t numProperties = properties.size();
     for (size_t i = 0; i < numProperties; i++)
@@ -241,16 +242,16 @@ static bool toPropertyDescriptor(ExecState* exec, JSValue in, PropertyDescriptor
     return true;
 }
 
-JSValue JSC_HOST_CALL objectConstructorDefineProperty(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectConstructorDefineProperty(ExecState* exec)
 {
-    if (!args.at(0).isObject())
+    if (!exec->argument(0).isObject())
         return throwError(exec, TypeError, "Properties can only be defined on Objects.");
-    JSObject* O = asObject(args.at(0));
-    UString propertyName = args.at(1).toString(exec);
+    JSObject* O = asObject(exec->argument(0));
+    UString propertyName = exec->argument(1).toString(exec);
     if (exec->hadException())
         return jsNull();
     PropertyDescriptor descriptor;
-    if (!toPropertyDescriptor(exec, args.at(2), descriptor))
+    if (!toPropertyDescriptor(exec, exec->argument(2), descriptor))
         return jsNull();
     ASSERT((descriptor.attributes() & (Getter | Setter)) || (!descriptor.isAccessorDescriptor()));
     ASSERT(!exec->hadException());
@@ -292,26 +293,26 @@ static JSValue defineProperties(ExecState* exec, JSObject* object, JSObject* pro
     return object;
 }
 
-JSValue JSC_HOST_CALL objectConstructorDefineProperties(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectConstructorDefineProperties(ExecState* exec)
 {
-    if (!args.at(0).isObject())
+    if (!exec->argument(0).isObject())
         return throwError(exec, TypeError, "Properties can only be defined on Objects.");
-    if (!args.at(1).isObject())
+    if (!exec->argument(1).isObject())
         return throwError(exec, TypeError, "Property descriptor list must be an Object.");
-    return defineProperties(exec, asObject(args.at(0)), asObject(args.at(1)));
+    return defineProperties(exec, asObject(exec->argument(0)), asObject(exec->argument(1)));
 }
 
-JSValue JSC_HOST_CALL objectConstructorCreate(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectConstructorCreate(ExecState* exec)
 {
-    if (!args.at(0).isObject() && !args.at(0).isNull())
+    if (!exec->argument(0).isObject() && !exec->argument(0).isNull())
         return throwError(exec, TypeError, "Object prototype may only be an Object or null.");
     JSObject* newObject = constructEmptyObject(exec);
-    newObject->setPrototype(args.at(0));
-    if (args.at(1).isUndefined())
+    newObject->setPrototype(exec->argument(0));
+    if (exec->argument(1).isUndefined())
         return newObject;
-    if (!args.at(1).isObject())
+    if (!exec->argument(1).isObject())
         return throwError(exec, TypeError, "Property descriptor list must be an Object.");
-    return defineProperties(exec, newObject, asObject(args.at(1)));
+    return defineProperties(exec, newObject, asObject(exec->argument(1)));
 }
 
 } // namespace JSC
index 97601f3..87212da 100644 (file)
@@ -31,15 +31,15 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ObjectPrototype);
 
-static JSValue JSC_HOST_CALL objectProtoFuncValueOf(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncHasOwnProperty(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncIsPrototypeOf(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncDefineGetter(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncDefineSetter(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncLookupGetter(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncLookupSetter(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncPropertyIsEnumerable(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL objectProtoFuncToLocaleString(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL objectProtoFuncValueOf(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncHasOwnProperty(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncIsPrototypeOf(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncDefineGetter(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncDefineSetter(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncLookupGetter(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncLookupSetter(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncPropertyIsEnumerable(ExecState*);
+static JSValue JSC_HOST_CALL objectProtoFuncToLocaleString(ExecState*);
 
 ObjectPrototype::ObjectPrototype(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> stucture, Structure* prototypeFunctionStructure)
     : JSObject(stucture)
@@ -81,74 +81,84 @@ bool ObjectPrototype::getOwnPropertySlot(ExecState* exec, unsigned propertyName,
 
 // ECMA 15.2.4.2, 15.2.4.4, 15.2.4.5, 15.2.4.7
 
-JSValue JSC_HOST_CALL objectProtoFuncValueOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL objectProtoFuncValueOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     return thisValue.toThisObject(exec);
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncHasOwnProperty(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectProtoFuncHasOwnProperty(ExecState* exec)
 {
-    return jsBoolean(thisValue.toThisObject(exec)->hasOwnProperty(exec, Identifier(exec, args.at(0).toString(exec))));
+    JSValue thisValue = exec->hostThisValue();
+    return jsBoolean(thisValue.toThisObject(exec)->hasOwnProperty(exec, Identifier(exec, exec->argument(0).toString(exec))));
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncIsPrototypeOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectProtoFuncIsPrototypeOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSObject* thisObj = thisValue.toThisObject(exec);
 
-    if (!args.at(0).isObject())
+    if (!exec->argument(0).isObject())
         return jsBoolean(false);
 
-    JSValue v = asObject(args.at(0))->prototype();
+    JSValue v = asObject(exec->argument(0))->prototype();
 
     while (true) {
         if (!v.isObject())
             return jsBoolean(false);
-        if (v == thisObj)\v
+        if (v == thisObj)
             return jsBoolean(true);
         v = asObject(v)->prototype();
     }
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncDefineGetter(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectProtoFuncDefineGetter(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     CallData callData;
-    if (args.at(1).getCallData(callData) == CallTypeNone)
+    if (exec->argument(1).getCallData(callData) == CallTypeNone)
         return throwError(exec, SyntaxError, "invalid getter usage");
-    thisValue.toThisObject(exec)->defineGetter(exec, Identifier(exec, args.at(0).toString(exec)), asObject(args.at(1)));
+    thisValue.toThisObject(exec)->defineGetter(exec, Identifier(exec, exec->argument(0).toString(exec)), asObject(exec->argument(1)));
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncDefineSetter(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectProtoFuncDefineSetter(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     CallData callData;
-    if (args.at(1).getCallData(callData) == CallTypeNone)
+    if (exec->argument(1).getCallData(callData) == CallTypeNone)
         return throwError(exec, SyntaxError, "invalid setter usage");
-    thisValue.toThisObject(exec)->defineSetter(exec, Identifier(exec, args.at(0).toString(exec)), asObject(args.at(1)));
+    thisValue.toThisObject(exec)->defineSetter(exec, Identifier(exec, exec->argument(0).toString(exec)), asObject(exec->argument(1)));
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncLookupGetter(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectProtoFuncLookupGetter(ExecState* exec)
 {
-    return thisValue.toThisObject(exec)->lookupGetter(exec, Identifier(exec, args.at(0).toString(exec)));
+    JSValue thisValue = exec->hostThisValue();
+    return thisValue.toThisObject(exec)->lookupGetter(exec, Identifier(exec, exec->argument(0).toString(exec)));
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncLookupSetter(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectProtoFuncLookupSetter(ExecState* exec)
 {
-    return thisValue.toThisObject(exec)->lookupSetter(exec, Identifier(exec, args.at(0).toString(exec)));
+    JSValue thisValue = exec->hostThisValue();
+    return thisValue.toThisObject(exec)->lookupSetter(exec, Identifier(exec, exec->argument(0).toString(exec)));
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncPropertyIsEnumerable(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL objectProtoFuncPropertyIsEnumerable(ExecState* exec)
 {
-    return jsBoolean(thisValue.toThisObject(exec)->propertyIsEnumerable(exec, Identifier(exec, args.at(0).toString(exec))));
+    JSValue thisValue = exec->hostThisValue();
+    return jsBoolean(thisValue.toThisObject(exec)->propertyIsEnumerable(exec, Identifier(exec, exec->argument(0).toString(exec))));
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncToLocaleString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL objectProtoFuncToLocaleString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     return thisValue.toThisJSString(exec);
 }
 
-JSValue JSC_HOST_CALL objectProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL objectProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     return jsMakeNontrivialString(exec, "[object ", thisValue.toThisObject(exec)->className(), "]");
 }
 
index 47065d7..8865d6b 100644 (file)
@@ -36,7 +36,7 @@ namespace JSC {
         bool m_hasNoPropertiesWithUInt32Names;
     };
 
-    JSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
+    JSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*);
 
 } // namespace JSC
 
index 1228902..bd6c205 100644 (file)
@@ -189,15 +189,15 @@ namespace JSC {
         return new (globalData) JSString(globalData, ropeBuilder.release());
     }
 
-    ALWAYS_INLINE JSValue jsString(ExecState* exec, JSValue thisValue, const ArgList& args)
+    ALWAYS_INLINE JSValue jsString(ExecState* exec, JSValue thisValue)
     {
         unsigned fiberCount = 0;
         if (LIKELY(thisValue.isString()))
             fiberCount += asString(thisValue)->size();
         else
             ++fiberCount;
-        for (unsigned i = 0; i < args.size(); ++i) {
-            JSValue v = args.at(i);
+        for (unsigned i = 0; i < exec->argumentCount(); ++i) {
+            JSValue v = exec->argument(i);
             if (LIKELY(v.isString()))
                 fiberCount += asString(v)->size();
             else
@@ -216,8 +216,8 @@ namespace JSC {
         unsigned length = 0;
         bool overflow = false;
 
-        for (unsigned i = 0; i < args.size(); ++i) {
-            JSValue v = args.at(i);
+        for (unsigned i = 0; i < exec->argumentCount(); ++i) {
+            JSValue v = exec->argument(i);
             if (LIKELY(v.isString()))
                 ropeBuilder.append(asString(v));
             else
index 2306a11..fd16c0c 100644 (file)
@@ -34,11 +34,7 @@ JSValue PropertySlot::functionGetter(ExecState* exec) const
 
     CallData callData;
     CallType callType = m_data.getterFunc->getCallData(callData);
-    if (callType == CallTypeHost)
-        return callData.native.function(exec, m_data.getterFunc, thisValue(), exec->emptyList());
-    ASSERT(callType == CallTypeJS);
-    // FIXME: Can this be done more efficiently using the callData?
-    return asFunction(m_data.getterFunc)->call(exec, thisValue(), exec->emptyList());
+    return call(exec, m_data.getterFunc, callType, callData, thisValue(), exec->emptyList());
 }
 
 } // namespace JSC
index e7e6109..c79d5f8 100644 (file)
@@ -319,8 +319,9 @@ ConstructType RegExpConstructor::getConstructData(ConstructData& constructData)
 }
 
 // ECMA 15.10.3
-static JSValue JSC_HOST_CALL callRegExpConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callRegExpConstructor(ExecState* exec)
 {
+    ArgList args(exec);
     return constructRegExp(exec, args);
 }
 
index b04b55e..acec966 100644 (file)
@@ -113,21 +113,21 @@ void setRegExpObjectLastIndex(ExecState* exec, JSObject* baseObject, JSValue val
     asRegExpObject(baseObject)->setLastIndex(value.toInteger(exec));
 }
 
-JSValue RegExpObject::test(ExecState* exec, const ArgList& args)
+JSValue RegExpObject::test(ExecState* exec)
 {
-    return jsBoolean(match(exec, args));
+    return jsBoolean(match(exec));
 }
 
-JSValue RegExpObject::exec(ExecState* exec, const ArgList& args)
+JSValue RegExpObject::exec(ExecState* exec)
 {
-    if (match(exec, args))
+    if (match(exec))
         return exec->lexicalGlobalObject()->regExpConstructor()->arrayOfMatches(exec);
     return jsNull();
 }
 
-static JSValue JSC_HOST_CALL callRegExpObject(ExecState* exec, JSObject* function, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callRegExpObject(ExecState* exec)
 {
-    return asRegExpObject(function)->exec(exec, args);
+    return asRegExpObject(exec->callee())->exec(exec);
 }
 
 CallType RegExpObject::getCallData(CallData& callData)
@@ -137,11 +137,11 @@ CallType RegExpObject::getCallData(CallData& callData)
 }
 
 // Shared implementation used by test and exec.
-bool RegExpObject::match(ExecState* exec, const ArgList& args)
+bool RegExpObject::match(ExecState* exec)
 {
     RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
 
-    UString input = args.isEmpty() ? regExpConstructor->input() : args.at(0).toString(exec);
+    UString input = !exec->argumentCount() ? regExpConstructor->input() : exec->argument(0).toString(exec);
     if (input.isNull()) {
         throwError(exec, GeneralError, makeString("No input to ", toString(exec), "."));
         return false;
index 3324e53..f997374 100644 (file)
@@ -37,8 +37,8 @@ namespace JSC {
         void setLastIndex(double lastIndex) { d->lastIndex = lastIndex; }
         double lastIndex() const { return d->lastIndex; }
 
-        JSValue test(ExecState*, const ArgList&);
-        JSValue exec(ExecState*, const ArgList&);
+        JSValue test(ExecState*);
+        JSValue exec(ExecState*);
 
         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
         virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
@@ -56,7 +56,7 @@ namespace JSC {
         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | JSObjectWithGlobalObject::StructureFlags;
         
     private:
-        bool match(ExecState*, const ArgList&);
+        bool match(ExecState*);
 
         virtual CallType getCallData(CallData&);
 
index 9ebf105..0a531ac 100644 (file)
@@ -38,10 +38,10 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(RegExpPrototype);
 
-static JSValue JSC_HOST_CALL regExpProtoFuncTest(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL regExpProtoFuncExec(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL regExpProtoFuncCompile(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL regExpProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL regExpProtoFuncTest(ExecState*);
+static JSValue JSC_HOST_CALL regExpProtoFuncExec(ExecState*);
+static JSValue JSC_HOST_CALL regExpProtoFuncCompile(ExecState*);
+static JSValue JSC_HOST_CALL regExpProtoFuncToString(ExecState*);
 
 // ECMA 15.10.5
 
@@ -58,35 +58,38 @@ RegExpPrototype::RegExpPrototype(ExecState* exec, JSGlobalObject* globalObject,
 
 // ------------------------------ Functions ---------------------------
     
-JSValue JSC_HOST_CALL regExpProtoFuncTest(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL regExpProtoFuncTest(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&RegExpObject::info))
         return throwError(exec, TypeError);
-    return asRegExpObject(thisValue)->test(exec, args);
+    return asRegExpObject(thisValue)->test(exec);
 }
 
-JSValue JSC_HOST_CALL regExpProtoFuncExec(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL regExpProtoFuncExec(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&RegExpObject::info))
         return throwError(exec, TypeError);
-    return asRegExpObject(thisValue)->exec(exec, args);
+    return asRegExpObject(thisValue)->exec(exec);
 }
 
-JSValue JSC_HOST_CALL regExpProtoFuncCompile(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL regExpProtoFuncCompile(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&RegExpObject::info))
         return throwError(exec, TypeError);
 
     RefPtr<RegExp> regExp;
-    JSValue arg0 = args.at(0);
-    JSValue arg1 = args.at(1);
+    JSValue arg0 = exec->argument(0);
+    JSValue arg1 = exec->argument(1);
     
     if (arg0.inherits(&RegExpObject::info)) {
         if (!arg1.isUndefined())
             return throwError(exec, TypeError, "Cannot supply flags when constructing one RegExp from another.");
         regExp = asRegExpObject(arg0)->regExp();
     } else {
-        UString pattern = args.isEmpty() ? UString("") : arg0.toString(exec);
+        UString pattern = !exec->argumentCount() ? UString("") : arg0.toString(exec);
         UString flags = arg1.isUndefined() ? UString("") : arg1.toString(exec);
         regExp = RegExp::create(&exec->globalData(), pattern, flags);
     }
@@ -99,8 +102,9 @@ JSValue JSC_HOST_CALL regExpProtoFuncCompile(ExecState* exec, JSObject*, JSValue
     return jsUndefined();
 }
 
-JSValue JSC_HOST_CALL regExpProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL regExpProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     if (!thisValue.inherits(&RegExpObject::info)) {
         if (thisValue.inherits(&RegExpPrototype::info))
             return jsNontrivialString(exec, "//");
index b5c46b6..8f3a2df 100644 (file)
 
 namespace JSC {
 
-static NEVER_INLINE JSValue stringFromCharCodeSlowCase(ExecState* exec, const ArgList& args)
+static NEVER_INLINE JSValue stringFromCharCodeSlowCase(ExecState* exec)
 {
-    unsigned length = args.size();
+    unsigned length = exec->argumentCount();
     UChar* buf;
     PassRefPtr<UStringImpl> impl = UStringImpl::createUninitialized(length, buf);
     for (unsigned i = 0; i < length; ++i)
-        buf[i] = static_cast<UChar>(args.at(i).toUInt32(exec));
+        buf[i] = static_cast<UChar>(exec->argument(i).toUInt32(exec));
     return jsString(exec, impl);
 }
 
-static JSValue JSC_HOST_CALL stringFromCharCode(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL stringFromCharCode(ExecState* exec)
 {
-    if (LIKELY(args.size() == 1))
-        return jsSingleCharacterString(exec, args.at(0).toUInt32(exec));
-    return stringFromCharCodeSlowCase(exec, args);
+    if (LIKELY(exec->argumentCount() == 1))
+        return jsSingleCharacterString(exec, exec->argument(0).toUInt32(exec));
+    return stringFromCharCodeSlowCase(exec);
 }
 
 ASSERT_CLASS_FITS_IN_CELL(StringConstructor);
@@ -80,11 +80,11 @@ ConstructType StringConstructor::getConstructData(ConstructData& constructData)
 }
 
 // ECMA 15.5.1
-static JSValue JSC_HOST_CALL callStringConstructor(ExecState* exec, JSObject*, JSValue, const ArgList& args)
+static JSValue JSC_HOST_CALL callStringConstructor(ExecState* exec)
 {
-    if (args.isEmpty())
+    if (!exec->argumentCount())
         return jsEmptyString(exec);
-    return jsString(exec, args.at(0).toString(exec));
+    return jsString(exec, exec->argument(0).toString(exec));
 }
 
 CallType StringConstructor::getCallData(CallData& callData)
index 9df3dbb..f90d908 100644 (file)
@@ -45,40 +45,38 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(StringPrototype);
 
-static JSValue JSC_HOST_CALL stringProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncCharAt(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncCharCodeAt(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncConcat(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncIndexOf(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncLastIndexOf(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncReplace(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSearch(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSlice(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSplit(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSubstr(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSubstring(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncToLowerCase(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncToUpperCase(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncLocaleCompare(ExecState*, JSObject*, JSValue, const ArgList&);
-
-static JSValue JSC_HOST_CALL stringProtoFuncBig(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSmall(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncBlink(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncBold(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncFixed(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncItalics(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncStrike(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSub(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncSup(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncFontcolor(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncAnchor(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState*, JSObject*, JSValue, const ArgList&);
-
-static JSValue JSC_HOST_CALL stringProtoFuncTrim(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncTrimLeft(ExecState*, JSObject*, JSValue, const ArgList&);
-static JSValue JSC_HOST_CALL stringProtoFuncTrimRight(ExecState*, JSObject*, JSValue, const ArgList&);
+static JSValue JSC_HOST_CALL stringProtoFuncToString(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncCharAt(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncCharCodeAt(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncConcat(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncIndexOf(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncLastIndexOf(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncReplace(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSearch(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSlice(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSplit(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSubstr(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSubstring(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncToLowerCase(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncToUpperCase(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncLocaleCompare(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncBig(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSmall(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncBlink(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncBold(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncFixed(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncItalics(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncStrike(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSub(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncSup(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncFontcolor(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncAnchor(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncTrim(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncTrimLeft(ExecState*);
+static JSValue JSC_HOST_CALL stringProtoFuncTrimRight(ExecState*);
 
 }
 
@@ -288,11 +286,12 @@ static ALWAYS_INLINE JSValue jsSpliceSubstringsWithSeparators(ExecState* exec, J
     return jsString(exec, impl);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncReplace(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncReplace(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSString* sourceVal = thisValue.toThisJSString(exec);
-    JSValue pattern = args.at(0);
-    JSValue replacement = args.at(1);
+    JSValue pattern = exec->argument(0);
+    JSValue replacement = exec->argument(1);
 
     UString replacementString;
     CallData callData;
@@ -449,8 +448,9 @@ JSValue JSC_HOST_CALL stringProtoFuncReplace(ExecState* exec, JSObject*, JSValue
     return jsString(exec, source.substr(0, matchPos), substituteBackreferences(replacementString, source, ovector, 0), source.substr(matchEnd));
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncToString(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     // Also used for valueOf.
 
     if (thisValue.isString())
@@ -462,11 +462,12 @@ JSValue JSC_HOST_CALL stringProtoFuncToString(ExecState* exec, JSObject*, JSValu
     return throwError(exec, TypeError);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncCharAt(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncCharAt(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     unsigned len = s.size();
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
     if (a0.isUInt32()) {
         uint32_t i = a0.asUInt32();
         if (i < len)
@@ -479,11 +480,12 @@ JSValue JSC_HOST_CALL stringProtoFuncCharAt(ExecState* exec, JSObject*, JSValue
     return jsEmptyString(exec);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncCharCodeAt(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncCharCodeAt(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     unsigned len = s.size();
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
     if (a0.isUInt32()) {
         uint32_t i = a0.asUInt32();
         if (i < len)
@@ -496,25 +498,27 @@ JSValue JSC_HOST_CALL stringProtoFuncCharCodeAt(ExecState* exec, JSObject*, JSVa
     return jsNaN(exec);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncConcat(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncConcat(ExecState* exec)
 {
-    if (thisValue.isString() && (args.size() == 1)) {
-        JSValue v = args.at(0);
+    JSValue thisValue = exec->hostThisValue();
+    if (thisValue.isString() && (exec->argumentCount() == 1)) {
+        JSValue v = exec->argument(0);
         return v.isString()
             ? jsString(exec, asString(thisValue), asString(v))
             : jsString(exec, asString(thisValue), v.toString(exec));
     }
 
-    return jsString(exec, thisValue, args);
+    return jsString(exec, thisValue);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncIndexOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncIndexOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     int len = s.size();
 
-    JSValue a0 = args.at(0);
-    JSValue a1 = args.at(1);
+    JSValue a0 = exec->argument(0);
+    JSValue a1 = exec->argument(1);
     UString u2 = a0.toString(exec);
     int pos;
     if (a1.isUndefined())
@@ -536,13 +540,14 @@ JSValue JSC_HOST_CALL stringProtoFuncIndexOf(ExecState* exec, JSObject*, JSValue
     return jsNumber(exec, result);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncLastIndexOf(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     int len = s.size();
 
-    JSValue a0 = args.at(0);
-    JSValue a1 = args.at(1);
+    JSValue a0 = exec->argument(0);
+    JSValue a1 = exec->argument(1);
 
     UString u2 = a0.toString(exec);
     double dpos = a1.toIntegerPreserveNaN(exec);
@@ -562,11 +567,12 @@ JSValue JSC_HOST_CALL stringProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSV
     return jsNumber(exec, result);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
 
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
 
     UString u = s;
     RefPtr<RegExp> reg;
@@ -613,11 +619,12 @@ JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState* exec, JSObject*, JSValue t
     return constructArray(exec, list);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSearch(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncSearch(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
 
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
 
     UString u = s;
     RefPtr<RegExp> reg;
@@ -638,13 +645,14 @@ JSValue JSC_HOST_CALL stringProtoFuncSearch(ExecState* exec, JSObject*, JSValue
     return jsNumber(exec, pos);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSlice(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncSlice(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     int len = s.size();
 
-    JSValue a0 = args.at(0);
-    JSValue a1 = args.at(1);
+    JSValue a0 = exec->argument(0);
+    JSValue a1 = exec->argument(1);
 
     // The arg processing is very much like ArrayProtoFunc::Slice
     double start = a0.toInteger(exec);
@@ -662,12 +670,13 @@ JSValue JSC_HOST_CALL stringProtoFuncSlice(ExecState* exec, JSObject*, JSValue t
     return jsEmptyString(exec);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSplit(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncSplit(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
 
-    JSValue a0 = args.at(0);
-    JSValue a1 = args.at(1);
+    JSValue a0 = exec->argument(0);
+    JSValue a1 = exec->argument(1);
 
     JSArray* result = constructEmptyArray(exec);
     unsigned i = 0;
@@ -725,13 +734,14 @@ JSValue JSC_HOST_CALL stringProtoFuncSplit(ExecState* exec, JSObject*, JSValue t
     return result;
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSubstr(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncSubstr(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     int len = s.size();
 
-    JSValue a0 = args.at(0);
-    JSValue a1 = args.at(1);
+    JSValue a0 = exec->argument(0);
+    JSValue a1 = exec->argument(1);
 
     double start = a0.toInteger(exec);
     double length = a1.isUndefined() ? len : a1.toInteger(exec);
@@ -747,13 +757,14 @@ JSValue JSC_HOST_CALL stringProtoFuncSubstr(ExecState* exec, JSObject*, JSValue
     return jsSubstring(exec, s, static_cast<unsigned>(start), static_cast<unsigned>(length));
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSubstring(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncSubstring(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     int len = s.size();
 
-    JSValue a0 = args.at(0);
-    JSValue a1 = args.at(1);
+    JSValue a0 = exec->argument(0);
+    JSValue a1 = exec->argument(1);
 
     double start = a0.toNumber(exec);
     double end;
@@ -778,8 +789,9 @@ JSValue JSC_HOST_CALL stringProtoFuncSubstring(ExecState* exec, JSObject*, JSVal
     return jsSubstring(exec, s, static_cast<unsigned>(start), static_cast<unsigned>(end) - static_cast<unsigned>(start));
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncToLowerCase(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncToLowerCase(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSString* sVal = thisValue.toThisJSString(exec);
     const UString& s = sVal->value(exec);
 
@@ -815,8 +827,9 @@ JSValue JSC_HOST_CALL stringProtoFuncToLowerCase(ExecState* exec, JSObject*, JSV
     return jsString(exec, UString::adopt(buffer));
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncToUpperCase(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncToUpperCase(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     JSString* sVal = thisValue.toThisJSString(exec);
     const UString& s = sVal->value(exec);
 
@@ -852,81 +865,93 @@ JSValue JSC_HOST_CALL stringProtoFuncToUpperCase(ExecState* exec, JSObject*, JSV
     return jsString(exec, UString::adopt(buffer));
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncLocaleCompare(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncLocaleCompare(ExecState* exec)
 {
-    if (args.size() < 1)
+    JSValue thisValue = exec->hostThisValue();
+    if (exec->argumentCount() < 1)
       return jsNumber(exec, 0);
 
     UString s = thisValue.toThisString(exec);
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
     return jsNumber(exec, localeCompare(s, a0.toString(exec)));
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncBig(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncBig(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<big>", s, "</big>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSmall(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncSmall(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<small>", s, "</small>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncBlink(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncBlink(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<blink>", s, "</blink>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncBold(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncBold(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<b>", s, "</b>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncFixed(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncFixed(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<tt>", s, "</tt>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncItalics(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncItalics(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<i>", s, "</i>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncStrike(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncStrike(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<strike>", s, "</strike>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSub(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncSub(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<sub>", s, "</sub>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncSup(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncSup(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
     return jsMakeNontrivialString(exec, "<sup>", s, "</sup>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncFontcolor(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncFontcolor(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
     return jsMakeNontrivialString(exec, "<font color=\"", a0.toString(exec), "\">", s, "</font>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
 
     uint32_t smallInteger;
     if (a0.getUInt32(smallInteger) && smallInteger <= 9) {
@@ -965,17 +990,19 @@ JSValue JSC_HOST_CALL stringProtoFuncFontsize(ExecState* exec, JSObject*, JSValu
     return jsMakeNontrivialString(exec, "<font size=\"", a0.toString(exec), "\">", s, "</font>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncAnchor(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncAnchor(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
     return jsMakeNontrivialString(exec, "<a name=\"", a0.toString(exec), "\">", s, "</a>");
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
+JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     UString s = thisValue.toThisString(exec);
-    JSValue a0 = args.at(0);
+    JSValue a0 = exec->argument(0);
     UString linkText = a0.toString(exec);
 
     unsigned linkTextSize = linkText.size();
@@ -1036,18 +1063,21 @@ static inline JSValue trimString(ExecState* exec, JSValue thisValue, int trimKin
     return jsString(exec, str.substr(left, right - left));
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncTrim(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncTrim(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     return trimString(exec, thisValue, TrimLeft | TrimRight);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncTrimLeft(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncTrimLeft(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     return trimString(exec, thisValue, TrimLeft);
 }
 
-JSValue JSC_HOST_CALL stringProtoFuncTrimRight(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
+JSValue JSC_HOST_CALL stringProtoFuncTrimRight(ExecState* exec)
 {
+    JSValue thisValue = exec->hostThisValue();
     return trimString(exec, thisValue, TrimRight);
 }
     
index ac10c4e..78d63c6 100644 (file)
@@ -976,8 +976,10 @@ on MinGW. See https://bugs.webkit.org/show_bug.cgi?id=29268 */
 #define ENABLE_JIT_OPTIMIZE_CALL 1
 #endif
 #ifndef ENABLE_JIT_OPTIMIZE_NATIVE_CALL
+#if PLATFORM(MAC) || (PLATFORM(WIN) && CPU(X86))
 #define ENABLE_JIT_OPTIMIZE_NATIVE_CALL 1
 #endif
+#endif
 #ifndef ENABLE_JIT_OPTIMIZE_PROPERTY_ACCESS
 #define ENABLE_JIT_OPTIMIZE_PROPERTY_ACCESS 1
 #endif
index d442a77..353d9b0 100644 (file)
@@ -1,3 +1,26 @@
+2010-05-28  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.
+
+        Simplified the host calling convention.
+
+        PART ONE: Functional code changes.
+        
+        [ None in JavaScriptGlue ]
+        
+        PART TWO: Global search and replace.
+        
+        In the areas below, I used global search-and-replace to change
+            (ExecState*, JSObject*, JSValue, const ArgList&) => (ExecState*)
+            args.size() => exec->argumentCount()
+            args.at(i) => exec->argument(i)
+
+        * JSObject.cpp:
+        (nativeCallFunction):
+        * UserObjectImp.cpp:
+        (UserObjectImp::callAsFunction):
+        * UserObjectImp.h:
+
 2010-04-23  Sam Weinig  <sam@webkit.org>
 
         Reviewed by David Levin.
index 1d50bce..e1d1b15 100644 (file)
@@ -73,10 +73,10 @@ void JSUserObject::SetProperty(CFStringRef propertyName, JSUserObject* value)
 
 }
 
-static JSValue JSC_HOST_CALL nativeCallFunction(ExecState* exec, JSObject* functionObject, JSValue  thisValue, const ArgList& args);
-static JSValue  nativeCallFunction(ExecState* exec, JSObject* functionObject, JSValue  thisValue, const ArgList& args)
+static JSValue JSC_HOST_CALL nativeCallFunction(ExecState* exec);
+static JSValue  nativeCallFunction(ExecState* exec)
 {
-    return static_cast<UserObjectImp*>(functionObject)->callAsFunction(exec, asObject(thisValue), args);
+    return static_cast<UserObjectImp*>(exec->callee())->callAsFunction(exec);
 }
 
 CallType JSUserObject::getCallData(CallData& callData)
index c188f75..2176f16 100644 (file)
@@ -56,18 +56,18 @@ CallType UserObjectImp::getCallData(CallData& callData)
     return fJSUserObject ? fJSUserObject->getCallData(callData) : CallTypeNone;
 }
 
-JSValue UserObjectImp::callAsFunction(ExecState *exec, JSObject *thisObj, const ArgList &args)
+JSValue UserObjectImp::callAsFunction(ExecState *exec)
 {
     JSValue result = jsUndefined();
-    JSUserObject* jsThisObj = KJSValueToJSObject(thisObj, exec);
+    JSUserObject* jsThisObj = KJSValueToJSObject(exec->hostThisValue().toThisObject(exec), exec);
     if (jsThisObj) {
-        CFIndex argCount = args.size();
+        CFIndex argCount = exec->argumentCount();
         CFArrayCallBacks arrayCallBacks;
         JSTypeGetCFArrayCallBacks(&arrayCallBacks);
         CFMutableArrayRef jsArgs = CFArrayCreateMutable(0, 0, &arrayCallBacks);
         if (jsArgs) {
             for (CFIndex i = 0; i < argCount; i++) {
-                JSUserObject* jsArg = KJSValueToJSObject(args.at(i), exec);
+                JSUserObject* jsArg = KJSValueToJSObject(exec->argument(i), exec);
                 CFArrayAppendValue(jsArgs, (void*)jsArg);
                 jsArg->Release();
             }
index e44c40e..8dbad98 100644 (file)
@@ -46,7 +46,7 @@ public:
 
     virtual void getOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode mode = ExcludeDontEnumProperties);
 
-    virtual JSValue callAsFunction(ExecState *exec, JSObject *thisObj, const ArgList &args);
+    virtual JSValue callAsFunction(ExecState *exec);
     virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
     virtual void put(ExecState *exec, const Identifier &propertyName, JSValue value, PutPropertySlot&);
 
index 854edff..4f605f5 100644 (file)
@@ -1,3 +1,21 @@
+2010-05-28  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.
+
+        Simplified the host calling convention.
+
+        Changed these results to expect to fail to stringify their exception
+        objects in the case of stack overflow. (Standardizing the calling
+        convention has implicitly added stack overflow checks to some places
+        where they used to be missing.)
+        
+        In a future patch, I plan to implement a more reliable way to stringify
+        exceptions without invoking a JS function. For now, though, it seems best
+        to match other test results, instead of silently overflowing the stack.
+
+        * fast/js/global-recursion-on-full-stack-expected.txt:
+        * fast/xmlhttprequest/xmlhttprequest-recursive-sync-event-expected.txt:
+
 2010-05-28  Stephen White  <senorblanco@chromium.org>
 
         Reviewed by Darin Fisher.
index 2a8e26e..bd35c1e 100644 (file)
@@ -1,3 +1,3 @@
-CONSOLE MESSAGE: line 0: RangeError: Maximum call stack size exceeded.
+CONSOLE MESSAGE: line 0: 
 This tests global code recursion when the JS stack is full.
 PASS: Entering global code with a full JS stack did not crash, and did not allow continued recursion.
index 2e7d9cd..2811673 100644 (file)
@@ -1,6 +1,6 @@
-CONSOLE MESSAGE: line 0: RangeError: Maximum call stack size exceeded.
-CONSOLE MESSAGE: line 0: RangeError: Maximum call stack size exceeded.
-CONSOLE MESSAGE: line 0: RangeError: Maximum call stack size exceeded.
+CONSOLE MESSAGE: line 0: 
+CONSOLE MESSAGE: line 0: 
+CONSOLE MESSAGE: line 0: 
 This tests that having infinite recursion in XMLHttpRequest event handler does not crash. 
 PASS
 
index 269604e..673a839 100644 (file)
@@ -1,3 +1,260 @@
+2010-05-28  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig, Gavin Barraclough, Oliver Hunt.
+
+        Simplified the host calling convention.
+
+        PART ONE: Functional code changes.
+        
+        [ None in WebCore ]
+        
+        PART TWO: Global search and replace.
+        
+        In the areas below, I used global search-and-replace to change
+            (ExecState*, JSObject*, JSValue, const ArgList&) => (ExecState*)
+            args.size() => exec->argumentCount()
+            args.at(i) => exec->argument(i)
+
+        * bindings/js/JSArrayBufferViewCustom.cpp:
+        (WebCore::JSArrayBufferView::slice):
+        * bindings/js/JSArrayBufferViewHelper.h:
+        (WebCore::setWebGLArrayHelper):
+        * bindings/js/JSCanvasRenderingContext2DCustom.cpp:
+        (WebCore::JSCanvasRenderingContext2D::setFillColor):
+        (WebCore::JSCanvasRenderingContext2D::setStrokeColor):
+        (WebCore::JSCanvasRenderingContext2D::strokeRect):
+        (WebCore::JSCanvasRenderingContext2D::drawImage):
+        (WebCore::JSCanvasRenderingContext2D::drawImageFromRect):
+        (WebCore::JSCanvasRenderingContext2D::setShadow):
+        (WebCore::JSCanvasRenderingContext2D::createPattern):
+        (WebCore::JSCanvasRenderingContext2D::createImageData):
+        (WebCore::JSCanvasRenderingContext2D::putImageData):
+        (WebCore::JSCanvasRenderingContext2D::fillText):
+        (WebCore::JSCanvasRenderingContext2D::strokeText):
+        * bindings/js/JSClipboardCustom.cpp:
+        (WebCore::JSClipboard::clearData):
+        (WebCore::JSClipboard::getData):
+        (WebCore::JSClipboard::setDragImage):
+        * bindings/js/JSDOMApplicationCacheCustom.cpp:
+        (WebCore::JSDOMApplicationCache::hasItem):
+        (WebCore::JSDOMApplicationCache::add):
+        (WebCore::JSDOMApplicationCache::remove):
+        * bindings/js/JSDOMFormDataCustom.cpp:
+        (WebCore::JSDOMFormData::append):
+        * bindings/js/JSDOMWindowCustom.cpp:
+        (WebCore::JSDOMWindow::open):
+        (WebCore::JSDOMWindow::showModalDialog):
+        (WebCore::JSDOMWindow::postMessage):
+        (WebCore::JSDOMWindow::setTimeout):
+        (WebCore::JSDOMWindow::setInterval):
+        (WebCore::JSDOMWindow::addEventListener):
+        (WebCore::JSDOMWindow::removeEventListener):
+        (WebCore::JSDOMWindow::openDatabase):
+        * bindings/js/JSDatabaseCustom.cpp:
+        (WebCore::JSDatabase::changeVersion):
+        (WebCore::createTransaction):
+        (WebCore::JSDatabase::transaction):
+        (WebCore::JSDatabase::readTransaction):
+        * bindings/js/JSDatabaseSyncCustom.cpp:
+        (WebCore::JSDatabaseSync::changeVersion):
+        (WebCore::createTransaction):
+        (WebCore::JSDatabaseSync::transaction):
+        (WebCore::JSDatabaseSync::readTransaction):
+        * bindings/js/JSDedicatedWorkerContextCustom.cpp:
+        (WebCore::JSDedicatedWorkerContext::postMessage):
+        * bindings/js/JSDesktopNotificationsCustom.cpp:
+        (WebCore::JSNotificationCenter::requestPermission):
+        * bindings/js/JSFloatArrayCustom.cpp:
+        (WebCore::JSFloatArray::set):
+        * bindings/js/JSGeolocationCustom.cpp:
+        (WebCore::JSGeolocation::getCurrentPosition):
+        (WebCore::JSGeolocation::watchPosition):
+        * bindings/js/JSHTMLAllCollectionCustom.cpp:
+        (WebCore::callHTMLAllCollection):
+        (WebCore::JSHTMLAllCollection::item):
+        (WebCore::JSHTMLAllCollection::namedItem):
+        * bindings/js/JSHTMLCanvasElementCustom.cpp:
+        (WebCore::JSHTMLCanvasElement::getContext):
+        * bindings/js/JSHTMLCollectionCustom.cpp:
+        (WebCore::callHTMLCollection):
+        (WebCore::JSHTMLCollection::item):
+        (WebCore::JSHTMLCollection::namedItem):
+        * bindings/js/JSHTMLDocumentCustom.cpp:
+        (WebCore::JSHTMLDocument::open):
+        (WebCore::documentWrite):
+        (WebCore::JSHTMLDocument::write):
+        (WebCore::JSHTMLDocument::writeln):
+        * bindings/js/JSHTMLInputElementCustom.cpp:
+        (WebCore::JSHTMLInputElement::setSelectionRange):
+        * bindings/js/JSHTMLOptionsCollectionCustom.cpp:
+        (WebCore::JSHTMLOptionsCollection::add):
+        (WebCore::JSHTMLOptionsCollection::remove):
+        * bindings/js/JSHTMLSelectElementCustom.cpp:
+        (WebCore::JSHTMLSelectElement::remove):
+        * bindings/js/JSHistoryCustom.cpp:
+        (WebCore::JSHistory::pushState):
+        (WebCore::JSHistory::replaceState):
+        * bindings/js/JSInjectedScriptHostCustom.cpp:
+        (WebCore::JSInjectedScriptHost::databaseForId):
+        (WebCore::JSInjectedScriptHost::currentCallFrame):
+        (WebCore::JSInjectedScriptHost::nodeForId):
+        (WebCore::JSInjectedScriptHost::pushNodePathToFrontend):
+        (WebCore::JSInjectedScriptHost::selectDatabase):
+        (WebCore::JSInjectedScriptHost::selectDOMStorage):
+        (WebCore::JSInjectedScriptHost::reportDidDispatchOnInjectedScript):
+        * bindings/js/JSInspectorFrontendHostCustom.cpp:
+        (WebCore::JSInspectorFrontendHost::platform):
+        (WebCore::JSInspectorFrontendHost::port):
+        (WebCore::JSInspectorFrontendHost::showContextMenu):
+        * bindings/js/JSInt16ArrayCustom.cpp:
+        (WebCore::JSInt16Array::set):
+        * bindings/js/JSInt32ArrayCustom.cpp:
+        (WebCore::JSInt32Array::set):
+        * bindings/js/JSInt8ArrayCustom.cpp:
+        (WebCore::JSInt8Array::set):
+        * bindings/js/JSJavaScriptCallFrameCustom.cpp:
+        (WebCore::JSJavaScriptCallFrame::evaluate):
+        (WebCore::JSJavaScriptCallFrame::scopeType):
+        * bindings/js/JSLocationCustom.cpp:
+        (WebCore::JSLocation::replace):
+        (WebCore::JSLocation::reload):
+        (WebCore::JSLocation::assign):
+        (WebCore::JSLocation::toString):
+        * bindings/js/JSMessageEventCustom.cpp:
+        (WebCore::JSMessageEvent::initMessageEvent):
+        * bindings/js/JSMessagePortCustom.cpp:
+        (WebCore::JSMessagePort::postMessage):
+        * bindings/js/JSMessagePortCustom.h:
+        (WebCore::handlePostMessage):
+        * bindings/js/JSNodeCustom.cpp:
+        (WebCore::JSNode::insertBefore):
+        (WebCore::JSNode::replaceChild):
+        (WebCore::JSNode::removeChild):
+        (WebCore::JSNode::appendChild):
+        * bindings/js/JSNodeListCustom.cpp:
+        (WebCore::callNodeList):
+        * bindings/js/JSPluginElementFunctions.cpp:
+        (WebCore::callPlugin):
+        * bindings/js/JSSQLResultSetRowListCustom.cpp:
+        (WebCore::JSSQLResultSetRowList::item):
+        * bindings/js/JSSQLTransactionCustom.cpp:
+        (WebCore::JSSQLTransaction::executeSql):
+        * bindings/js/JSSQLTransactionSyncCustom.cpp:
+        (WebCore::JSSQLTransactionSync::executeSql):
+        * bindings/js/JSSVGLengthCustom.cpp:
+        (WebCore::JSSVGLength::convertToSpecifiedUnits):
+        * bindings/js/JSSVGMatrixCustom.cpp:
+        (WebCore::JSSVGMatrix::multiply):
+        (WebCore::JSSVGMatrix::inverse):
+        (WebCore::JSSVGMatrix::rotateFromVector):
+        * bindings/js/JSSVGPODListCustom.h:
+        (WebCore::JSSVGPODListCustom::clear):
+        (WebCore::JSSVGPODListCustom::initialize):
+        (WebCore::JSSVGPODListCustom::getItem):
+        (WebCore::JSSVGPODListCustom::insertItemBefore):
+        (WebCore::JSSVGPODListCustom::replaceItem):
+        (WebCore::JSSVGPODListCustom::removeItem):
+        (WebCore::JSSVGPODListCustom::appendItem):
+        * bindings/js/JSSVGPathSegListCustom.cpp:
+        (WebCore::JSSVGPathSegList::clear):
+        (WebCore::JSSVGPathSegList::initialize):
+        (WebCore::JSSVGPathSegList::getItem):
+        (WebCore::JSSVGPathSegList::insertItemBefore):
+        (WebCore::JSSVGPathSegList::replaceItem):
+        (WebCore::JSSVGPathSegList::removeItem):
+        (WebCore::JSSVGPathSegList::appendItem):
+        * bindings/js/JSUint16ArrayCustom.cpp:
+        (WebCore::JSUint16Array::set):
+        * bindings/js/JSUint32ArrayCustom.cpp:
+        (WebCore::JSUint32Array::set):
+        * bindings/js/JSUint8ArrayCustom.cpp:
+        (WebCore::JSUint8Array::set):
+        * bindings/js/JSWebGLRenderingContextCustom.cpp:
+        (WebCore::JSWebGLRenderingContext::bufferData):
+        (WebCore::JSWebGLRenderingContext::bufferSubData):
+        (WebCore::getObjectParameter):
+        (WebCore::JSWebGLRenderingContext::getBufferParameter):
+        (WebCore::JSWebGLRenderingContext::getFramebufferAttachmentParameter):
+        (WebCore::JSWebGLRenderingContext::getParameter):
+        (WebCore::JSWebGLRenderingContext::getProgramParameter):
+        (WebCore::JSWebGLRenderingContext::getRenderbufferParameter):
+        (WebCore::JSWebGLRenderingContext::getShaderParameter):
+        (WebCore::JSWebGLRenderingContext::getTexParameter):
+        (WebCore::JSWebGLRenderingContext::getUniform):
+        (WebCore::JSWebGLRenderingContext::getVertexAttrib):
+        (WebCore::JSWebGLRenderingContext::texImage2D):
+        (WebCore::JSWebGLRenderingContext::texSubImage2D):
+        (WebCore::dataFunctionf):
+        (WebCore::dataFunctioni):
+        (WebCore::dataFunctionMatrix):
+        (WebCore::JSWebGLRenderingContext::uniform1fv):
+        (WebCore::JSWebGLRenderingContext::uniform1iv):
+        (WebCore::JSWebGLRenderingContext::uniform2fv):
+        (WebCore::JSWebGLRenderingContext::uniform2iv):
+        (WebCore::JSWebGLRenderingContext::uniform3fv):
+        (WebCore::JSWebGLRenderingContext::uniform3iv):
+        (WebCore::JSWebGLRenderingContext::uniform4fv):
+        (WebCore::JSWebGLRenderingContext::uniform4iv):
+        (WebCore::JSWebGLRenderingContext::uniformMatrix2fv):
+        (WebCore::JSWebGLRenderingContext::uniformMatrix3fv):
+        (WebCore::JSWebGLRenderingContext::uniformMatrix4fv):
+        (WebCore::JSWebGLRenderingContext::vertexAttrib1fv):
+        (WebCore::JSWebGLRenderingContext::vertexAttrib2fv):
+        (WebCore::JSWebGLRenderingContext::vertexAttrib3fv):
+        (WebCore::JSWebGLRenderingContext::vertexAttrib4fv):
+        * bindings/js/JSWebSocketCustom.cpp:
+        (WebCore::JSWebSocket::send):
+        * bindings/js/JSWorkerContextCustom.cpp:
+        (WebCore::JSWorkerContext::importScripts):
+        (WebCore::JSWorkerContext::setTimeout):
+        (WebCore::JSWorkerContext::setInterval):
+        (WebCore::JSWorkerContext::openDatabase):
+        (WebCore::JSWorkerContext::openDatabaseSync):
+        * bindings/js/JSWorkerCustom.cpp:
+        (WebCore::JSWorker::postMessage):
+        * bindings/js/JSXMLHttpRequestCustom.cpp:
+        (WebCore::JSXMLHttpRequest::open):
+        (WebCore::JSXMLHttpRequest::send):
+        * bindings/js/JSXSLTProcessorCustom.cpp:
+        (WebCore::JSXSLTProcessor::importStylesheet):
+        (WebCore::JSXSLTProcessor::transformToFragment):
+        (WebCore::JSXSLTProcessor::transformToDocument):
+        (WebCore::JSXSLTProcessor::setParameter):
+        (WebCore::JSXSLTProcessor::getParameter):
+        (WebCore::JSXSLTProcessor::removeParameter):
+        * bindings/js/ScheduledAction.cpp:
+        (WebCore::ScheduledAction::create):
+        (WebCore::ScheduledAction::ScheduledAction):
+        * bindings/js/ScheduledAction.h:
+        * bindings/js/ScriptCallFrame.cpp:
+        (WebCore::ScriptCallFrame::ScriptCallFrame):
+        * bindings/js/ScriptCallFrame.h:
+        * bindings/js/ScriptCallStack.cpp:
+        (WebCore::ScriptCallStack::ScriptCallStack):
+        (WebCore::ScriptCallStack::initialize):
+        * bindings/js/ScriptCallStack.h:
+        * bindings/scripts/CodeGeneratorJS.pm:
+        * bridge/c/c_instance.cpp:
+        (JSC::Bindings::CInstance::invokeMethod):
+        (JSC::Bindings::CInstance::invokeDefaultMethod):
+        * bridge/c/c_instance.h:
+        * bridge/jni/jsc/JavaInstanceJSC.cpp:
+        (JavaInstance::invokeMethod):
+        * bridge/jni/jsc/JavaInstanceJSC.h:
+        * bridge/jsc/BridgeJSC.h:
+        (JSC::Bindings::Instance::invokeDefaultMethod):
+        * bridge/objc/objc_instance.h:
+        * bridge/objc/objc_instance.mm:
+        (ObjcInstance::invokeMethod):
+        (ObjcInstance::invokeObjcMethod):
+        (ObjcInstance::invokeDefaultMethod):
+        * bridge/objc/objc_runtime.mm:
+        (JSC::Bindings::callObjCFallbackObject):
+        * bridge/runtime_method.cpp:
+        (JSC::callRuntimeMethod):
+        * bridge/runtime_object.cpp:
+        (JSC::Bindings::callRuntimeObject):
+
 2010-05-28  Stephen White  <senorblanco@chromium.org>
 
         Reviewed by Darin Fisher.
index 271d096..a865a30 100644 (file)
@@ -67,23 +67,23 @@ JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, ArrayBu
     return jsUndefined();
 }
 
-JSValue JSArrayBufferView::slice(ExecState* exec, const ArgList& args)
+JSValue JSArrayBufferView::slice(ExecState* exec)
 {
     ArrayBufferView* array = reinterpret_cast<ArrayBufferView*>(impl());
 
     int start, end;
-    switch (args.size()) {
+    switch (exec->argumentCount()) {
     case 0:
         start = 0;
         end = array->length();
         break;
     case 1:
-        start = args.at(0).toInt32(exec);
+        start = exec->argument(0).toInt32(exec);
         end = array->length();
         break;
     default:
-        start = args.at(0).toInt32(exec);
-        end = args.at(1).toInt32(exec);
+        start = exec->argument(0).toInt32(exec);
+        end = exec->argument(1).toInt32(exec);
     }
     return toJS(exec, globalObject(), array->slice(start, end));
 }
index 7243db6..6b77c0c 100644 (file)
 namespace WebCore {
 
 template <class T>
-JSC::JSValue setWebGLArrayHelper(JSC::ExecState* exec, T* impl, JSC::ArgList const& args, T* (*conversionFunc)(JSC::JSValue))
+JSC::JSValue setWebGLArrayHelper(JSC::ExecState* exec, T* impl, T* (*conversionFunc)(JSC::JSValue))
 {
-    if (args.size() < 1)
+    if (exec->argumentCount() < 1)
         return throwError(exec, JSC::SyntaxError);
 
-    T* array = (*conversionFunc)(args.at(0));
+    T* array = (*conversionFunc)(exec->argument(0));
     if (array) {
         // void set(in WebGL<T>Array array, [Optional] in unsigned long offset);
         unsigned offset = 0;
-        if (args.size() == 2)
-            offset = args.at(1).toInt32(exec);
+        if (exec->argumentCount() == 2)
+            offset = exec->argument(1).toInt32(exec);
         ExceptionCode ec = 0;
         impl->set(array, offset, ec);
         setDOMException(exec, ec);
         return JSC::jsUndefined();
     }
 
-    if (args.at(0).isObject()) {
+    if (exec->argument(0).isObject()) {
         // void set(in sequence<long> array, [Optional] in unsigned long offset);
-        JSC::JSObject* array = JSC::asObject(args.at(0));
+        JSC::JSObject* array = JSC::asObject(exec->argument(0));
         uint32_t offset = 0;
-        if (args.size() == 2)
-            offset = args.at(1).toInt32(exec);
+        if (exec->argumentCount() == 2)
+            offset = exec->argument(1).toInt32(exec);
         uint32_t length = array->get(exec, JSC::Identifier(exec, "length")).toInt32(exec);
         if (offset > impl->length()
             || offset + length > impl->length()
index f8aa5a7..416f976 100644 (file)
@@ -89,7 +89,7 @@ void JSCanvasRenderingContext2D::setFillStyle(ExecState* exec, JSValue value)
     context->setFillStyle(toHTMLCanvasStyle(exec, value));
 }
 
-JSValue JSCanvasRenderingContext2D::setFillColor(ExecState* exec, const ArgList& args)
+JSValue JSCanvasRenderingContext2D::setFillColor(ExecState* exec)
 {
     CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl());
 
@@ -99,26 +99,26 @@ JSValue JSCanvasRenderingContext2D::setFillColor(ExecState* exec, const ArgList&
     // number arg, number arg = gray color, alpha
     // 4 args = r, g, b, a
     // 5 args = c, m, y, k, a
-    switch (args.size()) {
+    switch (exec->argumentCount()) {
         case 1:
-            if (args.at(0).isString())
-                context->setFillColor(ustringToString(asString(args.at(0))->value(exec)));
+            if (exec->argument(0).isString())
+                context->setFillColor(ustringToString(asString(exec->argument(0))->value(exec)));
             else
-                context->setFillColor(args.at(0).toFloat(exec));
+                context->setFillColor(exec->argument(0).toFloat(exec));
             break;
         case 2:
-            if (args.at(0).isString())
-                context->setFillColor(ustringToString(asString(args.at(0))->value(exec)), args.at(1).toFloat(exec));
+            if (exec->argument(0).isString())
+                context->setFillColor(ustringToString(asString(exec->argument(0))->value(exec)), exec->argument(1).toFloat(exec));
             else
-                context->setFillColor(args.at(0).toFloat(exec), args.at(1).toFloat(exec));
+                context->setFillColor(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec));
             break;
         case 4:
-            context->setFillColor(args.at(0).toFloat(exec), args.at(1).toFloat(exec),
-                                  args.at(2).toFloat(exec), args.at(3).toFloat(exec));
+            context->setFillColor(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec),
+                                  exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec));
             break;
         case 5:
-            context->setFillColor(args.at(0).toFloat(exec), args.at(1).toFloat(exec),
-                                  args.at(2).toFloat(exec), args.at(3).toFloat(exec), args.at(4).toFloat(exec));
+            context->setFillColor(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec),
+                                  exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec));
             break;
         default:
             return throwError(exec, SyntaxError);
@@ -126,7 +126,7 @@ JSValue JSCanvasRenderingContext2D::setFillColor(ExecState* exec, const ArgList&
     return jsUndefined();
 }    
 
-JSValue JSCanvasRenderingContext2D::setStrokeColor(ExecState* exec, const ArgList& args)
+JSValue JSCanvasRenderingContext2D::setStrokeColor(ExecState* exec)
 { 
     CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl());
 
@@ -136,26 +136,26 @@ JSValue JSCanvasRenderingContext2D::setStrokeColor(ExecState* exec, const ArgLis
     // number arg, number arg = gray color, alpha
     // 4 args = r, g, b, a
     // 5 args = c, m, y, k, a
-    switch (args.size()) {
+    switch (exec->argumentCount()) {
         case 1:
-            if (args.at(0).isString())
-                context->setStrokeColor(ustringToString(asString(args.at(0))->value(exec)));
+            if (exec->argument(0).isString())
+                context->setStrokeColor(ustringToString(asString(exec->argument(0))->value(exec)));
             else
-                context->setStrokeColor(args.at(0).toFloat(exec));
+                context->setStrokeColor(exec->argument(0).toFloat(exec));
             break;
         case 2:
-            if (args.at(0).isString())
-                context->setStrokeColor(ustringToString(asString(args.at(0))->value(exec)), args.at(1).toFloat(exec));
+            if (exec->argument(0).isString())
+                context->setStrokeColor(ustringToString(asString(exec->argument(0))->value(exec)), exec->argument(1).toFloat(exec));
             else
-                context->setStrokeColor(args.at(0).toFloat(exec), args.at(1).toFloat(exec));
+                context->setStrokeColor(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec));
             break;
         case 4:
-            context->setStrokeColor(args.at(0).toFloat(exec), args.at(1).toFloat(exec),
-                                    args.at(2).toFloat(exec), args.at(3).toFloat(exec));
+            context->setStrokeColor(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec),
+                                    exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec));
             break;
         case 5:
-            context->setStrokeColor(args.at(0).toFloat(exec), args.at(1).toFloat(exec),
-                                    args.at(2).toFloat(exec), args.at(3).toFloat(exec), args.at(4).toFloat(exec));
+            context->setStrokeColor(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec),
+                                    exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec));
             break;
         default:
             return throwError(exec, SyntaxError);
@@ -164,21 +164,21 @@ JSValue JSCanvasRenderingContext2D::setStrokeColor(ExecState* exec, const ArgLis
     return jsUndefined();
 }
 
-JSValue JSCanvasRenderingContext2D::strokeRect(ExecState* exec, const ArgList& args)
+JSValue JSCanvasRenderingContext2D::strokeRect(ExecState* exec)
 { 
     CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl());
     
-    if (args.size() <= 4)
-        context->strokeRect(args.at(0).toFloat(exec), args.at(1).toFloat(exec),
-                            args.at(2).toFloat(exec), args.at(3).toFloat(exec));
+    if (exec->argumentCount() <= 4)
+        context->strokeRect(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec),
+                            exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec));
     else
-        context->strokeRect(args.at(0).toFloat(exec), args.at(1).toFloat(exec),
-                            args.at(2).toFloat(exec), args.at(3).toFloat(exec), args.at(4).toFloat(exec));
+        context->strokeRect(exec->argument(0).toFloat(exec), exec->argument(1).toFloat(exec),
+                            exec->argument(2).toFloat(exec), exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec));
 
     return jsUndefined();    
 }
 
-JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& args)
+JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec)
 { 
     CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl());
 
@@ -188,7 +188,7 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& ar
     //     drawImage(img, sx, sy, sw, sh, dx, dy, dw, dh)
     // Composite operation is specified with globalCompositeOperation.
     // The img parameter can be a <img> or <canvas> element.
-    JSValue value = args.at(0);
+    JSValue value = exec->argument(0);
     if (!value.isObject())
         return throwError(exec, TypeError);
     JSObject* o = asObject(value);
@@ -196,20 +196,20 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& ar
     ExceptionCode ec = 0;
     if (o->inherits(&JSHTMLImageElement::s_info)) {
         HTMLImageElement* imgElt = static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(o)->impl());
-        switch (args.size()) {
+        switch (exec->argumentCount()) {
             case 3:
-                context->drawImage(imgElt, args.at(1).toFloat(exec), args.at(2).toFloat(exec), ec);
+                context->drawImage(imgElt, exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec), ec);
                 break;
             case 5:
-                context->drawImage(imgElt, args.at(1).toFloat(exec), args.at(2).toFloat(exec),
-                                   args.at(3).toFloat(exec), args.at(4).toFloat(exec), ec);
+                context->drawImage(imgElt, exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec),
+                                   exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec), ec);
                 setDOMException(exec, ec);
                 break;
             case 9:
-                context->drawImage(imgElt, FloatRect(args.at(1).toFloat(exec), args.at(2).toFloat(exec),
-                                   args.at(3).toFloat(exec), args.at(4).toFloat(exec)),
-                                   FloatRect(args.at(5).toFloat(exec), args.at(6).toFloat(exec),
-                                   args.at(7).toFloat(exec), args.at(8).toFloat(exec)), ec);
+                context->drawImage(imgElt, FloatRect(exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec),
+                                   exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec)),
+                                   FloatRect(exec->argument(5).toFloat(exec), exec->argument(6).toFloat(exec),
+                                   exec->argument(7).toFloat(exec), exec->argument(8).toFloat(exec)), ec);
                 setDOMException(exec, ec);
                 break;
             default:
@@ -217,20 +217,20 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& ar
         }
     } else if (o->inherits(&JSHTMLCanvasElement::s_info)) {
         HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(o)->impl());
-        switch (args.size()) {
+        switch (exec->argumentCount()) {
             case 3:
-                context->drawImage(canvas, args.at(1).toFloat(exec), args.at(2).toFloat(exec), ec);
+                context->drawImage(canvas, exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec), ec);
                 break;
             case 5:
-                context->drawImage(canvas, args.at(1).toFloat(exec), args.at(2).toFloat(exec),
-                                   args.at(3).toFloat(exec), args.at(4).toFloat(exec), ec);
+                context->drawImage(canvas, exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec),
+                                   exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec), ec);
                 setDOMException(exec, ec);
                 break;
             case 9:
-                context->drawImage(canvas, FloatRect(args.at(1).toFloat(exec), args.at(2).toFloat(exec),
-                                   args.at(3).toFloat(exec), args.at(4).toFloat(exec)),
-                                   FloatRect(args.at(5).toFloat(exec), args.at(6).toFloat(exec),
-                                   args.at(7).toFloat(exec), args.at(8).toFloat(exec)), ec);
+                context->drawImage(canvas, FloatRect(exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec),
+                                   exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec)),
+                                   FloatRect(exec->argument(5).toFloat(exec), exec->argument(6).toFloat(exec),
+                                   exec->argument(7).toFloat(exec), exec->argument(8).toFloat(exec)), ec);
                 setDOMException(exec, ec);
                 break;
             default:
@@ -239,20 +239,20 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& ar
 #if ENABLE(VIDEO)
     } else if (o->inherits(&JSHTMLVideoElement::s_info)) {
             HTMLVideoElement* video = static_cast<HTMLVideoElement*>(static_cast<JSHTMLElement*>(o)->impl());
-            switch (args.size()) {
+            switch (exec->argumentCount()) {
                 case 3:
-                    context->drawImage(video, args.at(1).toFloat(exec), args.at(2).toFloat(exec), ec);
+                    context->drawImage(video, exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec), ec);
                     break;
                 case 5:
-                    context->drawImage(video, args.at(1).toFloat(exec), args.at(2).toFloat(exec),
-                                       args.at(3).toFloat(exec), args.at(4).toFloat(exec), ec);
+                    context->drawImage(video, exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec),
+                                       exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec), ec);
                     setDOMException(exec, ec);
                     break;
                 case 9:
-                    context->drawImage(video, FloatRect(args.at(1).toFloat(exec), args.at(2).toFloat(exec),
-                                       args.at(3).toFloat(exec), args.at(4).toFloat(exec)),
-                                       FloatRect(args.at(5).toFloat(exec), args.at(6).toFloat(exec),
-                                       args.at(7).toFloat(exec), args.at(8).toFloat(exec)), ec);
+                    context->drawImage(video, FloatRect(exec->argument(1).toFloat(exec), exec->argument(2).toFloat(exec),
+                                       exec->argument(3).toFloat(exec), exec->argument(4).toFloat(exec)),
+                                       FloatRect(exec->argument(5).toFloat(exec), exec->argument(6).toFloat(exec),
+                                       exec->argument(7).toFloat(exec), exec->argument(8).toFloat(exec)), ec);
                     setDOMException(exec, ec);
                     break;
                 default:
@@ -266,11 +266,11 @@ JSValue JSCanvasRenderingContext2D::drawImage(ExecState* exec, const ArgList& ar
     return jsUndefined();    
 }
 
-JSValue JSCanvasRenderingContext2D::drawImageFromRect(ExecState* exec, const ArgList& args)
+JSValue JSCanvasRenderingContext2D::drawImageFromRect(ExecState* exec)
 { 
     CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl());
     
-    JSValue value = args.at(0);
+    JSValue value = exec->argument(0);
     if (!value.isObject())
         return throwError(exec, TypeError);
     JSObject* o = asObject(value);