2009-11-03 Mark Rowe <mrowe@apple.com> Merge r50443. 2009-11-02 Oliver Hunt <oliver@apple.com> Reviewed by Gavin Barraclough. REGRESSION (r48573): JSC may incorrectly cache chain lookups with a dictionary at the head of the chain https://bugs.webkit.org/show_bug.cgi?id=31045 Add guards to prevent caching of prototype chain lookups with dictionaries at the head of the chain. Also add a few tighter assertions to cached prototype lookups to catch this in future. * interpreter/Interpreter.cpp: (JSC::Interpreter::tryCacheGetByID): (JSC::Interpreter::privateExecute): * jit/JITStubs.cpp: (JSC::JITThunks::tryCacheGetByID): 2009-10-15 Mark Rowe <mrowe@apple.com> Merge r46777. 2009-08-04 Oliver Hunt <oliver@apple.com> Reviewed by NOBODY (build fix). PPC64 Build fix * wtf/Platform.h: 2009-10-14 Mark Rowe <mrowe@apple.com> Merge r47620. 2009-08-20 Oliver Hunt <oliver@apple.com> Reviewed by Gavin Barraclough. REGRESSION: fast/profiler/call.html is crashing occasionally https://bugs.webkit.org/show_bug.cgi?id=28476 Using the codeblock for information about how many parameters and locals a function has is unsafe in certain circumstances. The basic scenario is all function code being cleared in response to the debugger or profiler being enabled, and then an activation is marked before its associated function is re-executed. To deal with this scenario we store the variable count of a function directly in the FunctionExecutable, and then use that information. * runtime/Arguments.h: (JSC::Arguments::getArgumentsData): * runtime/Executable.cpp: (JSC::FunctionExecutable::generateBytecode): * runtime/Executable.h: (JSC::FunctionExecutable::FunctionExecutable): (JSC::FunctionExecutable::variableCount): * runtime/JSActivation.cpp: (JSC::JSActivation::markChildren): 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r48733. 2009-09-24 Mark Rowe <mrowe@apple.com> Reviewed by Sam Weinig. <rdar://problem/7215058> FastMalloc scavenging thread should be named * wtf/FastMalloc.cpp: (WTF::TCMalloc_PageHeap::scavengerThread): Set the thread name. * wtf/Platform.h: Move the knowledge of whether pthread_setname_np exists to here as HAVE(PTHREAD_SETNAME_NP). * wtf/ThreadingPthreads.cpp: (WTF::setThreadNameInternal): Use HAVE(PTHREAD_SETNAME_NP). 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r46725. 2009-08-03 Ada Chan <adachan@apple.com> Fixed the Tiger build. * wtf/FastMalloc.cpp: 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r46724. 2009-08-03 Ada Chan <adachan@apple.com> Reviewed by Darin Adler. Don't use background thread to scavenge memory on Tiger until we figure out why it causes a crash. https://bugs.webkit.org/show_bug.cgi?id=27900 * wtf/FastMalloc.cpp: 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r46648. 2009-07-31 Ada Chan <adachan@apple.com> Fixes the Windows release-PGO build. Reviewed by Jon Honeycutt. * JavaScriptCore.vcproj/WTF/WTF.vcproj: Suppresses the warning about unreachable code that we get by adding "return 0" to WTF::TCMalloc_PageHeap::runScavengerThread(). * wtf/FastMalloc.cpp: (WTF::TCMalloc_PageHeap::runScavengerThread): Fixes the error about the method not returning a value in the release-PGO build. 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r46511. 2009-07-28 Ada Chan <adachan@apple.com> Reviewed by Darin Adler. https://bugs.webkit.org/show_bug.cgi?id=27236 - Implement TCMalloc_SystemRelease and TCMalloc_SystemCommit for Windows. - Use a background thread to periodically scavenge memory to release back to the system. * wtf/FastMalloc.cpp: (WTF::TCMalloc_PageHeap::init): (WTF::TCMalloc_PageHeap::runScavengerThread): (WTF::TCMalloc_PageHeap::scavenge): (WTF::TCMalloc_PageHeap::shouldContinueScavenging): (WTF::TCMalloc_PageHeap::New): (WTF::TCMalloc_PageHeap::AllocLarge): (WTF::TCMalloc_PageHeap::Delete): (WTF::TCMalloc_PageHeap::GrowHeap): (WTF::sleep): (WTF::TCMalloc_PageHeap::scavengerThread): * wtf/TCSystemAlloc.cpp: (TCMalloc_SystemRelease): (TCMalloc_SystemCommit): * wtf/TCSystemAlloc.h: 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r46387. 2009-07-24 Ada Chan <adachan@apple.com> In preparation for https://bugs.webkit.org/show_bug.cgi?id=27236: Remove TCMALLOC_TRACK_DECOMMITED_SPANS. We'll always track decommitted spans. We have tested this and show it has little impact on performance. Reviewed by Mark Rowe. * wtf/FastMalloc.cpp: (WTF::TCMalloc_PageHeap::New): (WTF::TCMalloc_PageHeap::AllocLarge): (WTF::propagateDecommittedState): (WTF::mergeDecommittedStates): (WTF::TCMalloc_PageHeap::Delete): (WTF::TCMalloc_PageHeap::IncrementalScavenge): 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r48590. 2009-09-21 Oliver Hunt <oliver@apple.com> Reviewed by Geoff Garen. REGRESSION (r48582): Crash in StructureStubInfo::initPutByIdTransition when reloading trac.webkit.org https://bugs.webkit.org/show_bug.cgi?id=29599 It is unsafe to attempt to cache new property transitions on dictionaries of any type. * interpreter/Interpreter.cpp: (JSC::Interpreter::tryCachePutByID): * jit/JITStubs.cpp: (JSC::JITThunks::tryCachePutByID): 2009-10-13 Mark Rowe <mrowe@apple.com> Merge r49026. 2009-10-02 Steve Falkenburg <sfalken@apple.com> Reviewed by Mark Rowe. <https://bugs.webkit.org/show_bug.cgi?id=29989> Safari version number shouldn't be exposed in WebKit code For a WebKit version of 532.3.4: Product version is: 5.32.3.4 (was 4.0.3.0) File version is: 5.32.3.4 (was 4.532.3.4) * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.rc: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r48582. 2009-09-21 Oliver Hunt <oliver@apple.com> RS=Maciej Stachowiak. Re-land SNES fix with corrected assertion. * interpreter/Interpreter.cpp: (JSC::Interpreter::resolveGlobal): (JSC::Interpreter::tryCachePutByID): (JSC::Interpreter::tryCacheGetByID): * jit/JITStubs.cpp: (JSC::JITThunks::tryCachePutByID): (JSC::JITThunks::tryCacheGetByID): (JSC::DEFINE_STUB_FUNCTION): * runtime/BatchedTransitionOptimizer.h: (JSC::BatchedTransitionOptimizer::BatchedTransitionOptimizer): * runtime/JSObject.cpp: (JSC::JSObject::removeDirect): * runtime/Structure.cpp: (JSC::Structure::Structure): (JSC::Structure::getEnumerablePropertyNames): (JSC::Structure::despecifyDictionaryFunction): (JSC::Structure::addPropertyTransitionToExistingStructure): (JSC::Structure::addPropertyTransition): (JSC::Structure::removePropertyTransition): (JSC::Structure::toDictionaryTransition): (JSC::Structure::toCacheableDictionaryTransition): (JSC::Structure::toUncacheableDictionaryTransition): (JSC::Structure::fromDictionaryTransition): (JSC::Structure::removePropertyWithoutTransition): * runtime/Structure.h: (JSC::Structure::isDictionary): (JSC::Structure::isUncacheableDictionary): (JSC::Structure::): * runtime/StructureChain.cpp: (JSC::StructureChain::isCacheable): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r47605. 2009-08-20 Oliver Hunt <oliver@apple.com> Reviewed by Geoff Garen. REGRESSION: significant slowdown on Celtic Kane "AJAX declaration" subtest https://bugs.webkit.org/show_bug.cgi?id=28332 Follow up style fixes that were missed in review. * runtime/Structure.cpp: (JSC::Structure::hasTransition): * runtime/Structure.h: (JSC::Structure::get): (JSC::StructureTransitionTable::contains): * runtime/StructureTransitionTable.h: (JSC::StructureTransitionTable::add): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r47604. 2009-08-20 Oliver Hunt <oliver@apple.com> Reviewed by NOBODY (Build fix). Add new exports to windows jsc build * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r47601. 2009-08-20 Oliver Hunt <oliver@apple.com> Reviewed by Gavin Barraclough. REGRESSION: significant slowdown on Celtic Kane "AJAX declaration" subtest https://bugs.webkit.org/show_bug.cgi?id=28332 The method check optimisation made transitions aware of the value being assigned when a transition was assigning a function. This had the side effect of making every assignment of a function expression result in a new transition, and thus a new Structure. The net result of this is that the common JS idiom of function MyObject() { this.myFunction = function(...){...}; } new MyObject(); Will produce a unique structure on every iteration, meaning that all caching is defeated and there is a significant amount of structure churn. The fix is to return the transition to its original form where it is keyed off a property name + attributes tuple, but have each transition support an optional transition on a specific value. * JavaScriptCore.exp: * runtime/JSObject.h: (JSC::JSObject::putDirectInternal): * runtime/Structure.cpp: (JSC::Structure::~Structure): (JSC::Structure::addPropertyTransitionToExistingStructure): (JSC::Structure::addPropertyTransition): (JSC::Structure::hasTransition): * runtime/Structure.h: (JSC::Structure::transitionedFor): (JSC::Structure::hasTransition): (JSC::Structure::): (JSC::StructureTransitionTable::contains): (JSC::StructureTransitionTable::get): * runtime/StructureTransitionTable.h: (JSC::StructureTransitionTableHashTraits::emptyValue): (JSC::StructureTransitionTable::hasTransition): (JSC::StructureTransitionTable::remove): (JSC::StructureTransitionTable::add): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r47474. 2009-08-18 Oliver Hunt <oliver@apple.com> Reviewed by Gavin Barraclough. Assigning a function to an object should always use the existing transition, even if the transition is not specialized https://bugs.webkit.org/show_bug.cgi?id=28442 Check for an unspecialized transition as an alternative to always failing if specialisation does not match. * runtime/Structure.cpp: (JSC::Structure::addPropertyTransitionToExistingStructure): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r48830. 2009-09-28 Oliver Hunt <oliver@apple.com> Reviewed by Geoff Garen. Hard dependency on SSE2 instruction set with JIT https://bugs.webkit.org/show_bug.cgi?id=29779 Add floating point support checks to op_jfalse and op_jtrue, and fix the logic for the slow case of op_add * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_add): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jfalse): (JSC::JIT::emit_op_jtrue): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46706. 2009-08-02 Geoffrey Garen <ggaren@apple.com> Qt build fix. Added JSAPIValueWrapper.cpp to the build. * JavaScriptCore.pri: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46705. 2009-08-02 Geoffrey Garen <ggaren@apple.com> Windows build fix. Exported symbols for JSAPIValueWrapper. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46704. 2009-08-02 Geoffrey Garen <ggaren@apple.com> GTK build fix. * jit/JITStubs.cpp: #include <stdarg.h>, for a definition of va_start. 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46703. 2009-08-02 Geoffrey Garen <ggaren@apple.com> Qt build fix. * runtime/Collector.cpp: #include <limits.h>, for a definition of ULONG_MAX. 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46702. 2009-08-02 Geoffrey Garen <ggaren@apple.com> Windows build fix: Nixed JSImmediate::prototype, JSImmediate::toObject, and JSImmediate::toThisObject, and removed their exported symbols. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: * runtime/JSImmediate.cpp: * runtime/JSImmediate.h: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46701. 2009-08-02 Geoffrey Garen <ggaren@apple.com> Reviewed by Mark Rowe. Enabled JSVALUE32_64 by default on all platforms other than x86_64 (which uses JSVALUE64). * wtf/Platform.h: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46610. 2009-07-30 Geoffrey Garen <ggaren@apple.com> Reviewed by Gavin Barraclough. Fixed failing tests seen on Windows buildbot. * jit/JITStubs.cpp: (JSC::DEFINE_STUB_FUNCTION): * jit/JITStubs.h: (JSC::): Use "int" instead of "bool" to guarantee a 32-bit result, regardless of compiler. gcc on mac uses 32-bit values for bool, but gcc on linux and MSVC on Windows use 8-bit values. 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46601. 2009-07-30 Geoffrey Garen <ggaren@apple.com> Windows build fix: added missing symbols on Windows. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46599. 2009-07-30 Geoffrey Garen <ggaren@apple.com> Windows build fix: removed stale symbols on Windows. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46598. === End merge of nitro-extreme branch 2009-07-30 === 2009-07-20 Geoffrey Garen <ggaren@apple.com> Fixed a post-review typo in r46066 that caused tons of test failures. SunSpider reports no change. * runtime/JSArray.cpp: (JSC::JSArray::JSArray): Initialize the full vector capacity, to avoid uninitialized members at the end. 2009-07-20 Geoffrey Garen <ggaren@apple.com> Windows WebKit build fix: Added some missing exports. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-07-17 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Get the branch working on windows. https://bugs.webkit.org/show_bug.cgi?id=27391 SunSpider says 0.3% faster. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: Updated MSVC export lists to fix linker errors. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: Added / removed new / old project files. * jit/JIT.cpp: (JSC::JIT::privateCompileCTIMachineTrampolines): Used #pragma pack to tell MSVC that these structures represent actual memory layout, and should not be automatically aligned. Changed the return value load to load a 64bit quantity into the canonical registers. * jit/JIT.h: Moved OBJECT_OFFSETOF definition to StdLibExtras.h because it's needed by more than just the JIT, and it supplements a standard library macro (offsetof). * jit/JITCall.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): Fixed an incorrectly signed cast to resolve an MSVC warning. * jit/JITStubs.h: Used #pragma pack to tell MSVC that these structures represent actual memory layout, and should not be automatically aligned. * runtime/JSArray.cpp: (JSC::JSArray::JSArray): Replaced memset_pattern8 with a for loop, since memset_pattern8 is not portable. (I verified that this version of the loop gives the best performance / generated code in GCC.) * runtime/JSObject.h: (JSC::JSObject::JSObject): Removed accidental usage of FIELD_OFFSET -- OBJECT_OFFSETOF is our new macro name. (FIELD_OFFSET conflicts with a definition in winnt.h.) * runtime/JSValue.cpp: Added some headers needed by non-all-in-one builds. * runtime/JSValue.h: (JSC::JSValue::): Made the tag signed, to match MSVC's signed enum values. (GCC doesn't seem to care one way or the other.) * wtf/MainThread.cpp: Moved the StdLibExtras.h #include -- I did this a while ago to resolve a conflict with winnt.h. I can't remember if it's truly still needed, but what the heck. * wtf/StdLibExtras.h: Moved OBJECT_OFFSETOF definition here. 2009-07-06 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig (?). Fixed an assertion seen during the stress test. Don't assume that, if op1 is constant, op2 is not, and vice versa. Sadly, not all constants get folded. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emitSlow_op_jnlesseq): 2009-07-06 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Include op_convert_this in result caching. No change on SunSpider or v8. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_convert_this): * jit/JITStubs.cpp: (JSC::DEFINE_STUB_FUNCTION): * jit/JITStubs.h: (JSC::): Made the op_convert_this JIT stub return an EncodedJSValue, so to maintain the result caching contract that { tag, payload } can be found in { regT1, regT0 }. 2009-07-06 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Implemented result chaining. 1% faster on SunSpider. 4%-5% faster on v8. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::move): * assembler/X86Assembler.h: (JSC::X86Assembler::movl_rr): Added an optimization to eliminate no-op mov instructions, to simplify chaining. * jit/JIT.cpp: (JSC::JIT::JIT): * jit/JIT.h: Added data members and helper functions for recording chained results. We record both a mapping from virtual to machine register and the opcode for which the mapping is valid, to help ensure that the mapping isn't used after the mapped register has been stomped by other instructions. * jit/JITCall.cpp: (JSC::JIT::compileOpCallVarargs): (JSC::JIT::compileOpCallVarargsSlowCase): (JSC::JIT::emit_op_ret): (JSC::JIT::emit_op_construct_verify): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase): Chain function call results. * jit/JITInlineMethods.h: (JSC::JIT::emitLoadTag): (JSC::JIT::emitLoadPayload): (JSC::JIT::emitLoad): (JSC::JIT::emitLoad2): (JSC::JIT::isLabeled): (JSC::JIT::map): (JSC::JIT::unmap): (JSC::JIT::isMapped): (JSC::JIT::getMappedPayload): (JSC::JIT::getMappedTag): Use helper functions when loading virtual registers into machine registers, in case the loads can be eliminated by chaining. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_mov): (JSC::JIT::emit_op_end): (JSC::JIT::emit_op_instanceof): (JSC::JIT::emit_op_get_global_var): (JSC::JIT::emit_op_put_global_var): (JSC::JIT::emit_op_get_scoped_var): (JSC::JIT::emit_op_put_scoped_var): (JSC::JIT::emit_op_to_primitive): (JSC::JIT::emit_op_resolve_global): (JSC::JIT::emit_op_jneq_ptr): (JSC::JIT::emit_op_next_pname): (JSC::JIT::emit_op_to_jsnumber): (JSC::JIT::emit_op_catch): Chain results from these opcodes. (JSC::JIT::emit_op_profile_will_call): (JSC::JIT::emit_op_profile_did_call): Load the profiler into regT2 to avoid stomping a chained result. * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_method_check): (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emit_op_get_by_id): Chain results from these opcodes. * jit/JITStubCall.h: (JSC::JITStubCall::addArgument): Always use { regT1, regT0 }, to facilitate chaining. (JSC::JITStubCall::call): Unmap all mapped registers, since our callee stub might stomp them. 2009-07-01 Sam Weinig <sam@webkit.org> Reviewed by Gavin Barraclough. Don't reload values in emitBinaryDoubleOp. SunSpider reports a 0.6% progression. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emitBinaryDoubleOp): 2009-07-01 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Convert op_div to load op1 and op2 up front. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_div): 2009-07-01 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Don't emit code in emitBinaryDoubleOp if code is unreachable, observable via an empty (unlinked) jumplist passed in. This only effects op_jnless and op_jnlesseq at present. * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emitSlow_op_jnlesseq): (JSC::JIT::emitBinaryDoubleOp): 2009-07-01 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Converted op_mod to put { tag, payload } in { regT1, regT0 }, and tidied up its constant case. SunSpider reports a 0.2% regression, but a micro-benchmark of op_mod shows a 12% speedup, and the SunSpider test that uses op_mod most should benefit a lot from result caching in the end, since it almost always performs (expression) % constant. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_mod): (JSC::JIT::emitSlow_op_mod): 2009-06-30 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Converted some more arithmetic ops to put { tag, payload } in { regT1, regT0 }. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): 2009-06-30 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Converted some more arithmetic ops to put { tag, payload } in { regT1, regT0 }, and added a case for subtract constant. SunSpider says no change. v8 says 0.3% slower. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_add): (JSC::JIT::emitAdd32Constant): (JSC::JIT::emitSlow_op_add): (JSC::JIT::emit_op_sub): (JSC::JIT::emitSub32Constant): (JSC::JIT::emitSlow_op_sub): 2009-06-30 Gavin Barraclough <barraclough@apple.com> Reviewed by Sam Weinig. Remove more uses of addressFor(), load double constants directly from the constantpool in the CodeBlock, rather than from the register file. * jit/JITArithmetic.cpp: (JSC::JIT::emitAdd32Constant): (JSC::JIT::emitBinaryDoubleOp): 2009-06-30 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed a bug in postfix ops, where we would treat x = x++ and x = x-- as a no-op, even if x were not an int, and the ++/-- could have side-effects. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_post_inc): (JSC::JIT::emitSlow_op_post_inc): (JSC::JIT::emit_op_post_dec): (JSC::JIT::emitSlow_op_post_dec): 2009-06-30 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Converted some arithmetic ops to put { tag, payload } in { regT1, regT0 }. SunSpider says 0.7% faster. v8 says no change. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emit_op_lshift): (JSC::JIT::emit_op_rshift): (JSC::JIT::emit_op_bitand): (JSC::JIT::emit_op_bitor): (JSC::JIT::emit_op_bitxor): * jit/JITInlineMethods.h: (JSC::JIT::isOperandConstantImmediateInt): (JSC::JIT::getOperandConstantImmediateInt): 2009-06-30 Gavin Barraclough <barraclough@apple.com> Reviewed by Sam Weinig. Start removing cases of addressFor(). * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emitAdd32Constant): (JSC::JIT::emitBinaryDoubleOp): (JSC::JIT::emit_op_div): * jit/JITInlineMethods.h: (JSC::JIT::emitLoadDouble): (JSC::JIT::emitLoadInt32ToDouble): (JSC::JIT::emitStoreDouble): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jfalse): (JSC::JIT::emit_op_jtrue): 2009-06-30 Geoffrey Garen <ggaren@apple.com> Rolled back in my last patch with regression fixed. * jit/JIT.cpp: (JSC::JIT::privateCompileSlowCases): * jit/JIT.h: * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): (JSC::JIT::emit_op_resolve_global): (JSC::JIT::emitSlow_op_resolve_global): (JSC::JIT::emit_op_eq): (JSC::JIT::emitSlow_op_eq): (JSC::JIT::emit_op_neq): (JSC::JIT::emitSlow_op_neq): 2009-06-30 Geoffrey Garen <ggaren@apple.com> Rolled out my last patch because it was a 2% SunSpider regression. * jit/JIT.cpp: (JSC::JIT::privateCompileSlowCases): * jit/JIT.h: * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): (JSC::JIT::emit_op_resolve_global): (JSC::JIT::emit_op_eq): (JSC::JIT::emitSlow_op_eq): (JSC::JIT::emit_op_neq): (JSC::JIT::emitSlow_op_neq): 2009-06-30 Geoffrey Garen <ggaren@apple.com> Reviewed by Gavin "Sam Weinig" Barraclough. Standardized the rest of our opcodes to put { tag, payload } in { regT1, regT0 } where possible. * jit/JIT.cpp: (JSC::JIT::privateCompileSlowCases): * jit/JIT.h: * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): (JSC::JIT::emit_op_resolve_global): (JSC::JIT::emitSlow_op_resolve_global): (JSC::JIT::emit_op_eq): (JSC::JIT::emitSlow_op_eq): (JSC::JIT::emit_op_neq): (JSC::JIT::emitSlow_op_neq): 2009-06-30 Gavin Barraclough <barraclough@apple.com> Reviewed by Geoffrey Garen. Replace calls to store32(tagFor()) and store32(payloadFor()) with emitStoreInt32(), emitStoreBool(), and emitStoreCell(). * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_negate): (JSC::JIT::emit_op_lshift): (JSC::JIT::emit_op_rshift): (JSC::JIT::emit_op_bitand): (JSC::JIT::emitBitAnd32Constant): (JSC::JIT::emit_op_bitor): (JSC::JIT::emitBitOr32Constant): (JSC::JIT::emit_op_bitxor): (JSC::JIT::emitBitXor32Constant): (JSC::JIT::emit_op_bitnot): (JSC::JIT::emit_op_post_inc): (JSC::JIT::emit_op_post_dec): (JSC::JIT::emit_op_pre_inc): (JSC::JIT::emit_op_pre_dec): (JSC::JIT::emit_op_add): (JSC::JIT::emitAdd32Constant): (JSC::JIT::emit_op_sub): (JSC::JIT::emitSub32ConstantLeft): (JSC::JIT::emitSub32ConstantRight): (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): (JSC::JIT::emit_op_div): (JSC::JIT::emit_op_mod): * jit/JITCall.cpp: (JSC::JIT::emit_op_load_varargs): * jit/JITInlineMethods.h: (JSC::JIT::emitStoreInt32): (JSC::JIT::emitStoreCell): (JSC::JIT::emitStoreBool): (JSC::JIT::emitStore): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_instanceof): (JSC::JIT::emit_op_not): (JSC::JIT::emit_op_eq): (JSC::JIT::emitSlow_op_eq): (JSC::JIT::emit_op_neq): (JSC::JIT::emitSlow_op_neq): (JSC::JIT::compileOpStrictEq): (JSC::JIT::emit_op_eq_null): (JSC::JIT::emit_op_neq_null): * jit/JITStubCall.h: (JSC::JITStubCall::call): 2009-06-30 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Standardized the rest of the property access instructions to put { tag, payload } in { regT1, regT0 }. Small v8 speedup, 0.2% SunSpider slowdown. * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::emitLoad): (JSC::JIT::emitLoad2): * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emitSlow_op_get_by_val): (JSC::JIT::emit_op_put_by_val): (JSC::JIT::emitSlow_op_put_by_val): (JSC::JIT::emit_op_put_by_id): (JSC::JIT::emitSlow_op_put_by_id): (JSC::JIT::patchPutByIdReplace): 2009-06-29 Sam Weinig <sam@webkit.org> Reviewed by Gavin Barraclough. Various cleanups. - Use fpRegT* instead of X86::xmm*. - Use a switch statement in emitBinaryDoubleOp instead of a bunch of if/elses. * jit/JITArithmetic.cpp: (JSC::JIT::emitAdd32Constant): (JSC::JIT::emitBinaryDoubleOp): (JSC::JIT::emit_op_div): 2009-06-29 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Add inline code dealing with doubles for op_jfalse and op_jtrue. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::): (JSC::MacroAssemblerX86Common::zeroDouble): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jfalse): (JSC::JIT::emit_op_jtrue): 2009-06-28 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Standardized op_get_by_id to put { tag, payload } in { regT1, regT0 }. SunSpider and v8 report maybe 0.2%-0.4% regressions, but the optimization this enables will win much more than that back. * jit/JIT.cpp: (JSC::JIT::privateCompileCTIMachineTrampolines): * jit/JIT.h: * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_method_check): (JSC::JIT::emit_op_get_by_id): (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compileGetByIdSlowCase): (JSC::JIT::patchGetByIdSelf): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdSelfList): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain): 2009-06-26 Geoffrey Garen <ggaren@apple.com> Reviewed by Maciej Stachowiak. Standardized op_call to put { tag, payload } in { regT1, regT0 }. SunSpider and v8 report no change. * jit/JIT.cpp: (JSC::JIT::privateCompileCTIMachineTrampolines): * jit/JITCall.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): (JSC::JIT::compileOpCallSetupArgs): (JSC::JIT::compileOpConstructSetupArgs): (JSC::JIT::compileOpCallVarargsSetupArgs): (JSC::JIT::compileOpCallVarargs): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase): 2009-06-26 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Handle multiplying by zero a little better by inlining the case that both operands are non-negative into the slowpath. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::branchOr32): * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): 2009-06-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Optimize x++ to ++x inside for loops. Sadly, no measurable speedup, but this should help with result chaining. * parser/Nodes.cpp: (JSC::ForNode::emitBytecode): 2009-06-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }. * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_bitnot): (JSC::JIT::emit_op_post_inc): 2009-06-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_bitnot): (JSC::JIT::emit_op_post_dec): (JSC::JIT::emit_op_pre_inc): (JSC::JIT::emitSlow_op_pre_inc): (JSC::JIT::emit_op_pre_dec): (JSC::JIT::emitSlow_op_pre_dec): 2009-06-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_negate): (JSC::JIT::emitSlow_op_negate): * jit/JITCall.cpp: (JSC::JIT::emit_op_construct_verify): (JSC::JIT::emitSlow_op_construct_verify): 2009-06-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_true): (JSC::JIT::emit_op_jfalse): (JSC::JIT::emit_op_jtrue): (JSC::JIT::emit_op_jeq_null): (JSC::JIT::emit_op_jneq_null): (JSC::JIT::emit_op_eq_null): (JSC::JIT::emit_op_neq_null): 2009-06-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig (sort of, maybe). Fixed some ASSERTs in http/tests/security. These ASSERTs were introduced by http://trac.webkit.org/changeset/45057, but the underlying problem was actually older. http://trac.webkit.org/changeset/45057 just exposed the problem by enabling optimization in more cases. The ASSERTs fired because we tested PropertySlot::slotBase() for validity, but slotBase() ASSERTs if it's invalid, so we would ASSERT before the test could happen. Solution: Remove the ASSERT. Maybe it was valid once, but it clearly goes against a pattern we've deployed of late. The underlying problem was that WebCore would re-use a PropertySlot in the case of a forwarding access, and the second use would not completely overwrite the first use. Solution: Make sure to overwrite m_offset when setting a value on a PropertySlot. (Other values already get implicitly overwritten during reuse.) * runtime/PropertySlot.h: (JSC::PropertySlot::PropertySlot): (JSC::PropertySlot::setValueSlot): (JSC::PropertySlot::setValue): (JSC::PropertySlot::setRegisterSlot): (JSC::PropertySlot::setUndefined): (JSC::PropertySlot::slotBase): (JSC::PropertySlot::clearOffset): 2009-06-24 Gavin Barraclough <barraclough@apple.com> Reviewed by Geoff Garen. Enable JIT_OPTIMIZE_METHOD_CALLS on the branch, implementation matches current implemenatation in ToT. * jit/JIT.h: * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_method_check): (JSC::JIT::emitSlow_op_method_check): (JSC::JIT::emit_op_get_by_id): (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::emitSlow_op_get_by_id): (JSC::JIT::compileGetByIdSlowCase): 2009-06-23 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Bit off a tiny bit more of standardizing opcode behavior to help with result caching. SunSpider reports no change, v8 maybe a tiny speedup. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_to_jsnumber): (JSC::JIT::emitSlow_op_to_jsnumber): (JSC::JIT::emit_op_convert_this): (JSC::JIT::emitSlow_op_convert_this): 2009-06-23 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Bit off a tiny bit more of standardizing opcode behavior to help with result caching -- including removing my old enemy, op_resolve_function, because it was non-standard, and removing it felt better than helping it limp along. SunSpider reports no change, v8 maybe a tiny speedup. * bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): * bytecode/Opcode.h: * bytecompiler/BytecodeGenerator.cpp: * bytecompiler/BytecodeGenerator.h: * interpreter/Interpreter.cpp: (JSC::Interpreter::privateExecute): * jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): * jit/JIT.h: * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_get_scoped_var): (JSC::JIT::emit_op_put_scoped_var): (JSC::JIT::emit_op_to_primitive): (JSC::JIT::emitSlow_op_to_primitive): * jit/JITStubs.cpp: * jit/JITStubs.h: * parser/Nodes.cpp: (JSC::FunctionCallResolveNode::emitBytecode): 2009-06-23 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Bit off a tiny bit of standardizing opcode behavior to help with result caching. 0.6% SunSpider speedup. 0.3% v8 speedup. * jit/JITInlineMethods.h: (JSC::JIT::emitLoad): Accomodate a base register that overlaps with payload by loading tag before payload, to avoid stomping base/payload. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_mov): Abide by the standard "tag in regT1, payload in regT0" semantics. (JSC::JIT::emit_op_get_global_var): (JSC::JIT::emit_op_put_global_var): Ditto. Also, removed some irrelevent loads while I was at it. The global object's "d" pointer never changes after construction. 2009-06-23 Gavin Barraclough <barraclough@apple.com> Reviewed by Sam Weinig. Remove 'arguments' field from Register union (again). This time do so without breaking tests (radical, I know). * interpreter/CallFrame.h: (JSC::ExecState::optionalCalleeArguments): (JSC::ExecState::setArgumentCount): (JSC::ExecState::init): * interpreter/Interpreter.cpp: (JSC::Interpreter::dumpRegisters): (JSC::Interpreter::unwindCallFrame): (JSC::Interpreter::privateExecute): (JSC::Interpreter::retrieveArguments): * interpreter/Register.h: (JSC::Register::withInt): (JSC::Register::): (JSC::Register::Register): (JSC::Register::i): * jit/JITStubs.cpp: (JSC::JITStubs::cti_op_tear_off_arguments): * runtime/Arguments.h: (JSC::JSActivation::copyRegisters): (JSC::Register::arguments): * runtime/JSActivation.cpp: (JSC::JSActivation::argumentsGetter): * runtime/JSActivation.h: 2009-06-23 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Removed some result register tracking cruft in preparation for a new result tracking mechanism. SunSpider reports no change. * assembler/AbstractMacroAssembler.h: * assembler/X86Assembler.h: (JSC::X86Assembler::JmpDst::JmpDst): No need to track jump targets in machine code; we already do this in bytecode. * jit/JIT.cpp: (JSC::JIT::JIT): (JSC::JIT::emitTimeoutCheck): Make sure to save and restore the result registers, so an opcode with a timeout check can still benefit from result register caching. (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): Removed calls to killLastResultRegister() in preparation for something new. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emit_op_jnlesseq): * jit/JITInlineMethods.h: (JSC::JIT::emitGetFromCallFrameHeaderPtr): (JSC::JIT::emitGetFromCallFrameHeader32): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jmp): (JSC::JIT::emit_op_jfalse): (JSC::JIT::emit_op_jtrue): (JSC::JIT::emit_op_jeq_null): (JSC::JIT::emit_op_jneq_null): (JSC::JIT::emit_op_jneq_ptr): (JSC::JIT::emit_op_jsr): (JSC::JIT::emit_op_sret): (JSC::JIT::emit_op_jmp_scopes): ditto * jit/JITStubCall.h: (JSC::JITStubCall::JITStubCall): (JSC::JITStubCall::getArgument): added a mechanism for reloading an argument you passed to a JIT stub, for use in emitTimeoutCheck. 2009-06-23 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Remove now-useless inplace variants of binary ops. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_bitand): (JSC::JIT::emit_op_bitor): (JSC::JIT::emit_op_bitxor): (JSC::JIT::emit_op_add): (JSC::JIT::emit_op_sub): (JSC::JIT::emit_op_mul): 2009-06-23 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Move off memory operands to aid in re-enabling result caching. - No regression measured. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_negate): (JSC::JIT::emit_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emit_op_lshift): (JSC::JIT::emit_op_rshift): (JSC::JIT::emit_op_bitand): (JSC::JIT::emitBitAnd32Constant): (JSC::JIT::emitBitAnd32InPlace): (JSC::JIT::emit_op_bitor): (JSC::JIT::emitBitOr32Constant): (JSC::JIT::emitBitOr32InPlace): (JSC::JIT::emit_op_bitxor): (JSC::JIT::emitBitXor32Constant): (JSC::JIT::emitBitXor32InPlace): (JSC::JIT::emit_op_bitnot): (JSC::JIT::emit_op_post_inc): (JSC::JIT::emit_op_post_dec): (JSC::JIT::emit_op_pre_inc): (JSC::JIT::emitSlow_op_pre_inc): (JSC::JIT::emit_op_pre_dec): (JSC::JIT::emitSlow_op_pre_dec): (JSC::JIT::emit_op_add): (JSC::JIT::emitAdd32Constant): (JSC::JIT::emitAdd32InPlace): (JSC::JIT::emitSlow_op_add): (JSC::JIT::emitSlowAdd32Constant): (JSC::JIT::emit_op_sub): (JSC::JIT::emitSlow_op_sub): (JSC::JIT::emitSub32ConstantLeft): (JSC::JIT::emitSub32ConstantRight): (JSC::JIT::emitSub32InPlaceLeft): (JSC::JIT::emitSub32InPlaceRight): (JSC::JIT::emitBinaryDoubleOp): (JSC::JIT::emit_op_mul): (JSC::JIT::emitMul32InPlace): (JSC::JIT::emit_op_div): (JSC::JIT::emit_op_mod): * jit/JITCall.cpp: (JSC::JIT::compileOpCallVarargs): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): (JSC::JIT::emit_op_instanceof): (JSC::JIT::emit_op_to_primitive): (JSC::JIT::emit_op_not): (JSC::JIT::emit_op_jneq_ptr): (JSC::JIT::emit_op_eq): (JSC::JIT::emit_op_neq): (JSC::JIT::emit_op_to_jsnumber): * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emit_op_put_by_val): 2009-06-23 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed some missing and/or misplaced labels in bytecode generation, so we don't have to work around them in JIT code generation. * bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::emitJumpSubroutine): * parser/Nodes.cpp: (JSC::TryNode::emitBytecode): 2009-06-22 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. For member function calls, emit "this" directly into the "this" slot for the function call, instead of moving it there later. This reduces time spent in op_mov during certain calls, like "a.b.c()". 1%-2% speedup on v8, mostly richards and delta-blue. * parser/Nodes.cpp: (JSC::FunctionCallDotNode::emitBytecode): 2009-06-22 Gavin Barraclough <barraclough@apple.com> Reviewed by Sam Weinig. Remove 'arguments' field from Register union. Having JSCell derived types in the union is dangerous since it opens the possibility for the field to be written as a raw pointer but then read as a JSValue. This will lead to statle data being read for the tag, which may be dangerous. Having removed Arguments* types form Register, all arguments objects must always explicitly be stored in the register file as JSValues. * interpreter/CallFrame.h: (JSC::ExecState::optionalCalleeArguments): * interpreter/Interpreter.cpp: (JSC::Interpreter::unwindCallFrame): (JSC::Interpreter::privateExecute): (JSC::Interpreter::retrieveArguments): * interpreter/Register.h: (JSC::Register::): * jit/JITStubs.cpp: (JSC::JITStubs::cti_op_tear_off_arguments): * runtime/Arguments.h: (JSC::JSActivation::copyRegisters): * runtime/JSActivation.cpp: (JSC::JSActivation::argumentsGetter): * runtime/JSActivation.h: 2009-06-03 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Add back known this value optimization by abstracting slow case if not JSCell jumps. * jit/JIT.h: * jit/JITCall.cpp: (JSC::JIT::compileOpCallVarargs): (JSC::JIT::compileOpCallVarargsSlowCase): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase): * jit/JITInlineMethods.h: (JSC::JIT::emitJumpSlowCaseIfNotJSCell): (JSC::JIT::linkSlowCaseIfNotJSCell): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_instanceof): (JSC::JIT::emitSlow_op_instanceof): * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emitSlow_op_get_by_val): (JSC::JIT::emit_op_put_by_val): (JSC::JIT::emitSlow_op_put_by_val): (JSC::JIT::emit_op_get_by_id): (JSC::JIT::emitSlow_op_get_by_id): (JSC::JIT::emit_op_put_by_id): (JSC::JIT::emitSlow_op_put_by_id): 2009-06-01 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed some of the regression in crypto-aes.js. (8.5% speedup in crypto-aes.js.) SunSpider reports no change overall. Division was producing double results, which took the slow path through array access code. Strangely, all my attempts at versions of this patch that modified array access code to accept ints encoded as doubles along the fast or slow paths were regressions. So I did this instead. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_div): When dividing an int by an int, go ahead and try to turn the result into an int. Don't just do int division, though, because testing shows it to be slower than SSE double division, and the corner cases are pretty complicated / lengthy on top of that. Also, don't try to canonicalize division of known tiny numerators into ints, since that's a waste of time. 2009-05-26 Geoffrey Garen <ggaren@apple.com> Reviewed by Oliver Hunt. Fixed a regression caused by my recent fix for NaN. * jit/JITArithmetic.cpp: (JSC::JIT::emitBinaryDoubleOp): Actually do the comparison in reverse order, like the ChangeLog said we would, bokay? 2009-05-26 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig and Oliver Hunt. Fixed two edge cases in %: - Don't do -2147483648 % x as a fast case, since you might do -2147483648 % -1, which will signal a hardware exception due to overflow. - In the case of a zero remainder, be sure to store negative zero if the dividend was zero. SunSpider reports no change. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_mod): (JSC::JIT::emitSlow_op_mod): 2009-05-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Maciej Stachowiak. Fixed a regression when comparing to NaN. * jit/JITArithmetic.cpp: (JSC::JIT::emitBinaryDoubleOp): For op_jnless and op_jnless_eq, do the comparison in reverse order, and jump if the result is below or below-or-equal. This ensures that we do jump in the case of NaN. 2009-05-25 Geoffrey Garen <ggaren@apple.com> Reviewed by Oliver Hunt. SunSpider says no change. Fixed regressions in fast/js/var-declarations-shadowing.html and fast/js/equality.html, caused by recent == and != optimizations. * jit/JITStubs.cpp: (JSC::JITStubs::cti_op_eq): Don't treat "compare to string" as always numeric or string comparison. If the second operand is an object, you need to ToPrimitive it, and start all over again. Also, I wrote out each of the possible cases explicitly, to cut down on redundant branching. 2009-05-25 Sam Weinig <sam@webkit.org> Reviewed by Mark Rowe. Fix bug in fast/js/constant-folding.html where we were not negating -0 properly. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_negate): 2009-05-23 Geoffrey Garen <ggaren@apple.com> Reviewed by Oliver Hunt. Refactored new slow case codegen for == and !=. SunSpider reports no change, maybe a tiny speedup. * jit/JITOpcodes.cpp: (JSC::JIT::emitSlow_op_eq): (JSC::JIT::emitSlow_op_neq): Made a vptr comparison a *Ptr operation, instead of *32, to make it portable to 64bit. Reorganized the string and generic cases to make their control flow a little clearer. 2009-05-23 Geoffrey Garen <ggaren@apple.com> Reviewed by Maciej Stachowiak. Optimized == and != for our new value representation -- especially for strings. 14% speedup on date-format-tofte. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_eq): (JSC::JIT::emitSlow_op_eq): (JSC::JIT::emit_op_neq): (JSC::JIT::emitSlow_op_neq): * jit/JITStubCall.h: (JSC::JITStubCall::JITStubCall): * jit/JITStubs.cpp: (JSC::JITStubs::cti_op_eq): (JSC::JITStubs::cti_op_eq_strings): (JSC::JITStubs::cti_op_call_eval): * jit/JITStubs.h: (JSC::): * runtime/JSValue.h: 2009-05-22 Sam Weinig <sam@webkit.org> Reviewed by Gavin Barraclough. Fix non-SSE enabled builds. * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_add): Don't early return here, we still need to call the JIT stub. (JSC::JIT::emitSlow_op_sub): Ditto. 2009-05-22 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Here's a thought: let's not take a jit stub call just to multiply by 1, bokay? imul doesn't set the zero flag, so to test for a zero result, we need an explicit instruction. (Luckily, it does set the overflow flag, so we can still use that.) * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): (JSC::JIT::emitMul32InPlace): 2009-05-22 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey "Premature Commit" Garen. Add back constant integer cases for op_add. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_add): (JSC::JIT::emitAdd32Constant): (JSC::JIT::emitSlow_op_add): (JSC::JIT::emitSlowAdd32Constant): * jit/JITInlineMethods.h: (JSC::JIT::getConstantOperandImmediateDouble): (JSC::JIT::isOperandConstantImmediateDouble): 2009-05-22 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added fast double cases for op_jnless and op_jnlesseq. * assembler/AbstractMacroAssembler.h: (JSC::AbstractMacroAssembler::JumpList::jumps): New accesor, used by addSlowCase. * assembler/X86Assembler.h: (JSC::X86Assembler::ucomisd_rm): New method for comparing register to memory. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emitSlow_op_jnlesseq): (JSC::JIT::emit_op_add): (JSC::JIT::emit_op_sub): (JSC::JIT::emitBinaryDoubleOp): (JSC::JIT::emit_op_mul): (JSC::JIT::emit_op_div): Modified emitBinaryDoubleOp to accept comparison/jump operations in addition to operations with explicit result registers. * jit/JITInlineMethods.h: (JSC::JIT::addSlowCase): Added an "addSlowCase" for JumpLists, so clients can track multiple jumps to the same slow case condition together. 2009-05-21 Sam Weinig <sam@webkit.org> Reviewed by Gavin Barraclough. Implement op_negate inline fast cases. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::neg32): * assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::negl_m): (JSC::X86Assembler::xorpd_rr): * jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_negate): (JSC::JIT::emitSlow_op_negate): 2009-05-20 Sam Weinig <sam@webkit.org> Reviewed by Gavin Barraclough. Update the patchOffsetGetByIdSlowCaseCall constant for the case that OPCODE_SAMPLING is enabled. * jit/JIT.h: 2009-05-20 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added support for inline subtraction of doubles. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_sub): (JSC::JIT::emitSlow_op_sub): (JSC::JIT::emitSlowSub32InPlaceLeft): (JSC::JIT::emitBinaryDoubleOp): 2009-05-20 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Added support for inline division. * assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::divsd_rr): (JSC::X86Assembler::divsd_mr): * bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): * bytecode/Opcode.h: * bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::emitBinaryOp): * interpreter/Interpreter.cpp: (JSC::Interpreter::privateExecute): * jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emitBinaryDoubleOp): (JSC::JIT::emit_op_div): (JSC::JIT::emitSlow_op_div): 2009-05-20 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added support for inline addition of doubles. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_add): (JSC::JIT::emitSlow_op_add): (JSC::JIT::emitSlowAdd32InPlace): (JSC::JIT::emitBinaryDoubleOp): (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): 2009-05-20 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Factored inline double operations into a helper function, so that we can reuse this code for other math operations. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emitBinaryDoubleOp): (JSC::JIT::emit_op_mul): * jit/JITCall.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): 2009-05-20 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added support for inline multiplication of doubles. * assembler/X86Assembler.h: (JSC::X86Assembler::cvtsi2sd_mr): New function, useful for loading an int32 into a double register. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): Filled out these cases for double arithmetic. * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::addressFor): New function, useful for addressing a JSValue's full 64bits as a double. 2009-05-19 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement and enable optimized calls. * jit/JIT.cpp: (JSC::JIT::privateCompileCTIMachineTrampolines): Add ENABLE(JIT_OPTIMIZE_CALL) guards around the the optimize call only trampolines (virtualCallPreLink and virtualCallLink). Update the trampolines to account for the new JSValue representation. (JSC::JIT::unlinkCall): Use NULL instead of JSValue noValue. * jit/JITCall.cpp: (JSC::JIT::compileOpCall): Update to account for the new JSValue representation (JSC::JIT::compileOpCallSlowCase): Ditto. * jit/JITStubs.h: Remove incorrect !ENABLE(JIT_OPTIMIZE_CALL) guard. * wtf/Platform.h: Enable ENABLE_JIT_OPTIMIZE_CALL. 2009-05-19 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement and enable optimized property access. * assembler/AbstractMacroAssembler.h: Fix comment. * jit/JIT.cpp: (JSC::JIT::privateCompileCTIMachineTrampolines): Remove array length trampoline and implement the string length trampoline. * jit/JIT.h: Add new constants for patch offsets. * jit/JITInlineMethods.h: Remove FIELD_OFFSET which is now in StdLibExtras.h. * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_id): (JSC::JIT::emitSlow_op_get_by_id): (JSC::JIT::emit_op_put_by_id): (JSC::JIT::emitSlow_op_put_by_id): (JSC::JIT::compilePutDirectOffset): (JSC::JIT::compileGetDirectOffset): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::patchGetByIdSelf): (JSC::JIT::patchPutByIdReplace): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdSelfList): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain): * jit/JITStubCall.h: (JSC::JITStubCall::addArgument): Add version of addArgument that takes two registers for the tag and payload. * jit/JITStubs.cpp: (JSC::JITStubs::JITStubs): Remove array length trampoline pointer. (JSC::JITStubs::cti_op_get_by_id_self_fail): * jit/JITStubs.h: * runtime/JSObject.h: (JSC::JSObject::JSObject): Move m_inheritorID below the property storage to align it to a 16 byte boundary. * wtf/Platform.h: Enable ENABLE_JIT_OPTIMIZE_PROPERTY_ACCESS * wtf/StdLibExtras.h: Move FIELD_OFFSET here. 2009-05-17 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Remove unneeded ExecState parameter from the number JSValue constructors. * runtime/JSValue.h: (JSC::jsNumber): (JSC::jsNaN): (JSC::JSValue::JSValue): 2009-05-15 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implemented fast path for op_put_by_val when putting to arrays. * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_put_by_val): (JSC::JIT::emitSlow_op_put_by_val): 2009-05-15 Geoffrey Garen <ggaren@apple.com> (Mostly by Sam) Reviewed by Sam Weinig. Implemented fast path for op_get_by_val when accessing array. * jit/JIT.cpp: * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emitSlow_op_get_by_val): 2009-05-14 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed a failure in fast/js/math-transforms.html caused by failing to preserve -0 in multiplication. * assembler/X86Assembler.h: (JSC::X86Assembler::jz): * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): (JSC::JIT::emitMul32Constant): (JSC::JIT::emitMul32InPlace): Check both for overflow and for zero when doing multiplication. Use a slow case to get these right. 2009-05-14 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed a bug in the varargs calling convention. * jit/JITCall.cpp: (JSC::JIT::compileOpCallVarargs): Move the argument count into regT1, since that's where ctiVirtualCall expects it to be. 2009-05-14 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed a small bug in instanceof's looping code. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_instanceof): NULL means the object has no prototype, so only loop when *not* equal to NULL. 2009-05-14 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed a small bug in instanceof's result writing code. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_instanceof): Make sure to fill out the payload bits in all cases. 2009-05-14 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Removed an invalid assertion in cti_op_urshift which depended on a fast path for op_urshift which has never existed. * jit/JITStubs.cpp: (JSC::JITStubs::cti_op_urshift): 2009-05-14 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed loop_if_true, which had the same reversed test that jtrue had. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_true): 2009-05-14 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. In op_neq, we apparently want to check that one value does *not* equal another. Go figure. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_neq): 2009-05-14 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. The slow case of op_mod should call op_mod's jit stub, not op_mul. That would be dumb. * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_mod): 2009-05-14 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed problems when using 'arguments' due to a half-initialized register. * interpreter/CallFrame.h: (JSC::ExecState::setCalleeArguments): (JSC::ExecState::init): Require a full JSValue when setting up the 'arguments' virtual register, since this register is accessible from JIT code and bytecode, and needs to be a true JSValue. * interpreter/CallFrameClosure.h: (JSC::CallFrameClosure::resetCallFrame): ditto * interpreter/Interpreter.cpp: (JSC::Interpreter::privateExecute): ditto * interpreter/Register.h: Removed the constructor that allowed assignment of a JSArguments* to a register. That is not safe. See above. * jit/JITStubs.cpp: (JSC::JITStubs::cti_op_create_arguments): (JSC::JITStubs::cti_op_create_arguments_no_params): ditto 2009-05-14 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. We really want to go to the slow case in op_jfalse and op_jtrue if the value is *not* boolean. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jfalse): (JSC::JIT::emit_op_jtrue): 2009-05-14 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Flipped the condition when emitting a an op_loop_if_less or op_loop_if_lesseq if the first operand is a constant. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): 2009-05-14 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Added missing return in op_jnless and op_jnlesseq. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emit_op_jnlesseq): 2009-05-14 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Load constants into the the register file as a temporary measure to aid bring up. This allows us to use to treat constants like any other virtual register. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_enter): (JSC::JIT::emit_op_enter_with_activation): 2009-05-14 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Implemented op_strict_eq. Original patch by Snowy, by way of Sam and Gavin. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::set8): Added set8, since it's slightly faster than set32, and the new value representation usually doesn't need set32. * jit/JIT.cpp: * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::emitLoadTag): (JSC::JIT::emitLoadPayload): Added helper functions for dealing with constants. Eventually, we should write special cases for all constants, but these are helpful in the short term. * jit/JITOpcodes.cpp: (JSC::JIT::compileOpStrictEq): (JSC::JIT::emitSlow_op_stricteq): (JSC::JIT::emitSlow_op_nstricteq): teh opcodez. * runtime/JSValue.h: (JSC::JSValue::): (JSC::JSValue::isDouble): Added a LowestTag for clarity. 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Fixed some bugs in host function calls. testapi now passes! * jit/JIT.cpp: Changed some registers around to avoid overwriting edx:eax, which is how JSValues are now returned. Also changed the code that passes thisValue to pass the full 64bits of the value. Also added an #error compiler directive to other platform builds, since the JSValue return signature probably won't return in edx:eax on those platforms, and we'll have to investigate a solution. 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Removed parameters from functions that are intended never to use their parameters. * jit/JITPropertyAccess.cpp: (JSC::JIT::emitSlow_op_get_by_val): (JSC::JIT::emitSlow_op_put_by_val): 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Ported op_instance_of from TOT. It's basically the same, but some register stuff changed to memory stuff. * jit/JITInlineMethods.h: (JSC::JIT::emitPutJITStubArgFromVirtualRegister): (JSC::JIT::emitStore): Changed to use helper functions. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_instanceof): (JSC::JIT::emitSlow_op_instanceof): Ported from TOT. 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Gavin Barraclough. Added a comment to explain an exception-handling subtelty that we found hard to remember when reviewing my last patch. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_catch): 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Implemented try/catch. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_throw): Updated to use JITStackFrame abstraction. (JSC::JIT::emit_op_catch): Filled out. 2009-05-13 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implemented op_loop_if_true, op_jfalse, op_jtrue, op_jeq_null and op_jneq_null * jit/JITOpcodes.cpp: (JSC::JIT::emitSlow_op_instanceof): Moved from below to be next to its fast brother. (JSC::JIT::emit_op_loop_if_true): Similar to the old version in that it tries to do the integer case first and reduce the number of jumps you might need to take. (JSC::JIT::emitSlow_op_loop_if_true): (JSC::JIT::emit_op_jfalse): Very similar to op_loop_if_true, only the inverse and without a timeout check. (JSC::JIT::emitSlow_op_jfalse): (JSC::JIT::emit_op_jtrue): Very similar to op_loop_if_true except without the timeout check. (JSC::JIT::emitSlow_op_jtrue): (JSC::JIT::emit_op_jeq_null): Very similar to the implementation of op_eq, except it takes jumps instead of copying the condition to a dst. (JSC::JIT::emit_op_jneq_null): Ditto but for op_neq. 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Implemented op_call_varargs. * jit/JITCall.cpp: (JSC::JIT::compileOpCallVarargsSetupArgs): (JSC::JIT::compileOpCallVarargs): (JSC::JIT::emit_op_call): (JSC::JIT::emit_op_call_eval): (JSC::JIT::emit_op_load_varargs): (JSC::JIT::emit_op_call_varargs): (JSC::JIT::emit_op_construct): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jneq_ptr): 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Implemented op_call_eval. * jit/JITCall.cpp: (JSC::JIT::compileOpCallVarargsSetupArgs): (JSC::JIT::compileOpCall): * jit/JITStubCall.h: (JSC::CallEvalJITStub::CallEvalJITStub): 2009-05-13 Sam Weinig <sam@webkit.org> Reviewed by Gavin Barraclough. Implemented op_not. (Gavin did most of the work!) * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_not): (JSC::JIT::emitSlow_op_not): 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Implemented op_global_resolve. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): Added back accidentally removed early returns. (JSC::JIT::emit_op_resolve_global): * jit/JITStubs.cpp: (JSC::JITStubs::cti_op_resolve_global): Pretty similar to the old code, but we need two reads and a TimesEight step in order to account for the 64bit value size. * jit/JITStubs.h: (JSC::): Slightly tweaked this code to specialize for a JSGlobalObject*, to avoid having to pass an irrelevant tag pointer to the stub. 2009-05-13 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implemented op_to_jsnumber. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_to_jsnumber): (JSC::JIT::emitSlow_op_to_jsnumber): 2009-05-13 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implemented op_convert_this. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_convert_this): (JSC::JIT::emitSlow_op_convert_this): 2009-05-13 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Got basic JS function and constructor calls working. * jit/JIT.cpp: (JSC::JIT::privateCompileCTIMachineTrampolines): * jit/JIT.h: * jit/JITCall.cpp: (JSC::JIT::compileOpCallSetupArgs): (JSC::JIT::compileOpCallVarargsSetupArgs): (JSC::JIT::compileOpConstructSetupArgs): (JSC::JIT::emit_op_ret): (JSC::JIT::emit_op_construct_verify): (JSC::JIT::emitSlow_op_construct_verify): (JSC::JIT::emitSlow_op_call): (JSC::JIT::emitSlow_op_call_eval): (JSC::JIT::emitSlow_op_call_varargs): (JSC::JIT::emitSlow_op_construct): (JSC::JIT::compileOpCall): Filled out these cases, with call_eval #if'd out. * jit/JITInlineMethods.h: (JSC::JIT::emitPutJITStubArgFromVirtualRegister): (JSC::JIT::emitLoad): Restored some legacy "*CTIArg*" functions, since I wanted to avoid the complexity of revamping the API here while trying to bring it up. Eventually, we should re-remove all of these functions. (JSC::JIT::recordJumpTarget): Removed unnecessary macro cruft. You will not silence me, Sam Weinig! The world will know that you are a crufty, crufty, crufty programmer!!! * jit/JITOpcodes.cpp: * jit/JITStubs.cpp: (JSC::): * jit/JITStubs.h: Changed up some offsets in the JITStackFrame class, since and off-by-one error was causing stack misalignment. 2009-05-13 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement op_eq_null and op_neq_null. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::set8): (JSC::MacroAssemblerX86Common::setTest8): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_stricteq): (JSC::JIT::emitSlow_op_stricteq): (JSC::JIT::emit_op_nstricteq): (JSC::JIT::emitSlow_op_nstricteq): (JSC::JIT::emit_op_eq_null): (JSC::JIT::emit_op_neq_null): * jsc.cpp: 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement op_new_error. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_new_error): * jit/JITStubCall.h: (JSC::JITStubCall::addArgument): Add a version of addArgument that takes a constant JSValue. 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Remove now unused emitGetVariableObjectRegister and emitPutVariableObjectRegister. * jit/JIT.cpp: * jit/JIT.h: 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement op_to_primitive and op_next_pname. * jit/JITOpcodes.cpp: (JSC::JIT::emitSlow_op_construct_verify): (JSC::JIT::emit_op_to_primitive): (JSC::JIT::emitSlow_op_to_primitive): (JSC::JIT::emitSlow_op_loop_if_true): (JSC::JIT::emit_op_jtrue): (JSC::JIT::emit_op_next_pname): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Add op_get_global_var, op_put_global_var, emit_op_get_scoped_var, emit_op_put_scoped_var and op_unexpected_load. * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::tagFor): (JSC::JIT::payloadFor): (JSC::JIT::emitLoad): (JSC::JIT::emitStore): (JSC::JIT::emitLoadReturnValue): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_get_global_var): (JSC::JIT::emit_op_put_global_var): (JSC::JIT::emit_op_get_scoped_var): (JSC::JIT::emit_op_put_scoped_var): (JSC::JIT::emit_op_unexpected_load): 2009-05-12 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added overflow handling to op_sub. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_sub): (JSC::JIT::emitSlowSub32InPlaceLeft): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Remove a function call by folding op_get_by_id and op_put_by_id into their respective compile functions. * jit/JIT.h: * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_id): (JSC::JIT::emitSlow_op_get_by_id): (JSC::JIT::emit_op_put_by_id): (JSC::JIT::emitSlow_op_put_by_id): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Make JITStubCall work in 64bit by making the stack index step dependent on the size of void*. * jit/JITStubCall.h: (JSC::JITStubCall::JITStubCall): (JSC::JITStubCall::addArgument): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement simple version of property access opcodes which just call a stub functions. * jit/JITOpcodes.cpp: * jit/JITPropertyAccess.cpp: (JSC::JIT::emitSlow_op_put_by_id): (JSC::JIT::emitSlow_op_get_by_id): (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emitSlow_op_get_by_val): (JSC::JIT::emit_op_put_by_val): (JSC::JIT::emitSlow_op_put_by_val): (JSC::JIT::emit_op_put_by_index): (JSC::JIT::emit_op_put_getter): (JSC::JIT::emit_op_put_setter): (JSC::JIT::emit_op_del_by_id): (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compilePutByIdHotPath): * jit/JITStubCall.h: (JSC::JITStubCall::addArgument): * jsc.cpp: 2009-05-12 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added work-around for XCode debugging echo problem. * jsc.cpp: (runInteractive): 2009-05-12 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added overflow handling to op_add. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_add): (JSC::JIT::emitSlowAdd32InPlace): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Add slow cases for op_jnless or emit_op_jnlesseq. * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emitSlow_op_jnlesseq): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Add implementations for op_jnless, emit_op_jnlesseq, op_loop_if_less and op_loop_if_lesseq. No slow cases for op_jnless or emit_op_jnlesseq yet. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emitSlow_op_jnlesseq): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emitSlow_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): (JSC::JIT::emitSlow_op_loop_if_lesseq): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Turn the RECORD_JUMP_TARGET macro into an inline function. * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::recordJumpTarget): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jmp): (JSC::JIT::emit_op_jsr): (JSC::JIT::emit_op_jmp_scopes): 2009-05-12 Sam Weinig <sam@webkit.org> Add MacroAssemblerX86Common::set8 to fix the build. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::set8): 2009-05-12 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Added overflow recovery for pre_inc and pre_dec. Turned some short-circuit code into early returns, as is the WebKit style. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_post_inc): (JSC::JIT::emitSlow_op_post_inc): (JSC::JIT::emit_op_post_dec): (JSC::JIT::emitSlow_op_post_dec): (JSC::JIT::emitSlow_op_pre_inc): (JSC::JIT::emitSlow_op_pre_dec): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement op_jmp, op_loop, op_eq and op_neq. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_jmp): (JSC::JIT::emit_op_loop): (JSC::JIT::emit_op_eq): (JSC::JIT::emitSlow_op_eq): (JSC::JIT::emit_op_neq): (JSC::JIT::emitSlow_op_neq): (JSC::JIT::emit_op_enter): (JSC::JIT::emit_op_enter_with_activation): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement the slow cases for arithmetic opcodes. * jit/JITArithmetic.cpp: (JSC::JIT::emitSlow_op_lshift): (JSC::JIT::emitSlow_op_rshift): (JSC::JIT::emitSlow_op_bitand): (JSC::JIT::emitSlow_op_bitor): (JSC::JIT::emitSlow_op_bitxor): (JSC::JIT::emitSlow_op_bitnot): (JSC::JIT::emitSlow_op_sub): (JSC::JIT::emitSlow_op_mul): (JSC::JIT::emitSlow_op_mod): (JSC::JIT::emit_op_mod): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Implement op_bitnot. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::not32): * assembler/X86Assembler.h: (JSC::X86Assembler::notl_m): * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_bitnot): 2009-05-12 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Add arithmetic opcode implementations from the old nitro-extreme branch. * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_jnless): (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emitSlow_op_jnlesseq): (JSC::JIT::emit_op_lshift): (JSC::JIT::emitSlow_op_lshift): (JSC::JIT::emit_op_rshift): (JSC::JIT::emitSlow_op_rshift): (JSC::JIT::emit_op_bitand): (JSC::JIT::emitBitAnd32Constant): (JSC::JIT::emitBitAnd32InPlace): (JSC::JIT::emit_op_bitor): (JSC::JIT::emitSlow_op_bitor): (JSC::JIT::emitBitOr32Constant): (JSC::JIT::emitBitOr32InPlace): (JSC::JIT::emit_op_bitxor): (JSC::JIT::emitSlow_op_bitxor): (JSC::JIT::emitBitXor32Constant): (JSC::JIT::emitBitXor32InPlace): (JSC::JIT::emit_op_bitnot): (JSC::JIT::emitSlow_op_bitnot): (JSC::JIT::emit_op_post_inc): (JSC::JIT::emitSlow_op_post_inc): (JSC::JIT::emit_op_post_dec): (JSC::JIT::emitSlow_op_post_dec): (JSC::JIT::emit_op_pre_inc): (JSC::JIT::emitSlow_op_pre_inc): (JSC::JIT::emit_op_pre_dec): (JSC::JIT::emitSlow_op_pre_dec): (JSC::JIT::emit_op_add): (JSC::JIT::emitAdd32Constant): (JSC::JIT::emitAdd32InPlace): (JSC::JIT::emitSlow_op_add): (JSC::JIT::emit_op_sub): (JSC::JIT::emitSlow_op_sub): (JSC::JIT::emitSub32ConstantLeft): (JSC::JIT::emitSub32ConstantRight): (JSC::JIT::emitSub32InPlaceLeft): (JSC::JIT::emitSub32InPlaceRight): (JSC::JIT::emit_op_mul): (JSC::JIT::emitSlow_op_mul): (JSC::JIT::emitMul32Constant): (JSC::JIT::emitMul32InPlace): (JSC::JIT::emit_op_mod): (JSC::JIT::emitSlow_op_mod): * jit/JITOpcodes.cpp: 2009-05-12 Geoffrey Garen <ggaren@apple.com> Removed JIT_OPTIMIZE_ARITHMETIC setting, since it was all about 32bit value representations. Added JSAPIValueWrapper to the repository. * jit/JIT.h: * jit/JITArithmetic.cpp: * runtime/JSAPIValueWrapper.cpp: Added. (JSC::JSAPIValueWrapper::toPrimitive): (JSC::JSAPIValueWrapper::getPrimitiveNumber): (JSC::JSAPIValueWrapper::toBoolean): (JSC::JSAPIValueWrapper::toNumber): (JSC::JSAPIValueWrapper::toString): (JSC::JSAPIValueWrapper::toObject): * runtime/JSAPIValueWrapper.h: Added. (JSC::JSAPIValueWrapper::value): (JSC::JSAPIValueWrapper::isAPIValueWrapper): (JSC::JSAPIValueWrapper::JSAPIValueWrapper): (JSC::jsAPIValueWrapper): * wtf/Platform.h: 2009-05-12 Geoffrey Garen <ggaren@apple.com> Turned on the JIT and got it building and running the most trivial of programs. All configurable optimizations are turned off, and a few opcodes are ad hoc #if'd out. So far, I've only merged op_mov and op_end, but some stub-reliant opcodes work as-is from TOT. * bytecode/CodeBlock.cpp: (JSC::CodeBlock::~CodeBlock): * bytecode/CodeBlock.h: * jit/JIT.cpp: (JSC::JIT::compileOpStrictEq): * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_lshift): (JSC::JIT::emitSlow_op_lshift): (JSC::JIT::emit_op_rshift): (JSC::JIT::emitSlow_op_rshift): (JSC::JIT::emit_op_jnless): (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emit_op_jnlesseq): (JSC::JIT::emitSlow_op_jnlesseq): (JSC::JIT::emit_op_bitand): (JSC::JIT::emitSlow_op_bitand): (JSC::JIT::emit_op_post_inc): (JSC::JIT::emitSlow_op_post_inc): (JSC::JIT::emit_op_post_dec): (JSC::JIT::emitSlow_op_post_dec): (JSC::JIT::emit_op_pre_inc): (JSC::JIT::emitSlow_op_pre_inc): (JSC::JIT::emit_op_pre_dec): (JSC::JIT::emitSlow_op_pre_dec): (JSC::JIT::emit_op_mod): (JSC::JIT::emitSlow_op_mod): (JSC::JIT::emit_op_add): (JSC::JIT::emit_op_mul): (JSC::JIT::emit_op_sub): (JSC::JIT::compileBinaryArithOpSlowCase): (JSC::JIT::emitSlow_op_add): (JSC::JIT::emitSlow_op_mul): * jit/JITCall.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): (JSC::JIT::compileOpConstructSetupArgs): (JSC::JIT::compileOpCallVarargs): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpCallSlowCase): * jit/JITInlineMethods.h: (JSC::JIT::getConstantOperandImmediateInt): (JSC::JIT::isOperandConstantImmediateInt): (JSC::JIT::emitInitRegister): (JSC::JIT::addSlowCase): (JSC::JIT::addJump): (JSC::JIT::emitJumpSlowToHot): (JSC::JIT::tagFor): (JSC::JIT::payloadFor): (JSC::JIT::emitLoad): (JSC::JIT::emitLoadReturnValue): (JSC::JIT::emitStore): (JSC::JIT::emitStoreReturnValue): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_mov): (JSC::JIT::emit_op_end): (JSC::JIT::emit_op_jmp): (JSC::JIT::emit_op_loop): (JSC::JIT::emit_op_loop_if_less): (JSC::JIT::emit_op_loop_if_lesseq): (JSC::JIT::emit_op_instanceof): (JSC::JIT::emit_op_get_global_var): (JSC::JIT::emit_op_put_global_var): (JSC::JIT::emit_op_get_scoped_var): (JSC::JIT::emit_op_put_scoped_var): (JSC::JIT::emit_op_tear_off_activation): (JSC::JIT::emit_op_ret): (JSC::JIT::emit_op_construct_verify): (JSC::JIT::emit_op_to_primitive): (JSC::JIT::emit_op_loop_if_true): (JSC::JIT::emit_op_resolve_global): (JSC::JIT::emit_op_not): (JSC::JIT::emit_op_jfalse): (JSC::JIT::emit_op_jeq_null): (JSC::JIT::emit_op_jneq_null): (JSC::JIT::emit_op_jneq_ptr): (JSC::JIT::emit_op_unexpected_load): (JSC::JIT::emit_op_eq): (JSC::JIT::emit_op_bitnot): (JSC::JIT::emit_op_jtrue): (JSC::JIT::emit_op_neq): (JSC::JIT::emit_op_bitxor): (JSC::JIT::emit_op_bitor): (JSC::JIT::emit_op_throw): (JSC::JIT::emit_op_next_pname): (JSC::JIT::emit_op_push_scope): (JSC::JIT::emit_op_to_jsnumber): (JSC::JIT::emit_op_push_new_scope): (JSC::JIT::emit_op_catch): (JSC::JIT::emit_op_switch_imm): (JSC::JIT::emit_op_switch_char): (JSC::JIT::emit_op_switch_string): (JSC::JIT::emit_op_new_error): (JSC::JIT::emit_op_eq_null): (JSC::JIT::emit_op_neq_null): (JSC::JIT::emit_op_convert_this): (JSC::JIT::emit_op_profile_will_call): (JSC::JIT::emit_op_profile_did_call): (JSC::JIT::emitSlow_op_construct_verify): (JSC::JIT::emitSlow_op_get_by_val): (JSC::JIT::emitSlow_op_loop_if_less): (JSC::JIT::emitSlow_op_loop_if_lesseq): (JSC::JIT::emitSlow_op_put_by_val): (JSC::JIT::emitSlow_op_not): (JSC::JIT::emitSlow_op_instanceof): * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emit_op_put_by_val): (JSC::JIT::emit_op_put_by_index): (JSC::JIT::emit_op_put_getter): (JSC::JIT::emit_op_put_setter): (JSC::JIT::emit_op_del_by_id): (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compilePutByIdHotPath): * jit/JITStubCall.h: (JSC::JITStubCall::JITStubCall): (JSC::JITStubCall::addArgument): (JSC::JITStubCall::call): (JSC::JITStubCall::): (JSC::CallEvalJITStub::CallEvalJITStub): * jit/JITStubs.cpp: (JSC::): (JSC::JITStubs::cti_op_add): (JSC::JITStubs::cti_op_pre_inc): (JSC::JITStubs::cti_op_mul): (JSC::JITStubs::cti_op_get_by_val): (JSC::JITStubs::cti_op_get_by_val_string): (JSC::JITStubs::cti_op_get_by_val_byte_array): (JSC::JITStubs::cti_op_sub): (JSC::JITStubs::cti_op_put_by_val): (JSC::JITStubs::cti_op_put_by_val_array): (JSC::JITStubs::cti_op_put_by_val_byte_array): (JSC::JITStubs::cti_op_negate): (JSC::JITStubs::cti_op_div): (JSC::JITStubs::cti_op_pre_dec): (JSC::JITStubs::cti_op_post_inc): (JSC::JITStubs::cti_op_eq): (JSC::JITStubs::cti_op_lshift): (JSC::JITStubs::cti_op_bitand): (JSC::JITStubs::cti_op_rshift): (JSC::JITStubs::cti_op_bitnot): (JSC::JITStubs::cti_op_mod): (JSC::JITStubs::cti_op_neq): (JSC::JITStubs::cti_op_post_dec): (JSC::JITStubs::cti_op_urshift): (JSC::JITStubs::cti_op_bitxor): (JSC::JITStubs::cti_op_bitor): (JSC::JITStubs::cti_op_switch_imm): * jit/JITStubs.h: * runtime/JSArray.cpp: (JSC::JSArray::JSArray): * runtime/JSFunction.cpp: (JSC::JSFunction::~JSFunction): * runtime/JSValue.h: (JSC::JSValue::payload): * wtf/Platform.h: 2009-05-07 Sam Weinig <sam@webkit.org> Reviewed by Geoffrey Garen. Add some new MacroAssembler and assembler functions that will be needed shortly. * assembler/MacroAssemblerX86Common.h: (JSC::MacroAssemblerX86Common::add32): (JSC::MacroAssemblerX86Common::and32): (JSC::MacroAssemblerX86Common::mul32): (JSC::MacroAssemblerX86Common::neg32): (JSC::MacroAssemblerX86Common::or32): (JSC::MacroAssemblerX86Common::sub32): (JSC::MacroAssemblerX86Common::xor32): (JSC::MacroAssemblerX86Common::branchAdd32): (JSC::MacroAssemblerX86Common::branchMul32): (JSC::MacroAssemblerX86Common::branchSub32): * assembler/X86Assembler.h: (JSC::X86Assembler::): (JSC::X86Assembler::addl_rm): (JSC::X86Assembler::andl_mr): (JSC::X86Assembler::andl_rm): (JSC::X86Assembler::andl_im): (JSC::X86Assembler::negl_r): (JSC::X86Assembler::notl_r): (JSC::X86Assembler::orl_rm): (JSC::X86Assembler::orl_im): (JSC::X86Assembler::subl_rm): (JSC::X86Assembler::xorl_mr): (JSC::X86Assembler::xorl_rm): (JSC::X86Assembler::xorl_im): (JSC::X86Assembler::imull_mr): 2009-05-11 Sam Weinig <sam@webkit.org> Reviewed by Cameron Zwarich. Remove the NumberHeap. * JavaScriptCore.exp: * runtime/Collector.cpp: (JSC::Heap::Heap): (JSC::Heap::destroy): (JSC::Heap::recordExtraCost): (JSC::Heap::heapAllocate): (JSC::Heap::markConservatively): (JSC::Heap::sweep): (JSC::Heap::collect): (JSC::Heap::objectCount): (JSC::Heap::statistics): (JSC::typeName): (JSC::Heap::isBusy): * runtime/Collector.h: (JSC::Heap::globalData): * runtime/JSCell.h: 2009-05-11 Geoffrey Garen <ggaren@apple.com> Reviewed by Sam Weinig. Land initial commit of new number representation for 32 bit platforms, with JIT disabled. * API/APICast.h: (toJS): (toRef): * API/JSCallbackObjectFunctions.h: (JSC::::hasInstance): (JSC::::toNumber): (JSC::::toString): * API/tests/testapi.c: (EvilExceptionObject_convertToType): * AllInOneFile.cpp: * JavaScriptCore.exp: * JavaScriptCore.xcodeproj/project.pbxproj: * bytecode/CodeBlock.cpp: (JSC::valueToSourceString): * bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::emitLoad): (JSC::BytecodeGenerator::emitUnexpectedLoad): (JSC::keyForImmediateSwitch): * bytecompiler/BytecodeGenerator.h: * interpreter/Interpreter.cpp: (JSC::Interpreter::dumpRegisters): (JSC::Interpreter::privateExecute): * parser/Nodes.cpp: (JSC::ArrayNode::emitBytecode): (JSC::processClauseList): * runtime/ArgList.h: * runtime/Collector.h: (JSC::sizeof): * runtime/DateMath.cpp: * runtime/ExceptionHelpers.h: * runtime/InitializeThreading.cpp: * runtime/JSArray.cpp: (JSC::JSArray::JSArray): * runtime/JSCell.cpp: * runtime/JSCell.h: (JSC::JSCell::isAPIValueWrapper): (JSC::JSValue::isString): (JSC::JSValue::isGetterSetter): (JSC::JSValue::isObject): (JSC::JSValue::getString): (JSC::JSValue::getObject): (JSC::JSValue::getCallData): (JSC::JSValue::getConstructData): (JSC::JSValue::getUInt32): (JSC::JSValue::marked): (JSC::JSValue::toPrimitive): (JSC::JSValue::getPrimitiveNumber): (JSC::JSValue::toBoolean): (JSC::JSValue::toNumber): (JSC::JSValue::toString): (JSC::JSValue::needsThisConversion): (JSC::JSValue::toThisString): (JSC::JSValue::getJSNumber): (JSC::JSValue::toObject): (JSC::JSValue::toThisObject): * runtime/JSGlobalData.cpp: (JSC::JSGlobalData::JSGlobalData): * runtime/JSGlobalData.h: * runtime/JSGlobalObject.h: (JSC::Structure::prototypeForLookup): * runtime/JSGlobalObjectFunctions.cpp: (JSC::globalFuncParseInt): * runtime/JSImmediate.h: * runtime/JSNumberCell.cpp: Removed. * runtime/JSNumberCell.h: Removed. * runtime/JSObject.h: (JSC::JSValue::get): (JSC::JSValue::put): * runtime/JSString.h: (JSC::JSValue::toThisJSString): * runtime/JSValue.cpp: (JSC::JSValue::toInteger): (JSC::JSValue::toIntegerPreserveNaN): (JSC::JSValue::toObjectSlowCase): (JSC::JSValue::toThisObjectSlowCase): (JSC::JSValue::synthesizeObject): (JSC::JSValue::synthesizePrototype): (JSC::JSValue::description): (JSC::nonInlineNaN): * runtime/JSValue.h: (JSC::JSValue::): (JSC::EncodedJSValueHashTraits::emptyValue): (JSC::jsNaN): (JSC::operator==): (JSC::operator!=): (JSC::toInt32): (JSC::toUInt32): (JSC::JSValue::encode): (JSC::JSValue::decode): (JSC::JSValue::JSValue): (JSC::JSValue::operator bool): (JSC::JSValue::operator==): (JSC::JSValue::operator!=): (JSC::JSValue::isUndefined): (JSC::JSValue::isNull): (JSC::JSValue::isUndefinedOrNull): (JSC::JSValue::isCell): (JSC::JSValue::isInt32): (JSC::JSValue::isUInt32): (JSC::JSValue::isDouble): (JSC::JSValue::isTrue): (JSC::JSValue::isFalse): (JSC::JSValue::tag): (JSC::JSValue::asInt32): (JSC::JSValue::asUInt32): (JSC::JSValue::asDouble): (JSC::JSValue::asCell): (JSC::JSValue::isNumber): (JSC::JSValue::isBoolean): (JSC::JSValue::getBoolean): (JSC::JSValue::uncheckedGetNumber): (JSC::JSValue::toJSNumber): (JSC::JSValue::getNumber): (JSC::JSValue::toInt32): (JSC::JSValue::toUInt32): * runtime/Operations.h: (JSC::JSValue::equal): (JSC::JSValue::equalSlowCaseInline): (JSC::JSValue::strictEqual): (JSC::JSValue::strictEqualSlowCaseInline): (JSC::jsLess): (JSC::jsLessEq): (JSC::jsAdd): * runtime/PropertySlot.h: * runtime/StringPrototype.cpp: (JSC::stringProtoFuncCharAt): (JSC::stringProtoFuncCharCodeAt): (JSC::stringProtoFuncIndexOf): * wtf/Platform.h: === Start merge of nitro-extreme branch 2009-07-30 === 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46438. 2009-07-27 Gavin Barraclough <barraclough@apple.com> Rubber stamped by Oliver Hunt. Fix tyop in JIT, renamed preverveReturnAddressAfterCall -> preserveReturnAddressAfterCall. * jit/JIT.cpp: (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines): * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::preserveReturnAddressAfterCall): * jit/JITPropertyAccess.cpp: (JSC::JIT::privateCompilePutByIdTransition): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46347. 2009-07-24 Csaba Osztrogonac <oszi@inf.u-szeged.hu> Reviewed by Darin Adler and Adam Barth. Build fix for x86 platforms. https://bugs.webkit.org/show_bug.cgi?id=27602 * jit/JIT.cpp: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46247. 2009-07-22 Gavin Barraclough <barraclough@apple.com> Reviewed by Sam Weinig. With ENABLE(ASSEMBLER_WX_EXCLUSIVE), only change permissions once per repatch event. ( https://bugs.webkit.org/show_bug.cgi?id=27564 ) Currently we change permissions forwards and backwards for each instruction modified, instead we should only change permissions once per complete repatching event. 2.5% progression running with ENABLE(ASSEMBLER_WX_EXCLUSIVE) enabled, which recoups 1/3 of the penalty of running with this mode enabled. * assembler/ARMAssembler.cpp: (JSC::ARMAssembler::linkBranch): - Replace usage of MakeWritable with cacheFlush. * assembler/ARMAssembler.h: (JSC::ARMAssembler::patchPointerInternal): (JSC::ARMAssembler::repatchLoadPtrToLEA): - Replace usage of MakeWritable with cacheFlush. * assembler/ARMv7Assembler.h: (JSC::ARMv7Assembler::relinkJump): (JSC::ARMv7Assembler::relinkCall): (JSC::ARMv7Assembler::repatchInt32): (JSC::ARMv7Assembler::repatchPointer): (JSC::ARMv7Assembler::repatchLoadPtrToLEA): (JSC::ARMv7Assembler::setInt32): - Replace usage of MakeWritable with cacheFlush. * assembler/LinkBuffer.h: (JSC::LinkBuffer::performFinalization): - Make explicit call to cacheFlush. * assembler/MacroAssemblerCodeRef.h: (JSC::MacroAssemblerCodeRef::MacroAssemblerCodeRef): - Make size always available. * assembler/RepatchBuffer.h: (JSC::RepatchBuffer::RepatchBuffer): (JSC::RepatchBuffer::~RepatchBuffer): - Add calls to MakeWritable & makeExecutable. * assembler/X86Assembler.h: (JSC::X86Assembler::relinkJump): (JSC::X86Assembler::relinkCall): (JSC::X86Assembler::repatchInt32): (JSC::X86Assembler::repatchPointer): (JSC::X86Assembler::repatchLoadPtrToLEA): - Remove usage of MakeWritable. * bytecode/CodeBlock.h: (JSC::CodeBlock::getJITCode): - Provide access to CodeBlock's JITCode. * jit/ExecutableAllocator.h: (JSC::ExecutableAllocator::makeExecutable): (JSC::ExecutableAllocator::cacheFlush): - Remove MakeWritable, make cacheFlush public. * jit/JIT.cpp: (JSC::ctiPatchNearCallByReturnAddress): (JSC::ctiPatchCallByReturnAddress): (JSC::JIT::privateCompile): (JSC::JIT::unlinkCall): (JSC::JIT::linkCall): - Add CodeBlock argument to RepatchBuffer. * jit/JIT.h: - Pass CodeBlock argument for use by RepatchBuffer. * jit/JITCode.h: (JSC::JITCode::start): (JSC::JITCode::size): - Provide access to code start & size. * jit/JITPropertyAccess.cpp: (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::patchGetByIdSelf): (JSC::JIT::patchMethodCallProto): (JSC::JIT::patchPutByIdReplace): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdSelfList): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain): - Add CodeBlock argument to RepatchBuffer. * jit/JITStubs.cpp: (JSC::JITThunks::tryCachePutByID): (JSC::JITThunks::tryCacheGetByID): (JSC::JITStubs::DEFINE_STUB_FUNCTION): - Pass CodeBlock argument for use by RepatchBuffer. 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46210. 2009-07-21 Zoltan Herczeg <zherczeg@inf.u-szeged.hu> Reviewed by Gavin Barraclough. Cache not only the structure of the method, but the structure of its prototype as well. https://bugs.webkit.org/show_bug.cgi?id=27077 * bytecode/CodeBlock.cpp: (JSC::CodeBlock::~CodeBlock): * bytecode/CodeBlock.h: (JSC::MethodCallLinkInfo::MethodCallLinkInfo): * jit/JITPropertyAccess.cpp: (JSC::JIT::patchMethodCallProto): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46209. 2009-07-21 Gavin Barraclough <barraclough@apple.com> Reviewed by Sam Weinig. Move call linking / repatching down from AbstractMacroAssembler into MacroAssemblerARCH classes. ( https://bugs.webkit.org/show_bug.cgi?id=27527 ) This allows the implementation to be defined per architecture. Specifically this addresses the fact that x86-64 MacroAssembler implements far calls as a load to register, followed by a call to register. Patching the call actually requires the pointer load to be patched, rather than the call to be patched. This is implementation detail specific to MacroAssemblerX86_64, and as such is best handled there. * assembler/AbstractMacroAssembler.h: * assembler/MacroAssemblerARM.h: (JSC::MacroAssemblerARM::linkCall): (JSC::MacroAssemblerARM::repatchCall): * assembler/MacroAssemblerARMv7.h: (JSC::MacroAssemblerARMv7::linkCall): (JSC::MacroAssemblerARMv7::repatchCall): * assembler/MacroAssemblerX86.h: (JSC::MacroAssemblerX86::linkCall): (JSC::MacroAssemblerX86::repatchCall): * assembler/MacroAssemblerX86_64.h: (JSC::MacroAssemblerX86_64::linkCall): (JSC::MacroAssemblerX86_64::repatchCall): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46202. 2009-07-21 Gavin Barraclough <barraclough@apple.com> Reviewed by Oliver Hunt. Move LinkBuffer/RepatchBuffer out of AbstractMacroAssembler. ( https://bugs.webkit.org/show_bug.cgi?id=27485 ) This change is the first step in a process to move code that should be in the architecture-specific MacroAssembler classes up out of Assmbler and AbstractMacroAssembler. * JavaScriptCore.xcodeproj/project.pbxproj: - added new files * assembler/ARMAssembler.h: (JSC::ARMAssembler::linkPointer): - rename patchPointer to bring it in line with the current link/repatch naming scheme * assembler/ARMv7Assembler.h: (JSC::ARMv7Assembler::linkCall): (JSC::ARMv7Assembler::linkPointer): (JSC::ARMv7Assembler::relinkCall): (JSC::ARMv7Assembler::repatchInt32): (JSC::ARMv7Assembler::repatchPointer): (JSC::ARMv7Assembler::setInt32): (JSC::ARMv7Assembler::setPointer): - rename patchPointer to bring it in line with the current link/repatch naming scheme * assembler/AbstractMacroAssembler.h: (JSC::AbstractMacroAssembler::linkJump): (JSC::AbstractMacroAssembler::linkCall): (JSC::AbstractMacroAssembler::linkPointer): (JSC::AbstractMacroAssembler::getLinkerAddress): (JSC::AbstractMacroAssembler::getLinkerCallReturnOffset): (JSC::AbstractMacroAssembler::repatchJump): (JSC::AbstractMacroAssembler::repatchCall): (JSC::AbstractMacroAssembler::repatchNearCall): (JSC::AbstractMacroAssembler::repatchInt32): (JSC::AbstractMacroAssembler::repatchPointer): (JSC::AbstractMacroAssembler::repatchLoadPtrToLEA): - remove the LinkBuffer/RepatchBuffer classes, but leave a set of (private, friended) methods to interface to the Assembler * assembler/LinkBuffer.h: Added. (JSC::LinkBuffer::LinkBuffer): (JSC::LinkBuffer::~LinkBuffer): (JSC::LinkBuffer::link): (JSC::LinkBuffer::patch): (JSC::LinkBuffer::locationOf): (JSC::LinkBuffer::locationOfNearCall): (JSC::LinkBuffer::returnAddressOffset): (JSC::LinkBuffer::finalizeCode): (JSC::LinkBuffer::finalizeCodeAddendum): (JSC::LinkBuffer::code): (JSC::LinkBuffer::performFinalization): - new file containing the LinkBuffer class, previously a member of AbstractMacroAssembler * assembler/RepatchBuffer.h: Added. (JSC::RepatchBuffer::RepatchBuffer): (JSC::RepatchBuffer::relink): (JSC::RepatchBuffer::repatch): (JSC::RepatchBuffer::repatchLoadPtrToLEA): (JSC::RepatchBuffer::relinkCallerToTrampoline): (JSC::RepatchBuffer::relinkCallerToFunction): (JSC::RepatchBuffer::relinkNearCallerToTrampoline): - new file containing the RepatchBuffer class, previously a member of AbstractMacroAssembler * assembler/X86Assembler.h: (JSC::X86Assembler::linkJump): (JSC::X86Assembler::linkCall): (JSC::X86Assembler::linkPointerForCall): (JSC::X86Assembler::linkPointer): (JSC::X86Assembler::relinkJump): (JSC::X86Assembler::relinkCall): (JSC::X86Assembler::repatchInt32): (JSC::X86Assembler::repatchPointer): (JSC::X86Assembler::setPointer): (JSC::X86Assembler::setInt32): (JSC::X86Assembler::setRel32): - rename patchPointer to bring it in line with the current link/repatch naming scheme * jit/JIT.cpp: (JSC::ctiPatchNearCallByReturnAddress): (JSC::ctiPatchCallByReturnAddress): - include new headers - remove MacroAssembler:: specification from RepatchBuffer usage * jit/JITPropertyAccess.cpp: * yarr/RegexJIT.cpp: - include new headers 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46187. 2009-07-21 Robert Agoston <Agoston.Robert@stud.u-szeged.hu> Reviewed by David Levin. Fixed #undef typo. https://bugs.webkit.org/show_bug.cgi?id=27506 * bytecode/Opcode.h: 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r46057. 2009-07-17 Gabor Loki <loki@inf.u-szeged.hu> Reviewed by Gavin Barraclough. Extend AssemblerBuffer with constant pool handling mechanism. https://bugs.webkit.org/show_bug.cgi?id=24986 Add a platform independed constant pool framework. This pool can store 32 or 64 bits values which is enough to hold any integer, pointer or double constant. * assembler/AssemblerBuffer.h: (JSC::AssemblerBuffer::putIntUnchecked): (JSC::AssemblerBuffer::putInt64Unchecked): (JSC::AssemblerBuffer::append): (JSC::AssemblerBuffer::grow): * assembler/AssemblerBufferWithConstantPool.h: Added. (JSC::): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r45933. 2009-07-15 Darin Adler <darin@apple.com> Fix a build for a particular Apple configuration. * wtf/FastAllocBase.h: Change include to use "" style for including another wtf header. This is the style we use for including other public headers in the same directory. 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r45918. 2009-07-15 Yong Li <yong.li@torchmobile.com> Reviewed by George Staikos. https://bugs.webkit.org/show_bug.cgi?id=27020 msToGregorianDateTime should set utcOffset to 0 when outputIsUTC is false * wtf/DateMath.cpp: (WTF::gregorianDateTimeToMS): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r45904. 2009-07-15 Oliver Hunt <oliver@apple.com> Reviewed by Simon Hausmann. REGRESSION: fast/js/postfix-syntax.html fails with interpreter https://bugs.webkit.org/show_bug.cgi?id=27294 When postfix operators operating on locals assign to the same local the order of operations has to be to store the incremented value, then store the unmodified number. Rather than implementing this subtle semantic in the interpreter I've just made the logic explicit in the bytecode generator, so x=x++ effectively becomes x=ToNumber(x) (for a local var x). * parser/Nodes.cpp: (JSC::emitPostIncOrDec): 2009-10-08 Mark Rowe <mrowe@apple.com> Merge r45903. 2009-07-15 Oliver Hunt <oliver@apple.com> Reviewed by Simon Hausmann. REGRESSION(43559): fast/js/kde/arguments-scope.html fails with interpreter https://bugs.webkit.org/show_bug.cgi?id=27259 The interpreter was incorrectly basing its need to create the arguments object based on the presence of the callframe's argument reference rather than the local arguments reference. Based on this it then overrode the local variable reference. * interpreter/Interpreter.cpp: (JSC::Interpreter::privateExecute): 2009-07-15 Steve Falkenburg <sfalken@apple.com> Merge r45949. 2009-07-15 Steve Falkenburg <sfalken@apple.com> Windows Build fix. Visual Studio reset our intermediate directory on us. This sets it back. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: * JavaScriptCore.vcproj/testapi/testapi.vcproj: 2009-07-15 Steve Falkenburg <sfalken@apple.com> Merge r45892. 2009-07-14 Steve Falkenburg <sfalken@apple.com> Reorganize JavaScriptCore headers into: API: include/JavaScriptCore/ Private: include/private/JavaScriptCore/ Reviewed by Darin Adler. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreCommon.vsprops: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreGenerated.make: * JavaScriptCore.vcproj/testapi/testapi.vcproj: * JavaScriptCore.vcproj/testapi/testapiCommon.vsprops: 2009-07-12 Mark Rowe <mrowe@apple.com> Merge r45736. 2009-07-10 Mark Rowe <mrowe@apple.com> Second part of the "make Windows happier" dance. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-07-12 Mark Rowe <mrowe@apple.com> Merge r45735. 2009-07-10 Mark Rowe <mrowe@apple.com> Try and make the Windows build happy. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-07-12 Mark Rowe <mrowe@apple.com> Merge r45733. 2009-07-10 Kevin McCullough <kmccullough@apple.com> Reviewed by Geoffrey Garen. * debugger/Debugger.h: Made this function virtual for use in WebCore's WebInspector. 2009-07-11 Mark Rowe <mrowe@apple.com> <rdar://problem/7047403> Disable channel messaging * Configurations/FeatureDefines.xcconfig: 2009-07-09 Maciej Stachowiak <mjs@apple.com> Not reviewed, build fix. Windows build fix for the last change. * wtf/dtoa.cpp: Forgot to include Vector.h 2009-07-09 Maciej Stachowiak <mjs@apple.com> Reviewed by Darin Adler. REGRESSION: crash in edge cases of floating point parsing. https://bugs.webkit.org/show_bug.cgi?id=27110 <rdar://problem/7044458> Tests: fast/css/number-parsing-crash.html fast/css/number-parsing-crash.html fast/js/number-parsing-crash.html * wtf/dtoa.cpp: (WTF::BigInt::BigInt): Converted this to more a proper class, using a Vector with inline capacity (WTF::lshift): Rearranged logic somewhat nontrivially to deal with the new way of sizing BigInts. Added an assertion to verify that invariants are maintained. All other functions are adapted fairly mechanically to the above changes. (WTF::BigInt::clear): (WTF::BigInt::size): (WTF::BigInt::resize): (WTF::BigInt::words): (WTF::BigInt::append): (WTF::multadd): (WTF::s2b): (WTF::i2b): (WTF::mult): (WTF::cmp): (WTF::diff): (WTF::b2d): (WTF::d2b): (WTF::ratio): (WTF::strtod): (WTF::quorem): (WTF::dtoa): 2009-07-09 Drew Wilson <atwilson@google.com> Reviewed by Alexey Proskuryakov. Turned on CHANNEL_MESSAGING by default because the MessageChannel API can now be implemented for Web Workers and is reasonably stable. * Configurations/FeatureDefines.xcconfig: 2009-07-09 Oliver Hunt <oliver@apple.com> Reviewed by NOBODY (Build fix). * interpreter/Interpreter.cpp: (JSC::Interpreter::privateExecute): 2009-07-09 Oliver Hunt <oliver@apple.com> Reviewed by Darin Adler. Bug 27016 - Interpreter crashes due to invalid array indexes <https://bugs.webkit.org/show_bug.cgi?id=27016> Unsigned vs signed conversions results in incorrect behaviour in 64bit interpreter builds. * interpreter/Interpreter.cpp: (JSC::Interpreter::privateExecute): 2009-07-09 Dimitri Glazkov <dglazkov@chromium.org> Reviewed by Darin Fisher. [Chromium] Upstream JavaScriptCore.gypi, the project file for Chromium build. https://bugs.webkit.org/show_bug.cgi?id=27135 * JavaScriptCore.gypi: Added. 2009-07-09 Joe Mason <joe.mason@torchmobile.com> Reviewed by George Staikos. Authors: Yong Li <yong.li@torchmobile.com>, Joe Mason <joe.mason@torchmobile.com> https://bugs.webkit.org/show_bug.cgi?id=27031 Add an override for deleteOwnedPtr(HDC) on Windows * wtf/OwnPtrCommon.h: * wtf/OwnPtrWin.cpp: (WTF::deleteOwnedPtr): 2009-07-09 Laszlo Gombos <laszlo.1.gombos@nokia.com> Reviewed by Darin Adler. Guard singal.h dependency with HAVE(SIGNAL_H) to enable building jsc on SYMBIAN. https://bugs.webkit.org/show_bug.cgi?id=27026 Based on Norbert Leser's work. * jsc.cpp: (printUsageStatement): (parseArguments): * wtf/Platform.h: 2009-07-07 Gavin Barraclough <barraclough@apple.com> Reviewed by Sam Weinig. Stop loading constants into the register file. Instead, use high register values (highest bit bar the sign bit set) to indicate constants in the instruction stream, and when we encounter such a value load it directly from the CodeBlock. Since constants are no longer copied into the register file, this patch renders the 'unexpected constant' mechanism redundant, and removes it. 2% improvement, thanks to Sam Weinig. * bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): (JSC::CodeBlock::CodeBlock): (JSC::CodeBlock::mark): (JSC::CodeBlock::shrinkToFit): * bytecode/CodeBlock.h: (JSC::CodeBlock::isTemporaryRegisterIndex): (JSC::CodeBlock::constantRegister): (JSC::CodeBlock::isConstantRegisterIndex): (JSC::CodeBlock::getConstant): (JSC::ExecState::r): * bytecode/Opcode.h: * bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::preserveLastVar): (JSC::BytecodeGenerator::BytecodeGenerator): (JSC::BytecodeGenerator::addConstantValue): (JSC::BytecodeGenerator::emitEqualityOp): (JSC::BytecodeGenerator::emitLoad): (JSC::BytecodeGenerator::emitResolveBase): (JSC::BytecodeGenerator::emitResolveWithBase): (JSC::BytecodeGenerator::emitNewError): * bytecompiler/BytecodeGenerator.h: (JSC::BytecodeGenerator::emitNode): * interpreter/CallFrame.h: (JSC::ExecState::noCaller): (JSC::ExecState::hasHostCallFrameFlag): (JSC::ExecState::addHostCallFrameFlag): (JSC::ExecState::removeHostCallFrameFlag): * interpreter/Interpreter.cpp: (JSC::Interpreter::resolve): (JSC::Interpreter::resolveSkip): (JSC::Interpreter::resolveGlobal): (JSC::Interpreter::resolveBase): (JSC::Interpreter::resolveBaseAndProperty): (JSC::Interpreter::resolveBaseAndFunc): (JSC::Interpreter::dumpRegisters): (JSC::Interpreter::throwException): (JSC::Interpreter::createExceptionScope): (JSC::Interpreter::privateExecute): (JSC::Interpreter::retrieveArguments): * jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): * jit/JITInlineMethods.h: (JSC::JIT::emitLoadDouble): (JSC::JIT::emitLoadInt32ToDouble): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_new_error): (JSC::JIT::emit_op_enter): (JSC::JIT::emit_op_enter_with_activation): * parser/Nodes.cpp: (JSC::DeleteResolveNode::emitBytecode): (JSC::DeleteValueNode::emitBytecode): (JSC::PrefixResolveNode::emitBytecode): * runtime/JSActivation.cpp: (JSC::JSActivation::JSActivation): * wtf/Platform.h: 2009-07-07 Mark Rowe <mrowe@apple.com> Reviewed by Darin Adler. Fix <https://bugs.webkit.org/show_bug.cgi?id=27025> / <rdar://problem/7033448>. Bug 27025: Crashes and regression test failures related to regexps in 64-bit For x86_64 RegexGenerator uses rbx, a callee-save register, as a scratch register but neglects to save and restore it. The change in handling of the output vector in r45545 altered code generation so that the RegExp::match was now storing important data in rbx, which caused crashes and bogus results when it was clobbered. * yarr/RegexJIT.cpp: (JSC::Yarr::RegexGenerator::generateEnter): Save rbx. (JSC::Yarr::RegexGenerator::generateReturn): Restore rbx. 2009-07-06 Ada Chan <adachan@apple.com> Reviewed by Darin Adler and Mark Rowe. Decommitted spans are added to the list of normal spans rather than the returned spans in TCMalloc_PageHeap::Delete(). https://bugs.webkit.org/show_bug.cgi?id=26998 In TCMalloc_PageHeap::Delete(), the deleted span can be decommitted in the process of merging with neighboring spans that are also decommitted. The merged span needs to be placed in the list of returned spans (spans whose memory has been returned to the system). Right now it's always added to the list of the normal spans which can theoretically cause thrashing. * wtf/FastMalloc.cpp: (WTF::TCMalloc_PageHeap::Delete): 2009-07-05 Lars Knoll <lars.knoll@nokia.com> Reviewed by Maciej Stachowiak. https://bugs.webkit.org/show_bug.cgi?id=26843 Fix run-time crashes in JavaScriptCore with the Metrowerks compiler on Symbian. The Metrowerks compiler on the Symbian platform moves the globally defined Hashtables into read-only memory, despite one of the members being mutable. This causes crashes at run-time due to write access to read-only memory. Avoid the use of const with this compiler by introducing the JSC_CONST_HASHTABLE macro. Based on idea by Norbert Leser. * runtime/Lookup.h: Define JSC_CONST_HASHTABLE as const for !WINSCW. * create_hash_table: Use JSC_CONST_HASHTABLE for hashtables. * runtime/JSGlobalData.cpp: Import various global hashtables via the macro. 2009-07-04 Dan Bernstein <mitz@apple.com> - debug build fix * runtime/RegExpConstructor.cpp: (JSC::RegExpConstructor::getLastParen): 2009-07-03 Yong Li <yong.li@torchmobile.com> Reviewed by Maciej Stachowiak (and revised slightly) RegExp::match to be optimized https://bugs.webkit.org/show_bug.cgi?id=26957 Allow regexp matching to use Vectors with inline capacity instead of allocating a new ovector buffer every time. ~5% speedup on SunSpider string-unpack-code test, 0.3% on SunSpider overall. * runtime/RegExp.cpp: (JSC::RegExp::match): * runtime/RegExp.h: * runtime/RegExpConstructor.cpp: (JSC::RegExpConstructorPrivate::RegExpConstructorPrivate): (JSC::RegExpConstructorPrivate::lastOvector): (JSC::RegExpConstructorPrivate::tempOvector): (JSC::RegExpConstructorPrivate::changeLastOvector): (JSC::RegExpConstructor::performMatch): (JSC::RegExpMatchesArray::RegExpMatchesArray): (JSC::RegExpMatchesArray::fillArrayInstance): (JSC::RegExpConstructor::getBackref): (JSC::RegExpConstructor::getLastParen): (JSC::RegExpConstructor::getLeftContext): (JSC::RegExpConstructor::getRightContext): * runtime/StringPrototype.cpp: (JSC::stringProtoFuncSplit): 2009-06-30 Kwang Yul Seo <skyul@company100.net> Reviewed by Eric Seidel. Override operator new/delete with const std::nothrow_t& as the second argument. https://bugs.webkit.org/show_bug.cgi?id=26792 On Windows CE, operator new/delete, new[]/delete[] with const std::nothrow_t& must be overrided because some standard template libraries use these operators. The problem occurs when memory allocated by new(size_t s, const std::nothrow_t&) is freed by delete(void* p). This causes the umatched malloc/free problem. The patch overrides all new, delete, new[] and delete[] to use fastMaloc and fastFree consistently. * wtf/FastMalloc.h: (throw): 2009-06-30 Gabor Loki <loki@inf.u-szeged.hu> Reviewed by Sam Weinig. <https://bugs.webkit.org/show_bug.cgi?id=24986> Remove unnecessary references to AssemblerBuffer. * interpreter/Interpreter.cpp: * interpreter/Interpreter.h: 2009-06-29 David Levin <levin@chromium.org> Reviewed by Oliver Hunt. Still seeing occasional leaks from UString::sharedBuffer code https://bugs.webkit.org/show_bug.cgi?id=26420 The problem is that the pointer to the memory allocation isn't visible by "leaks" due to the lower bits being used as flags. The fix is to make the pointer visible in memory (in debug only). The downside of this fix that the memory allocated by sharedBuffer will still look like a leak in non-debug builds when any flags are set. * wtf/PtrAndFlags.h: (WTF::PtrAndFlags::set): 2009-06-29 Sam Weinig <sam@webkit.org> Reviewed by Mark Rowe. Remove more unused scons support. * SConstruct: Removed. 2009-06-29 Oliver Hunt <oliver@apple.com> Reviewed by Gavin Barraclough. <rdar://problem/7016214> JSON.parse fails to parse valid JSON with most Unicode characters <https://bugs.webkit.org/show_bug.cgi?id=26802> In the original JSON.parse patch unicode was handled correctly, however in some last minute "clean up" I oversimplified isSafeStringCharacter. This patch corrects this bug. * runtime/LiteralParser.cpp: (JSC::isSafeStringCharacter): (JSC::LiteralParser::Lexer::lexString): 2009-06-26 Oliver Hunt <oliver@apple.com> Reviewed by Dan Bernstein. <rdar://problem/7009684> REGRESSION(r45039): Crashes inside JSEvent::put on PowerPC (26746) <https://bugs.webkit.org/show_bug.cgi?id=26746> Fix for r45039 incorrectly uncached a get_by_id by converting it to put_by_id. Clearly this is less than correct. This patch corrects that error. * interpreter/Interpreter.cpp: (JSC::Interpreter::tryCacheGetByID): 2009-06-26 Eric Seidel <eric@webkit.org> No review, only rolling out r45259. Roll out r45259 after crash appeared on the bots: plugins/undefined-property-crash.html ASSERTION FAILED: s <= HeapConstants<heapType>::cellSize (leopard-intel-debug-tests/build/JavaScriptCore/runtime/Collector.cpp:278 void* JSC::Heap::heapAllocate(size_t) [with JSC::HeapType heapType = PrimaryHeap]) * runtime/DateInstance.cpp: * runtime/Identifier.cpp: * runtime/Lookup.h: * runtime/RegExpConstructor.cpp: * runtime/RegExpObject.h: * runtime/ScopeChain.h: * runtime/UString.h: 2009-06-26 Jedrzej Nowacki <jedrzej.nowacki@nokia.com> Reviewed by Simon Hausmann. Add support for QDataStream operators to Vector. * wtf/Vector.h: (WTF::operator<<): (WTF::operator>>): 2009-06-24 Sam Weinig <sam@webkit.org> Reviewed by Gavin Barraclough. Make the opcode sampler work once again. * jit/JIT.h: (JSC::JIT::compileGetByIdProto): (JSC::JIT::compileGetByIdSelfList): (JSC::JIT::compileGetByIdProtoList): (JSC::JIT::compileGetByIdChainList): (JSC::JIT::compileGetByIdChain): (JSC::JIT::compilePutByIdTransition): (JSC::JIT::compileCTIMachineTrampolines): (JSC::JIT::compilePatchGetArrayLength): * jit/JITStubCall.h: (JSC::JITStubCall::call): 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Maciej Stachowiak. Extend FastAllocBase.h with 'using WTF::FastAllocBase' to avoid unnecessary WTF:: usings. Remove existing unnecessary WTF:: usings. * interpreter/Interpreter.h: * profiler/CallIdentifier.h: * runtime/ScopeChain.h: * wtf/FastAllocBase.h: 2009-06-24 David Levin <levin@chromium.org> Fix all builds. * bytecode/CodeBlock.h: * bytecompiler/BytecodeGenerator.h: * interpreter/Register.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Maciej Stachowiak. https://bugs.webkit.org/show_bug.cgi?id=26677 Inherits CodeBlock class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/bytecode/CodeBlock.h:217. * bytecode/CodeBlock.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Maciej Stachowiak. https://bugs.webkit.org/show_bug.cgi?id=26676 Inherits BytecodeGenerator class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/parser/Nodes.cpp:1892. * bytecompiler/BytecodeGenerator.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Maciej Stachowiak. https://bugs.webkit.org/show_bug.cgi?id=26675 Inherits Register class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/runtime/JSVariableObject.h:149. * interpreter/Register.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Darin Adler. https://bugs.webkit.org/show_bug.cgi?id=26674 Inherits HashMap class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/runtime/Structure.cpp:458. * wtf/HashMap.h: 2009-06-24 Oliver Hunt <oliver@apple.com> Reviewed by Darin Adler. <rdar://problem/6940519> REGRESSION (Safari 4 Public Beta - TOT): google.com/adplanner shows blank page instead of site details in "basic research' The problem was caused by the page returned with a function using a var declaration list containing around ~3000 variables. The solution to this is to flatten the comma expression representation and make codegen comma expressions and initializer lists iterative rather than recursive. * parser/Grammar.y: * parser/NodeConstructors.h: (JSC::CommaNode::CommaNode): * parser/Nodes.cpp: (JSC::CommaNode::emitBytecode): * parser/Nodes.h: (JSC::ExpressionNode::isCommaNode): (JSC::CommaNode::isCommaNode): (JSC::CommaNode::append): 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Maciej Stachowiak. https://bugs.webkit.org/show_bug.cgi?id=26645 Inherits ScopeChainNode class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/runtime/ScopeChain.h:95. * wtf/RefPtr.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Darin Adler. https://bugs.webkit.org/show_bug.cgi?id=26648 Inherits Deque class from FastAllocBase because it has been instantiated by 'new' with DEFINE_STATIC_LOCAL macro in JavaScriptCore/wtf/MainThread.cpp:62. * wtf/Deque.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Darin Adler. https://bugs.webkit.org/show_bug.cgi?id=26644 Inherits RefPtr class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/runtime/StructureChain.cpp:41. * wtf/RefPtr.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Darin Adler. Inherits HashSet class from FastAllocBase, because it has been instantiated by 'new' in JavaScriptCore/runtime/Collector.h:116. * wtf/HashSet.h: 2009-06-24 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Darin Adler. Inherits Vector class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/runtime/Structure.cpp:633. * wtf/Vector.h: 2009-06-24 Norbert Leser <norbert.leser@nokia.com> Reviewed by Maciej Stachoviak. The BytecodeGenerator objects were instantiated on stack, which takes up ~38kB per instance (each instance includes copy of JSC::CodeBlock with large SymbolTable, etc.). Specifically, since there is nested invocation (e.g., GlobalCode --> FunctionCode), the stack overflows immediately on Symbian hardware (max. 80 kB). Proposed change allocates generator objects on heap. Performance impact (if any) should be negligible and change is proposed as general fix, rather than ifdef'd for SYMBIAN. * parser/Nodes.cpp: (JSC::ProgramNode::generateBytecode): (JSC::EvalNode::generateBytecode): (JSC::EvalNode::bytecodeForExceptionInfoReparse): (JSC::FunctionBodyNode::generateBytecode): (JSC::FunctionBodyNode::bytecodeForExceptionInfoReparse): 2009-06-23 Oliver Hunt <oliver@apple.com> Reviewed by Gavin Barraclough. <rdar://problem/6992806> REGRESSION: Enumeration can skip new properties in cases of prototypes that have more than 64 (26593) <https://bugs.webkit.org/show_bug.cgi?id=26593> Do not attempt to cache structure chains if they contain a dictionary at any level. * interpreter/Interpreter.cpp: (JSC::Interpreter::tryCachePutByID): (JSC::Interpreter::tryCacheGetByID): * jit/JITStubs.cpp: (JSC::JITThunks::tryCachePutByID): * runtime/Structure.cpp: (JSC::Structure::getEnumerablePropertyNames): (JSC::Structure::addPropertyTransition): * runtime/StructureChain.cpp: (JSC::StructureChain::isCacheable): * runtime/StructureChain.h: 2009-06-23 Yong Li <yong.li@torchmobile.com> Reviewed by George Staikos. https://bugs.webkit.org/show_bug.cgi?id=26654 Add the proper export define for the JavaScriptCore API when building for WINCE. * API/JSBase.h: 2009-06-23 Joe Mason <joe.mason@torchmobile.com> Reviewed by Adam Treat. Authors: Yong Li <yong.li@torchmobile.com>, Joe Mason <joe.mason@torchmobile.com> https://bugs.webkit.org/show_bug.cgi?id=26611 Implement currentThreadStackBase on WINCE by adding a global, g_stackBase, which must be set to the address of a local variable by the caller before calling any WebKit function that invokes JSC. * runtime/Collector.cpp: (JSC::isPageWritable): (JSC::getStackBase): Starts at the top of the stack and returns the entire range of consecutive writable pages as an estimate of the actual stack. This will be much bigger than the actual stack range, so some dead objects can't be collected, but it guarantees live objects aren't collected prematurely. (JSC::currentThreadStackBase): On WinCE, returns g_stackBase if set or call getStackBase as a fallback if not. 2009-06-23 Oliver Hunt <oliver@apple.com> Reviewed by Alexey Proskuryakov. Fix stupid performance problem in the LiteralParser The LiteralParser was making a new UString in order to use toDouble, however UString's toDouble allows a much wider range of numberic strings than the LiteralParser accepts, and requires an additional heap allocation or two for the construciton of the UString. To rectify this we just call WTF::dtoa directly using a stack allocated buffer to hold the validated numeric literal. * runtime/LiteralParser.cpp: (JSC::LiteralParser::Lexer::lexNumber): (JSC::LiteralParser::parse): * runtime/LiteralParser.h: 2009-06-22 Oliver Hunt <oliver@apple.com> Reviewed by Alexey Proskuryakov. Bug 26640: JSON.stringify needs to special case Boolean objects <https://bugs.webkit.org/show_bug.cgi?id=26640> Add special case handling of the Boolean object so we match current ES5 errata. * runtime/JSONObject.cpp: (JSC::unwrapBoxedPrimitive): renamed from unwrapNumberOrString (JSC::gap): (JSC::Stringifier::appendStringifiedValue): 2009-06-22 Oliver Hunt <oliver@apple.com> Reviewed by Darin Adler. Bug 26591: Support revivers in JSON.parse <https://bugs.webkit.org/show_bug.cgi?id=26591> Add reviver support to JSON.parse. This completes the JSON object. * runtime/JSONObject.cpp: (JSC::Walker::Walker): (JSC::Walker::callReviver): (JSC::Walker::walk): (JSC::JSONProtoFuncParse): 2009-06-21 Oliver Hunt <oliver@apple.com> Reviewed by Darin Adler. Bug 26592: Support standard toJSON functions <https://bugs.webkit.org/show_bug.cgi?id=26592> Add support for the standard Date.toJSON function. * runtime/DatePrototype.cpp: (JSC::dateProtoFuncToJSON): 2009-06-21 Oliver Hunt <oliver@apple.com> Reviewed by Sam Weinig. Bug 26594: JSC needs to support Date.toISOString <https://bugs.webkit.org/show_bug.cgi?id=26594> Add support for Date.toISOString. * runtime/DatePrototype.cpp: (JSC::dateProtoFuncToISOString): 2009-06-21 Oliver Hunt <oliver@apple.com> Reviewed by NOBODY (Build fix). Remove dead code. * runtime/LiteralParser.cpp: (JSC::LiteralParser::parse): 2009-06-21 Oliver Hunt <oliver@apple.com> Reviewed by Darin Adler and Cameron Zwarich. Bug 26587: Support JSON.parse <https://bugs.webkit.org/show_bug.cgi?id=26587> Extend the LiteralParser to support the full strict JSON grammar, fix a few places where the grammar was incorrectly lenient. Doesn't yet support the JSON.parse reviver function but that does not block the JSON.parse functionality itself. * interpreter/Interpreter.cpp: (JSC::Interpreter::callEval): * runtime/JSGlobalObjectFunctions.cpp: (JSC::globalFuncEval): * runtime/JSONObject.cpp: (JSC::JSONProtoFuncParse): * runtime/LiteralParser.cpp: (JSC::LiteralParser::Lexer::lex): (JSC::isSafeStringCharacter): (JSC::LiteralParser::Lexer::lexString): (JSC::LiteralParser::parse): * runtime/LiteralParser.h: (JSC::LiteralParser::LiteralParser): (JSC::LiteralParser::tryJSONParse): (JSC::LiteralParser::): (JSC::LiteralParser::Lexer::Lexer): 2009-06-21 David Levin <levin@chromium.org> Reviewed by NOBODY (speculative build fix for windows). Simply removed some whitespace form this file to make windows build wtf and hopefully copy the new MessageQueque.h so that WebCore picks it up. * wtf/Assertions.cpp: 2009-06-21 Drew Wilson <atwilson@google.com> Reviewed by David Levin. <https://bugs.webkit.org/show_bug.cgi?id=25043> Added support for multi-threaded MessagePorts. * wtf/MessageQueue.h: (WTF::::appendAndCheckEmpty): Added API to test whether the queue was empty before adding an element. 2009-06-20 David D. Kilzer <ddkilzer@webkit.org> Fix namespace comment in SegmentedVector.h * wtf/SegmentedVector.h: Updated namespace comment to reflect new namespace after r44897. 2009-06-20 Zoltan Herczeg <zherczeg@inf.u-szeged.hu> Bug 24986: ARM JIT port <https://bugs.webkit.org/show_bug.cgi?id=24986> Reviewed by Oliver Hunt. An Iterator added for SegmentedVector. Currently only the pre ++ operator is supported. * wtf/SegmentedVector.h: (WTF::SegmentedVectorIterator::~SegmentedVectorIterator): (WTF::SegmentedVectorIterator::operator*): (WTF::SegmentedVectorIterator::operator->): (WTF::SegmentedVectorIterator::operator++): (WTF::SegmentedVectorIterator::operator==): (WTF::SegmentedVectorIterator::operator!=): (WTF::SegmentedVectorIterator::operator=): (WTF::SegmentedVectorIterator::SegmentedVectorIterator): (WTF::SegmentedVector::alloc): (WTF::SegmentedVector::begin): (WTF::SegmentedVector::end): 2009-06-20 Zoltan Herczeg <zherczeg@inf.u-szeged.hu> Bug 24986: ARM JIT port <https://bugs.webkit.org/show_bug.cgi?id=24986> Reviewed by Oliver Hunt. Move SegmentedVector to /wtf subdirectory and change "namespace JSC" to "namespace WTF" Additional build file updates by David Kilzer. * GNUmakefile.am: Updated path to SegmentedVector.h. * JavaScriptCore.order: Updated SegmentedVector namespace from JSC to WTF in mangled C++ method name. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: Removed reference to bytecompiler\SegmentedVector.h. * JavaScriptCore.vcproj/WTF/WTF.vcproj: Added reference to wtf\SegmentedVector.h. * JavaScriptCore.xcodeproj/project.pbxproj: Moved SegmentedVector.h definition from bytecompiler subdirectory to wtf subdirectory. * bytecompiler/BytecodeGenerator.h: Updated #include path to SegmentedVector.h and prepended WTF:: namespace to its use. * parser/Lexer.h: Ditto. * wtf/SegmentedVector.h: Renamed from JavaScriptCore/bytecompiler/SegmentedVector.h. (WTF::SegmentedVector::SegmentedVector): (WTF::SegmentedVector::~SegmentedVector): (WTF::SegmentedVector::size): (WTF::SegmentedVector::at): (WTF::SegmentedVector::operator[]): (WTF::SegmentedVector::last): (WTF::SegmentedVector::append): (WTF::SegmentedVector::removeLast): (WTF::SegmentedVector::grow): (WTF::SegmentedVector::clear): (WTF::SegmentedVector::deleteAllSegments): (WTF::SegmentedVector::segmentExistsFor): (WTF::SegmentedVector::segmentFor): (WTF::SegmentedVector::subscriptFor): (WTF::SegmentedVector::ensureSegmentsFor): (WTF::SegmentedVector::ensureSegment): 2009-06-19 Gavin Barraclough <barraclough@apple.com> Reviewed by NOBODY (build fix take 2 - rename FIELD_OFFSET to something that doesn't conflict with winnt.h). * jit/JIT.cpp: (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines): (JSC::JIT::emitGetVariableObjectRegister): (JSC::JIT::emitPutVariableObjectRegister): * jit/JIT.h: * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_rshift): (JSC::JIT::emitSlow_op_jnless): (JSC::JIT::emitSlow_op_jnlesseq): (JSC::JIT::compileBinaryArithOp): * jit/JITCall.cpp: (JSC::JIT::compileOpCallInitializeCallFrame): (JSC::JIT::compileOpCall): * jit/JITInlineMethods.h: (JSC::JIT::restoreArgumentReference): (JSC::JIT::checkStructure): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_instanceof): (JSC::JIT::emit_op_get_scoped_var): (JSC::JIT::emit_op_put_scoped_var): (JSC::JIT::emit_op_construct_verify): (JSC::JIT::emit_op_resolve_global): (JSC::JIT::emit_op_jeq_null): (JSC::JIT::emit_op_jneq_null): (JSC::JIT::emit_op_to_jsnumber): (JSC::JIT::emit_op_catch): (JSC::JIT::emit_op_eq_null): (JSC::JIT::emit_op_neq_null): (JSC::JIT::emit_op_convert_this): (JSC::JIT::emit_op_profile_will_call): (JSC::JIT::emit_op_profile_did_call): (JSC::JIT::emitSlow_op_get_by_val): * jit/JITPropertyAccess.cpp: (JSC::JIT::emit_op_get_by_val): (JSC::JIT::emit_op_put_by_val): (JSC::JIT::emit_op_method_check): (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::emit_op_put_by_id): (JSC::JIT::compilePutDirectOffset): (JSC::JIT::compileGetDirectOffset): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompilePatchGetArrayLength): * jit/JITStubs.cpp: (JSC::JITThunks::JITThunks): 2009-06-19 Gavin Barraclough <barraclough@apple.com> Reviewed by NOBODY (Windows build fix). * jit/JIT.h: * jit/JITInlineMethods.h: 2009-06-19 Gabor Loki <loki@inf.u-szeged.hu> Reviewed by Gavin Barraclough. Reorganize ARM architecture specific macros. Use PLATFORM_ARM_ARCH(7) instead of PLATFORM(ARM_V7). Bug 24986: ARM JIT port <https://bugs.webkit.org/show_bug.cgi?id=24986> * assembler/ARMv7Assembler.h: * assembler/AbstractMacroAssembler.h: (JSC::AbstractMacroAssembler::Imm32::Imm32): * assembler/MacroAssembler.h: * assembler/MacroAssemblerCodeRef.h: (JSC::MacroAssemblerCodePtr::MacroAssemblerCodePtr): * jit/ExecutableAllocator.h: (JSC::ExecutableAllocator::cacheFlush): * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::restoreArgumentReferenceForTrampoline): * jit/JITStubs.cpp: * jit/JITStubs.h: * wtf/Platform.h: * yarr/RegexJIT.cpp: (JSC::Yarr::RegexGenerator::generateEnter): (JSC::Yarr::RegexGenerator::generateReturn): 2009-06-19 Gavin Barraclough <barraclough@apple.com> Reviewed by Oliver Hunt. Fix armv7 JIT build issues. Unfortunate the arm compiler does not like the use of offsetof on JITStackFrame (since it now contains non POD types), and the FIELD_OFFSET macro does not appear constantish enough for it to be happy with its use in COMPILE_ASSERT macros. * Replace offsetofs with FIELD_OFFSETs (safe on C++ objects). * Move COMPILE_ASSERTs defending layout of JITStackFrame structure on armv7 into JITThunks constructor. * jit/JIT.cpp: * jit/JIT.h: * jit/JITInlineMethods.h: (JSC::JIT::restoreArgumentReference): * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_catch): * jit/JITStubs.cpp: (JSC::JITThunks::JITThunks): 2009-06-19 Adam Treat <adam.treat@torchmobile.com> Blind attempt at build fix. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-06-19 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Oliver Hunt. Inherits CallIdentifier struct from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/profiler/CallIdentifier.h:86. * wtf/HashCountedSet.h: 2009-06-19 Adam Treat <adam.treat@torchmobile.com> Reviewed by Oliver Hunt. https://bugs.webkit.org/show_bug.cgi?id=26540 Modify the test shell to add a new function 'checkSyntax' that will only parse the source instead of executing it. In this way we can test pure parsing performance against some of the larger scripts in the wild. * jsc.cpp: (GlobalObject::GlobalObject): (functionCheckSyntax): 2009-06-19 Zoltan Horvath <hzoltan@inf.u-szeged.hu> Reviewed by Darin Adler. Inherits HashCountedSet class from FastAllocBase because it has been instantiated by 'new' in JavaScriptCore/runtime/Collector.cpp:1095. * wtf/HashCountedSet.h: 2009-06-19 Yong Li <yong.li@torchmobile.com> Reviewed by George Staikos. https://bugs.webkit.org/show_bug.cgi?id=26558 Declare these symbols extern for WINCE as they are provided by libce. * runtime/DateConstructor.cpp: * runtime/DatePrototype.cpp: (JSC::formatLocaleDate): 2009-06-19 Oliver Hunt <oliver@apple.com> Reviewed by Maciej Stachowiak. <rdar://problem/6988973> ScopeChain leak in interpreter builds Move the Scopechain destruction code in JSFunction outside of the ENABLE(JIT) path. * runtime/JSFunction.cpp: (JSC::JSFunction::~JSFunction): * wtf/Platform.h: 2009-06-19 Yong Li <yong.li@torchmobile.com> Reviewed by George Staikos. https://bugs.webkit.org/show_bug.cgi?id=26543 Windows CE uses 'GetLastError' instead of 'errno.' * interpreter/RegisterFile.h: (JSC::RegisterFile::RegisterFile): (JSC::RegisterFile::grow): 2009-06-19 David Levin <levin@chromium.org> Reviewed by NOBODY (Windows build fix). Add export for Windows corresponding to OSX export done in r44844. * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: 2009-06-18 Oliver Hunt <oliver@apple.com> Reviewed by Gavin "Viceroy of Venezuela" Barraclough. Bug 26532: Native functions do not correctly unlink from optimised callsites when they're collected <https://bugs.webkit.org/show_bug.cgi?id=26532> <rdar://problem/6625385> We need to make sure that each native function instance correctly unlinks any references to it when it is collected. Allowing this to happen required a few changes: * Every native function needs a codeblock to track the link information * To have this codeblock, every function now also needs its own functionbodynode so we no longer get to have a single shared instance. * Identifying a host function is now done by looking for CodeBlock::codeType() == NativeCode * JavaScriptCore.exp: * bytecode/CodeBlock.cpp: (JSC::CodeBlock::CodeBlock): Constructor for NativeCode CodeBlock (JSC::CodeBlock::derefStructures): (JSC::CodeBlock::refStructures): (JSC::CodeBlock::reparseForExceptionInfoIfNecessary): (JSC::CodeBlock::handlerForBytecodeOffset): (JSC::CodeBlock::lineNumberForBytecodeOffset): (JSC::CodeBlock::expressionRangeForBytecodeOffset): (JSC::CodeBlock::getByIdExceptionInfoForBytecodeOffset): (JSC::CodeBlock::functionRegisterForBytecodeOffset): (JSC::CodeBlock::hasGlobalResolveInstructionAtBytecodeOffset): (JSC::CodeBlock::hasGlobalResolveInfoAtBytecodeOffset): (JSC::CodeBlock::setJITCode): Add assertions to ensure we don't try and use NativeCode CodeBlocks as a normal codeblock. * bytecode/CodeBlock.h: (JSC::): (JSC::CodeBlock::source): (JSC::CodeBlock::sourceOffset): (JSC::CodeBlock::evalCodeCache): (JSC::CodeBlock::createRareDataIfNecessary): More assertions. * jit/JIT.cpp: (JSC::JIT::privateCompileCTIMachineTrampolines): (JSC::JIT::linkCall): Update logic to allow native function caching * jit/JITStubs.cpp: * parser/Nodes.cpp: (JSC::FunctionBodyNode::createNativeThunk): (JSC::FunctionBodyNode::isHostFunction): * parser/Nodes.h: * runtime/JSFunction.cpp: (JSC::JSFunction::JSFunction): (JSC::JSFunction::~JSFunction): (JSC::JSFunction::mark): * runtime/JSGlobalData.cpp: (JSC::JSGlobalData::~JSGlobalData): * runtime/JSGlobalData.h: 2009-06-18 Gavin Barraclough <barraclough@apple.com> Reviewed by NOBODY (Windows build fix). * wtf/DateMath.cpp: (WTF::calculateUTCOffset): 2009-06-18 Gavin Barraclough <barraclough@apple.com> Reviewed by Geoff Garen. Timezone calculation incorrect in Venezuela. https://bugs.webkit.org/show_bug.cgi?id=26531 <rdar://problem/6646169> Time is incorrectly reported to JavaScript in both Safari 3 and Firefox 3 The problem is that we're calculating the timezone relative to 01/01/2000, but the VET timezone changed from -4 hours to -4:30 hours on 12/09/2007. According to the spec, section 15.9.1.9 states "the time since the beginning of the year", presumably meaning the *current* year. Change the calculation to be based on whatever the current year is, rather than a canned date. No performance impact. * wtf/DateMath.cpp: (WTF::calculateUTCOffset): 2009-06-18 Gavin Barraclough <barraclough@apple.com> Rubber Stamped by Mark Rowe (originally reviewed by Sam Weinig). (Reintroducing patch added in r44492, and reverted in r44796.) Change the implementation of op_throw so the stub function always modifies its return address - if it doesn't find a 'catch' it will switch to a trampoline to force a return from JIT execution. This saves memory, by avoiding the need for a unique return for every op_throw. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_throw): JITStubs::cti_op_throw now always changes its return address, remove return code generated after the stub call (this is now handled by ctiOpThrowNotCaught). * jit/JITStubs.cpp: (JSC::): Add ctiOpThrowNotCaught definitions. (JSC::JITStubs::DEFINE_STUB_FUNCTION): Change cti_op_throw to always change its return address. * jit/JITStubs.h: Add ctiOpThrowNotCaught declaration. 2009-06-18 Kevin McCullough <kmccullough@apple.com> Reviewed by Oliver Hunt. <rdar://problem/6940880> REGRESSION: Breakpoints don't break in 64-bit - Exposed functions now needed by WebCore. * JavaScriptCore.exp: 2009-06-17 Darin Adler <darin@apple.com> Reviewed by Oliver Hunt. Bug 26429: Make JSON.stringify non-recursive so it can handle objects of arbitrary complexity https://bugs.webkit.org/show_bug.cgi?id=26429 For marking I decided not to use gcProtect, because this is inside the engine so it's easy enough to just do marking. And that darned gcProtect does locking! Oliver tried to convince me to used MarkedArgumentBuffer, but the constructor for that class says "FIXME: Remove all clients of this API, then remove this API." * runtime/Collector.cpp: (JSC::Heap::collect): Add a call to JSONObject::markStringifiers. * runtime/CommonIdentifiers.cpp: (JSC::CommonIdentifiers::CommonIdentifiers): Added emptyIdentifier. * runtime/CommonIdentifiers.h: Ditto. * runtime/JSGlobalData.cpp: (JSC::JSGlobalData::JSGlobalData): Initialize firstStringifierToMark to 0. * runtime/JSGlobalData.h: Added firstStringifierToMark. * runtime/JSONObject.cpp: Cut down the includes to the needed ones only. (JSC::unwrapNumberOrString): Added. Helper for unwrapping number and string objects to get their number and string values. (JSC::ReplacerPropertyName::ReplacerPropertyName): Added. The class is used to wrap an identifier or integer so we don't have to do any work unless we actually call a replacer. (JSC::ReplacerPropertyName::value): Added. (JSC::gap): Added. Helper function for the Stringifier constructor. (JSC::PropertyNameForFunctionCall::PropertyNameForFunctionCall): Added. The class is used to wrap an identifier or integer so we don't have to allocate a number or string until we actually call toJSON or a replacer. (JSC::PropertyNameForFunctionCall::asJSValue): Added. (JSC::Stringifier::Stringifier): Updated and moved out of the class definition. Added code to hook this into a singly linked list for marking. (JSC::Stringifier::~Stringifier): Remove from the singly linked list. (JSC::Stringifier::mark): Mark all the objects in the holder stacks. (JSC::Stringifier::stringify): Updated. (JSC::Stringifier::appendQuotedString): Tweaked and streamlined a bit. (JSC::Stringifier::toJSON): Renamed from toJSONValue. (JSC::Stringifier::appendStringifiedValue): Renamed from stringify. Added code to use the m_holderStack to do non-recursive stringify of objects and arrays. This code also uses the timeout checker since in pathological cases it could be slow even without calling into the JavaScript virtual machine. (JSC::Stringifier::willIndent): Added. (JSC::Stringifier::indent): Added. (JSC::Stringifier::unindent): Added. (JSC::Stringifier::startNewLine): Added. (JSC::Stringifier::Holder::Holder): Added. (JSC::Stringifier::Holder::appendNextProperty): Added. This is the function that handles the format of arrays and objects. (JSC::JSONObject::getOwnPropertySlot): Moved this down to the bottom of the file so the JSONObject class is not interleaved with the Stringifier class. (JSC::JSONObject::markStringifiers): Added. Calls mark. (JSC::JSONProtoFuncStringify): Streamlined the code here. The code to compute the gap string is now a separate function. * runtime/JSONObject.h: Made everything private. Added markStringifiers. 2009-06-17 Oliver Hunt <oliver@apple.com> Reviewed by Gavin Barraclough. <rdar://problem/6974140> REGRESSION(r43849): Crash in cti_op_call_NotJSFunction when getting directions on maps.google.com Roll out r43849 as it appears that we cannot rely on the address of an objects property storage being constant even if the structure is unchanged. * jit/JIT.h: * jit/JITPropertyAccess.cpp: (JSC::JIT::compileGetDirectOffset): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain): 2009-06-17 Gavin Barraclough <barraclough@apple.com> Rubber Stamped by Mark Rowe. Fully revert r44492 & r44748 while we fix a bug they cause on internal builds <rdar://problem/6955963>. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_throw): * jit/JITStubs.cpp: (JSC::): (JSC::JITStubs::DEFINE_STUB_FUNCTION): * jit/JITStubs.h: 2009-06-17 Gavin Barraclough <barraclough@apple.com> Reviewed by Mark Rowe. <rdar://problem/6947426> sunspider math-cordic.js exhibits different intermediate results running 32-bit vs. 64-bit On 64-bit, NaN-encoded values must be detagged before they can be used in rshift. No performance impact. * jit/JITArithmetic.cpp: (JSC::JIT::emit_op_rshift): 2009-06-17 Adam Treat <adam.treat@torchmobile.com> Reviewed by George Staikos. https://bugs.webkit.org/show_bug.cgi?id=23155 Move WIN_CE -> WINCE as previously discussed with Qt WINCE folks. * jsc.cpp: (main): 2009-06-17 George Staikos <george.staikos@torchmobile.com> Reviewed by Adam Treat. https://bugs.webkit.org/show_bug.cgi?id=23155 Move WIN_CE -> WINCE as previously discussed with Qt WINCE folks. * config.h: * jsc.cpp: * wtf/Assertions.cpp: * wtf/Assertions.h: * wtf/CurrentTime.cpp: (WTF::lowResUTCTime): * wtf/DateMath.cpp: (WTF::getLocalTime): * wtf/MathExtras.h: * wtf/Platform.h: * wtf/StringExtras.h: * wtf/Threading.h: * wtf/win/MainThreadWin.cpp: 2009-06-17 Gavin Barraclough <barraclough@apple.com> Reviewed by Oliver Hunt. <rdar://problem/6974175> ASSERT in JITStubs.cpp at appsaccess.apple.com Remove PropertySlot::putValue - PropertySlots should only be used for getting, not putting. Rename JSGlobalObject::getOwnPropertySlot to hasOwnPropertyForWrite, which is what it really was being used to ask, and remove some other getOwnPropertySlot & getOwnPropertySlotForWrite methods, which were unused and likely to lead to confusion. * runtime/JSGlobalObject.h: (JSC::JSGlobalObject::hasOwnPropertyForWrite): * runtime/JSObject.h: * runtime/JSStaticScopeObject.cpp: * runtime/JSStaticScopeObject.h: * runtime/PropertySlot.h: 2009-06-16 Gavin Barraclough <barraclough@apple.com> Reviewed by Oliver hunt. Temporarily partially disable r44492, since this is causing some problems on internal builds. * jit/JITOpcodes.cpp: (JSC::JIT::emit_op_throw): * jit/JITStubs.cpp: (JSC::JITStubs::DEFINE_STUB_FUNCTION): 2009-06-16 Sam Weinig <sam@webkit.org> Fix windows build. * jit/JIT.cpp: (JSC::JIT::JIT): 2009-06-16 Sam Weinig <sam@webkit.org> Reviewed by Oliver Hunt. Initialize m_bytecodeIndex to -1 in JIT, and correctly initialize it for each type of stub using the return address to find the correct offset. * jit/JIT.cpp: (JSC::JIT::JIT): * jit/JIT.h: (JSC::JIT::compileGetByIdProto): (JSC::JIT::compileGetByIdSelfList): (JSC::JIT::compileGetByIdProtoList): (JSC::JIT::compileGetByIdChainList): (JSC::JIT::compileGetByIdChain): (JSC::JIT::compilePutByIdTransition): (JSC::JIT::compileCTIMachineTrampolines): (JSC::JIT::compilePatchGetArrayLength): * jit/JITStubCall.h: (JSC::JITStubCall::call): == Rolled over to ChangeLog-2009-06-16 ==