2009-08-03 Fumitoshi Ukai <ukai@chromium.org>
[WebKit-https.git] / JavaScriptCore / ChangeLog
1 2009-08-03  Fumitoshi Ukai  <ukai@chromium.org>
2
3         Reviewed by Jan Alonzo.
4
5         Fix build break on Gtk/x86_64.
6         https://bugs.webkit.org/show_bug.cgi?id=27936
7
8         Use JSVALUE64 for X86_64 LINUX, except Qt.
9
10         * wtf/Platform.h:
11
12 2009-08-02  Xan Lopez  <xlopez@igalia.com>
13
14         Fix the GTK+ build.
15
16         * wtf/Platform.h:
17
18 2009-08-02  Geoffrey Garen  <ggaren@apple.com>
19
20         Reviewed by Sam Weinig.
21
22         Disabled JSVALUE32_64 on Qt builds, since all layout tests mysteriously
23         crash with it enabled.
24
25         * wtf/Platform.h:
26
27 2009-08-02  Geoffrey Garen  <ggaren@apple.com>
28
29         Qt build fix.
30
31         Added JSAPIValueWrapper.cpp to the build.
32
33         * JavaScriptCore.pri:
34
35 2009-08-02  Geoffrey Garen  <ggaren@apple.com>
36
37         Windows build fix.
38
39         Exported symbols for JSAPIValueWrapper.
40
41         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
42         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
43
44 2009-08-02  Geoffrey Garen  <ggaren@apple.com>
45
46         GTK build fix.
47
48         * jit/JITStubs.cpp: #include <stdarg.h>, for a definition of va_start.
49
50 2009-08-02  Geoffrey Garen  <ggaren@apple.com>
51
52         Qt build fix.
53         
54         * runtime/Collector.cpp: #include <limits.h>, for a definition of ULONG_MAX.
55
56 2009-08-02  Geoffrey Garen  <ggaren@apple.com>
57
58         Windows build fix: Nixed JSImmediate::prototype, JSImmediate::toObject,
59         and JSImmediate::toThisObject, and removed their exported symbols.
60
61         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
62         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
63         * runtime/JSImmediate.cpp:
64         * runtime/JSImmediate.h:
65
66 2009-08-02  Geoffrey Garen  <ggaren@apple.com>
67
68         Reviewed by Mark Rowe.
69
70         Enabled JSVALUE32_64 by default on all platforms other than x86_64 (which uses JSVALUE64).
71
72         * wtf/Platform.h:
73
74 2009-08-02  Kevin Ollivier  <kevino@theolliviers.com>
75
76         Reviewed by Jan Alonzo.
77
78         Script for building the JavaScriptCore library for wx.
79         https://bugs.webkit.org/show_bug.cgi?id=27619
80
81         * wscript: Added.
82
83 2009-08-02  Yong Li  <yong.li@torchmobile.com>
84
85         Reviewed by George Staikos.
86
87         DateMath depends on strftime and localtime, which need to be imported manually on WinCE
88         https://bugs.webkit.org/show_bug.cgi?id=26558
89
90         * wtf/DateMath.cpp:
91
92 2009-08-01  David Kilzer  <ddkilzer@apple.com>
93
94         wtf/Threading.h: added include of Platform.h
95
96         Reviewed by Mark Rowe.
97
98         * wtf/Threading.h: Added #include "Platform.h" since this header
99         uses PLATFORM() and other macros.
100
101 2009-08-01  Mark Rowe  <mrowe@apple.com>
102
103         Rubber-stamped by Oliver Hunt.
104
105         Roll out r46668 as it was misinformed.  ScopeChain is only used with placement new.
106
107         * runtime/ScopeChain.h:
108
109 2009-08-01  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
110
111         Allow custom memory allocation control for JavaScriptCore's HashMap class
112         http://bugs.webkit.org/show_bug.cgi?id=27871
113
114         Inherits HashMap class from FastAllocBase because it has been
115         instantiated by 'new' in JavaScriptCore/API/JSClassRef.cpp:148.
116
117         * wtf/RefPtrHashMap.h:
118         (WTF::):
119
120 2009-08-01  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
121
122         Allow custom memory allocation control for JavaScriptCore's ScopeChain class
123         https://bugs.webkit.org/show_bug.cgi?id=27834
124
125         Inherits ScopeChain class from FastAllocBase because it has been
126         instantiated by 'new' in JavaScriptCore/runtime/JSFunction.h:109.
127
128         * runtime/ScopeChain.h:
129
130 2009-08-01  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
131
132         Reviewed by Darin Adler.
133
134         Allow custom memory allocation control for JavaScriptCore's RegExpConstructorPrivate struct 
135         https://bugs.webkit.org/show_bug.cgi?id=27833
136
137         Inherits RegExpConstructorPrivate class from FastAllocBase because it has been
138         instantiated by 'new' in JavaScriptCore/runtime/RegExpConstructor.cpp:152.
139
140         * runtime/RegExpConstructor.cpp:
141
142 2009-07-31  Yong Li  <yong.li@torchmobile.com>
143
144         Reviewed by George Staikos.
145
146         Resurrect the old GetTickCount implementation of currentTime, controlled by WTF_USE_QUERY_PERFORMANCE_COUNTER
147         currentSystemTime taken from older WebKit; currentTime written by Yong Li <yong.li@torchmobile.com>; cleanup by Joe Mason <joe.mason@torchmobile.com>
148         https://bugs.webkit.org/show_bug.cgi?id=27848
149
150         * wtf/CurrentTime.cpp:
151         (WTF::currentSystemTime): get current time with GetCurrentFT
152         (WTF::currentTime): track msec elapsed since first currentSystemTime call using GetTickCount
153         * wtf/Platform.h:
154
155 2009-07-31  Ada Chan  <adachan@apple.com>
156
157         Fixes the Windows release-PGO build.
158
159         Reviewed by Jon Honeycutt.
160
161         * JavaScriptCore.vcproj/WTF/WTF.vcproj: Suppresses the warning about unreachable code that we get by adding "return 0" to WTF::TCMalloc_PageHeap::runScavengerThread().
162         * wtf/FastMalloc.cpp:
163         (WTF::TCMalloc_PageHeap::runScavengerThread): Fixes the error about the method not returning a value in the release-PGO build.
164
165 2009-07-31  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
166
167         Change malloc to fastMalloc and free to fastFree in Yarr's RegexInterpreter.cpp
168         https://bugs.webkit.org/show_bug.cgi?id=27874
169
170         Use fastMalloc and fastFree instead of malloc and free in RegexInterpreter.cpp's methods.
171
172         * yarr/RegexInterpreter.cpp:
173         (JSC::Yarr::Interpreter::allocDisjunctionContext):
174         (JSC::Yarr::Interpreter::freeDisjunctionContext):
175         (JSC::Yarr::Interpreter::allocParenthesesDisjunctionContext):
176         (JSC::Yarr::Interpreter::freeParenthesesDisjunctionContext):
177
178 2009-07-30  Xan Lopez  <xlopez@igalia.com>
179
180         Reviewed by Jan Alonzo.
181
182         Fix compiler warning.
183
184         GCC does not like C++-style comments in preprocessor directives.
185
186         * wtf/Platform.h:
187
188 2009-07-30  John McCall  <rjmccall@apple.com>
189
190         Reviewed by Gavin Barraclough.
191
192         Optimize the X86_64 trampolines: avoid the need for filler arguments
193         and move the stub-args area closer to the stack pointer.
194
195         * jit/JIT.h: adjust patch offsets because of slight code-size change 
196         * jit/JITCode.h:
197         (JSC::JITCode::execute): don't pass filler args
198         * jit/JITStubs.cpp:
199         (ctiTrampoline): (X86_64): push args onto stack, use args directly
200         (ctiVMThrowTrampoline): (X86_64): adjust %rsp by correct displacement
201         (ctiOpThrowNotCaught): (X86_64): adjust %rsp by correct displacement
202         * jit/JITStubs.h:
203         (JITStackFrame): (X86_64): move args area earlier
204         (ctiTrampoline): remove filler args from prototype
205
206 2009-07-30  Gavin Barraclough  <barraclough@apple.com>
207
208         Reviewed by NOBODY (build fix).
209
210         Temporarily revert r46618 since this is b0rking on Linux.
211
212 2009-07-23  Gavin Barraclough  <barraclough@apple.com>
213
214         Reviewed by Oliver Hunt.
215
216         Make get_by_id/put_by_id/method_check/call defer optimization using a data flag rather than a code modification.
217         ( https://bugs.webkit.org/show_bug.cgi?id=27635 )
218
219         This improves performance of ENABLE(ASSEMBLER_WX_EXCLUSIVE) builds by 2-2.5%, reducing the overhead to about 2.5%.
220         (No performance impact with ASSEMBLER_WX_EXCLUSIVE disabled).
221
222         * bytecode/CodeBlock.cpp:
223         (JSC::printStructureStubInfo):
224             - Make StructureStubInfo store the type as an integer, rather than an OpcodeID.
225
226         * bytecode/CodeBlock.h:
227         (JSC::):
228         (JSC::CallLinkInfo::seenOnce):
229         (JSC::CallLinkInfo::setSeen):
230         (JSC::MethodCallLinkInfo::seenOnce):
231         (JSC::MethodCallLinkInfo::setSeen):
232             - Change a pointer in CallLinkInfo/MethodCallLinkInfo to use a PtrAndFlags, use a flag to track when an op has been executed once.
233
234         * bytecode/StructureStubInfo.cpp:
235         (JSC::StructureStubInfo::deref):
236             - Make StructureStubInfo store the type as an integer, rather than an OpcodeID.
237
238         * bytecode/StructureStubInfo.h:
239         (JSC::StructureStubInfo::StructureStubInfo):
240         (JSC::StructureStubInfo::initGetByIdSelf):
241         (JSC::StructureStubInfo::initGetByIdProto):
242         (JSC::StructureStubInfo::initGetByIdChain):
243         (JSC::StructureStubInfo::initGetByIdSelfList):
244         (JSC::StructureStubInfo::initGetByIdProtoList):
245         (JSC::StructureStubInfo::initPutByIdTransition):
246         (JSC::StructureStubInfo::initPutByIdReplace):
247         (JSC::StructureStubInfo::seenOnce):
248         (JSC::StructureStubInfo::setSeen):
249             - Make StructureStubInfo store the type as an integer, rather than an OpcodeID, add a flag to track when an op has been executed once.
250
251         * bytecompiler/BytecodeGenerator.cpp:
252         (JSC::BytecodeGenerator::emitGetById):
253         (JSC::BytecodeGenerator::emitPutById):
254             - Make StructureStubInfo store the type as an integer, rather than an OpcodeID.
255
256         * jit/JIT.cpp:
257         (JSC::JIT::privateCompileCTIMachineTrampolines):
258         (JSC::JIT::unlinkCall):
259             - Remove the "don't lazy link" stage of calls.
260
261         * jit/JIT.h:
262         (JSC::JIT::compileCTIMachineTrampolines):
263             - Remove the "don't lazy link" stage of calls.
264
265         * jit/JITCall.cpp:
266         (JSC::JIT::compileOpCallSlowCase):
267             - Remove the "don't lazy link" stage of calls.
268
269         * jit/JITStubs.cpp:
270         (JSC::JITThunks::JITThunks):
271         (JSC::JITThunks::tryCachePutByID):
272         (JSC::JITThunks::tryCacheGetByID):
273         (JSC::JITStubs::DEFINE_STUB_FUNCTION):
274         (JSC::JITStubs::getPolymorphicAccessStructureListSlot):
275             - Remove the "don't lazy link" stage of calls, and the "_second" stage of get_by_id/put_by_id/method_check.
276
277         * jit/JITStubs.h:
278         (JSC::JITThunks::ctiStringLengthTrampoline):
279         (JSC::JITStubs::):
280             - Remove the "don't lazy link" stage of calls, and the "_second" stage of get_by_id/put_by_id/method_check.
281
282         * wtf/PtrAndFlags.h:
283         (WTF::PtrAndFlags::PtrAndFlags):
284         (WTF::PtrAndFlags::operator!):
285         (WTF::PtrAndFlags::operator->):
286             - Add ! and -> operators, add constuctor with pointer argument.
287
288 2009-07-30  Geoffrey Garen  <ggaren@apple.com>
289
290         Reviewed by Gavin Barraclough.
291
292         Fixed failing tests seen on Windows buildbot.
293
294         * jit/JITStubs.cpp:
295         (JSC::DEFINE_STUB_FUNCTION):
296         * jit/JITStubs.h:
297         (JSC::): Use "int" instead of "bool" to guarantee a 32-bit result,
298         regardless of compiler. gcc on mac uses 32-bit values for bool,
299         but gcc on linux and MSVC on Windows use 8-bit values.
300
301 2009-07-30  Geoffrey Garen  <ggaren@apple.com>
302
303         Windows build fix: added missing symbols on Windows.
304
305         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
306         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
307
308 2009-07-30  Geoffrey Garen  <ggaren@apple.com>
309
310         Windows build fix: removed stale symbols on Windows.
311
312         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
313         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
314
315 === End merge of nitro-extreme branch 2009-07-30 ===
316
317 2009-07-20  Geoffrey Garen  <ggaren@apple.com>
318
319         Fixed a post-review typo in r46066 that caused tons of test failures.
320         
321         SunSpider reports no change.
322
323         * runtime/JSArray.cpp:
324         (JSC::JSArray::JSArray): Initialize the full vector capacity, to avoid
325         uninitialized members at the end.
326
327 2009-07-20  Geoffrey Garen  <ggaren@apple.com>
328
329         Windows WebKit build fix: Added some missing exports.
330
331         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
332         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
333
334 2009-07-17  Geoffrey Garen  <ggaren@apple.com>
335
336         Reviewed by Sam Weinig.
337
338         Get the branch working on windows.
339         https://bugs.webkit.org/show_bug.cgi?id=27391
340         
341         SunSpider says 0.3% faster.
342
343         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
344         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def: Updated
345         MSVC export lists to fix linker errors.
346
347         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: Added / removed
348         new / old project files.
349
350         * jit/JIT.cpp:
351         (JSC::JIT::privateCompileCTIMachineTrampolines): Used #pragma pack to tell
352         MSVC that these structures represent actual memory layout, and should not be
353         automatically aligned. Changed the return value load to load a 64bit quantity
354         into the canonical registers.
355
356         * jit/JIT.h: Moved OBJECT_OFFSETOF definition to StdLibExtras.h because
357         it's needed by more than just the JIT, and it supplements a standard library
358         macro (offsetof).
359
360         * jit/JITCall.cpp:
361         (JSC::JIT::compileOpCallInitializeCallFrame): Fixed an incorrectly signed
362         cast to resolve an MSVC warning.
363
364         * jit/JITStubs.h: Used #pragma pack to tell MSVC that these structures
365         represent actual memory layout, and should not be automatically aligned. 
366
367         * runtime/JSArray.cpp:
368         (JSC::JSArray::JSArray): Replaced memset_pattern8 with a for loop, since
369         memset_pattern8 is not portable. (I verified that this version of the loop
370         gives the best performance / generated code in GCC.)
371
372         * runtime/JSObject.h:
373         (JSC::JSObject::JSObject): Removed accidental usage of FIELD_OFFSET --
374         OBJECT_OFFSETOF is our new macro name. (FIELD_OFFSET conflicts with a
375         definition in winnt.h.)
376
377         * runtime/JSValue.cpp: Added some headers needed by non-all-in-one builds.
378         
379         * runtime/JSValue.h:
380         (JSC::JSValue::): Made the tag signed, to match MSVC's signed enum values.
381         (GCC doesn't seem to care one way or the other.)
382
383         * wtf/MainThread.cpp: Moved the StdLibExtras.h #include -- I did this a
384         while ago to resolve a conflict with winnt.h. I can't remember if it's truly
385         still needed, but what the heck.
386
387         * wtf/StdLibExtras.h: Moved OBJECT_OFFSETOF definition here.
388
389 2009-07-06  Geoffrey Garen  <ggaren@apple.com>
390
391         Reviewed by Sam Weinig (?).
392         
393         Fixed an assertion seen during the stress test.
394         
395         Don't assume that, if op1 is constant, op2 is not, and vice versa. Sadly,
396         not all constants get folded.
397
398         * jit/JITArithmetic.cpp:
399         (JSC::JIT::emit_op_jnless):
400         (JSC::JIT::emitSlow_op_jnless):
401         (JSC::JIT::emit_op_jnlesseq):
402         (JSC::JIT::emitSlow_op_jnlesseq):
403
404 2009-07-06  Geoffrey Garen  <ggaren@apple.com>
405
406         Reviewed by Sam Weinig.
407         
408         Include op_convert_this in result caching.
409         
410         No change on SunSpider or v8.
411
412         * jit/JITOpcodes.cpp:
413         (JSC::JIT::emit_op_convert_this):
414
415         * jit/JITStubs.cpp:
416         (JSC::DEFINE_STUB_FUNCTION):
417         * jit/JITStubs.h:
418         (JSC::): Made the op_convert_this JIT stub return an EncodedJSValue, so
419         to maintain the result caching contract that { tag, payload } can be
420         found in { regT1, regT0 }.
421
422 2009-07-06  Geoffrey Garen  <ggaren@apple.com>
423
424         Reviewed by Sam Weinig.
425         
426         Implemented result chaining.
427         
428         1% faster on SunSpider. 4%-5% faster on v8.
429
430         * assembler/MacroAssemblerX86Common.h:
431         (JSC::MacroAssemblerX86Common::move):
432         * assembler/X86Assembler.h:
433         (JSC::X86Assembler::movl_rr): Added an optimization to eliminate
434         no-op mov instructions, to simplify chaining.
435
436         * jit/JIT.cpp:
437         (JSC::JIT::JIT):
438         * jit/JIT.h: Added data members and helper functions for recording
439         chained results. We record both a mapping from virtual to machine register
440         and the opcode for which the mapping is valid, to help ensure that the
441         mapping isn't used after the mapped register has been stomped by other
442         instructions.
443
444         * jit/JITCall.cpp:
445         (JSC::JIT::compileOpCallVarargs):
446         (JSC::JIT::compileOpCallVarargsSlowCase):
447         (JSC::JIT::emit_op_ret):
448         (JSC::JIT::emit_op_construct_verify):
449         (JSC::JIT::compileOpCall):
450         (JSC::JIT::compileOpCallSlowCase): Chain function call results.
451
452         * jit/JITInlineMethods.h:
453         (JSC::JIT::emitLoadTag):
454         (JSC::JIT::emitLoadPayload):
455         (JSC::JIT::emitLoad):
456         (JSC::JIT::emitLoad2):
457         (JSC::JIT::isLabeled):
458         (JSC::JIT::map):
459         (JSC::JIT::unmap):
460         (JSC::JIT::isMapped):
461         (JSC::JIT::getMappedPayload):
462         (JSC::JIT::getMappedTag): Use helper functions when loading virtual
463         registers into machine registers, in case the loads can be eliminated
464         by chaining.
465
466         * jit/JITOpcodes.cpp:
467         (JSC::JIT::emit_op_mov):
468         (JSC::JIT::emit_op_end):
469         (JSC::JIT::emit_op_instanceof):
470         (JSC::JIT::emit_op_get_global_var):
471         (JSC::JIT::emit_op_put_global_var):
472         (JSC::JIT::emit_op_get_scoped_var):
473         (JSC::JIT::emit_op_put_scoped_var):
474         (JSC::JIT::emit_op_to_primitive):
475         (JSC::JIT::emit_op_resolve_global):
476         (JSC::JIT::emit_op_jneq_ptr):
477         (JSC::JIT::emit_op_next_pname):
478         (JSC::JIT::emit_op_to_jsnumber):
479         (JSC::JIT::emit_op_catch): Chain results from these opcodes.
480
481         (JSC::JIT::emit_op_profile_will_call):
482         (JSC::JIT::emit_op_profile_did_call): Load the profiler into regT2 to
483         avoid stomping a chained result.
484
485         * jit/JITPropertyAccess.cpp:
486         (JSC::JIT::emit_op_method_check):
487         (JSC::JIT::emit_op_get_by_val):
488         (JSC::JIT::emit_op_get_by_id): Chain results from these opcodes.
489
490         * jit/JITStubCall.h:
491         (JSC::JITStubCall::addArgument): Always use { regT1, regT0 }, to facilitate
492         chaining.
493
494         (JSC::JITStubCall::call): Unmap all mapped registers, since our callee
495         stub might stomp them.
496
497 2009-07-01  Sam Weinig  <sam@webkit.org>
498
499         Reviewed by Gavin Barraclough.
500
501         Don't reload values in emitBinaryDoubleOp.
502
503         SunSpider reports a 0.6% progression. 
504
505         * jit/JIT.h:
506         * jit/JITArithmetic.cpp:
507         (JSC::JIT::emit_op_jnless):
508         (JSC::JIT::emit_op_jnlesseq):
509         (JSC::JIT::emitBinaryDoubleOp):
510
511 2009-07-01  Sam Weinig  <sam@webkit.org>
512
513         Reviewed by Geoffrey Garen.
514
515         Convert op_div to load op1 and op2 up front.
516
517         * jit/JITArithmetic.cpp:
518         (JSC::JIT::emit_op_div):
519
520 2009-07-01  Sam Weinig  <sam@webkit.org>
521
522         Reviewed by Geoffrey Garen.
523
524         Don't emit code in emitBinaryDoubleOp if code is unreachable, observable
525         via an empty (unlinked) jumplist passed in.  This only effects op_jnless
526         and op_jnlesseq at present.
527
528         * jit/JITArithmetic.cpp:
529         (JSC::JIT::emitSlow_op_jnless):
530         (JSC::JIT::emitSlow_op_jnlesseq):
531         (JSC::JIT::emitBinaryDoubleOp):
532
533 2009-07-01  Geoffrey Garen  <ggaren@apple.com>
534
535         Reviewed by Sam Weinig.
536
537         Converted op_mod to put { tag, payload } in { regT1, regT0 }, and
538         tidied up its constant case.
539         
540         SunSpider reports a 0.2% regression, but a micro-benchmark of op_mod
541         shows a 12% speedup, and the SunSpider test that uses op_mod most should
542         benefit a lot from result caching in the end, since it almost always
543         performs (expression) % constant.
544
545         * jit/JITArithmetic.cpp:
546         (JSC::JIT::emit_op_mod):
547         (JSC::JIT::emitSlow_op_mod):
548
549 2009-06-30  Sam Weinig  <sam@webkit.org>
550
551         Reviewed by Geoffrey Garen.
552
553         Converted some more arithmetic ops to put { tag, payload } in
554         { regT1, regT0 }.
555
556         * jit/JITArithmetic.cpp:
557         (JSC::JIT::emit_op_mul):
558         (JSC::JIT::emitSlow_op_mul):
559
560 2009-06-30  Geoffrey Garen  <ggaren@apple.com>
561
562         Reviewed by Sam Weinig.
563
564         Converted some more arithmetic ops to put { tag, payload } in
565         { regT1, regT0 }, and added a case for subtract constant.
566         
567         SunSpider says no change. v8 says 0.3% slower.
568
569         * jit/JIT.h:
570         * jit/JITArithmetic.cpp:
571         (JSC::JIT::emit_op_add):
572         (JSC::JIT::emitAdd32Constant):
573         (JSC::JIT::emitSlow_op_add):
574         (JSC::JIT::emit_op_sub):
575         (JSC::JIT::emitSub32Constant):
576         (JSC::JIT::emitSlow_op_sub):
577
578 2009-06-30  Gavin Barraclough  <barraclough@apple.com>
579
580         Reviewed by Sam Weinig.
581
582         Remove more uses of addressFor(), load double constants directly from
583         the constantpool in the CodeBlock, rather than from the register file.
584
585         * jit/JITArithmetic.cpp:
586         (JSC::JIT::emitAdd32Constant):
587         (JSC::JIT::emitBinaryDoubleOp):
588
589 2009-06-30  Geoffrey Garen  <ggaren@apple.com>
590
591         Reviewed by Sam Weinig.
592         
593         Fixed a bug in postfix ops, where we would treat x = x++ and x = x--
594         as a no-op, even if x were not an int, and the ++/-- could have side-effects.
595
596         * jit/JITArithmetic.cpp:
597         (JSC::JIT::emit_op_post_inc):
598         (JSC::JIT::emitSlow_op_post_inc):
599         (JSC::JIT::emit_op_post_dec):
600         (JSC::JIT::emitSlow_op_post_dec):
601
602 2009-06-30  Geoffrey Garen  <ggaren@apple.com>
603
604         Reviewed by Sam Weinig.
605         
606         Converted some arithmetic ops to put { tag, payload } in
607         { regT1, regT0 }.
608         
609         SunSpider says 0.7% faster. v8 says no change.
610
611         * jit/JIT.h:
612         * jit/JITArithmetic.cpp:
613         (JSC::JIT::emit_op_jnless):
614         (JSC::JIT::emit_op_jnlesseq):
615         (JSC::JIT::emit_op_lshift):
616         (JSC::JIT::emit_op_rshift):
617         (JSC::JIT::emit_op_bitand):
618         (JSC::JIT::emit_op_bitor):
619         (JSC::JIT::emit_op_bitxor):
620         * jit/JITInlineMethods.h:
621         (JSC::JIT::isOperandConstantImmediateInt):
622         (JSC::JIT::getOperandConstantImmediateInt):
623
624 2009-06-30  Gavin Barraclough  <barraclough@apple.com>
625
626         Reviewed by Sam Weinig.
627
628         Start removing cases of addressFor().
629
630         * jit/JIT.h:
631         * jit/JITArithmetic.cpp:
632         (JSC::JIT::emitAdd32Constant):
633         (JSC::JIT::emitBinaryDoubleOp):
634         (JSC::JIT::emit_op_div):
635         * jit/JITInlineMethods.h:
636         (JSC::JIT::emitLoadDouble):
637         (JSC::JIT::emitLoadInt32ToDouble):
638         (JSC::JIT::emitStoreDouble):
639         * jit/JITOpcodes.cpp:
640         (JSC::JIT::emit_op_jfalse):
641         (JSC::JIT::emit_op_jtrue):
642
643 2009-06-30  Geoffrey Garen  <ggaren@apple.com>
644
645         Rolled back in my last patch with regression fixed.
646
647         * jit/JIT.cpp:
648         (JSC::JIT::privateCompileSlowCases):
649         * jit/JIT.h:
650         * jit/JITOpcodes.cpp:
651         (JSC::JIT::emit_op_loop_if_less):
652         (JSC::JIT::emit_op_loop_if_lesseq):
653         (JSC::JIT::emit_op_resolve_global):
654         (JSC::JIT::emitSlow_op_resolve_global):
655         (JSC::JIT::emit_op_eq):
656         (JSC::JIT::emitSlow_op_eq):
657         (JSC::JIT::emit_op_neq):
658         (JSC::JIT::emitSlow_op_neq):
659
660 2009-06-30  Geoffrey Garen  <ggaren@apple.com>
661
662         Rolled out my last patch because it was a 2% SunSpider regression.
663
664         * jit/JIT.cpp:
665         (JSC::JIT::privateCompileSlowCases):
666         * jit/JIT.h:
667         * jit/JITOpcodes.cpp:
668         (JSC::JIT::emit_op_loop_if_less):
669         (JSC::JIT::emit_op_loop_if_lesseq):
670         (JSC::JIT::emit_op_resolve_global):
671         (JSC::JIT::emit_op_eq):
672         (JSC::JIT::emitSlow_op_eq):
673         (JSC::JIT::emit_op_neq):
674         (JSC::JIT::emitSlow_op_neq):
675
676 2009-06-30  Geoffrey Garen  <ggaren@apple.com>
677
678         Reviewed by Gavin "Sam Weinig" Barraclough.
679         
680         Standardized the rest of our opcodes to put { tag, payload } in
681         { regT1, regT0 } where possible.
682
683         * jit/JIT.cpp:
684         (JSC::JIT::privateCompileSlowCases):
685         * jit/JIT.h:
686         * jit/JITOpcodes.cpp:
687         (JSC::JIT::emit_op_loop_if_less):
688         (JSC::JIT::emit_op_loop_if_lesseq):
689         (JSC::JIT::emit_op_resolve_global):
690         (JSC::JIT::emitSlow_op_resolve_global):
691         (JSC::JIT::emit_op_eq):
692         (JSC::JIT::emitSlow_op_eq):
693         (JSC::JIT::emit_op_neq):
694         (JSC::JIT::emitSlow_op_neq):
695
696 2009-06-30  Gavin Barraclough  <barraclough@apple.com>
697
698         Reviewed by Geoffrey Garen.
699
700         Replace calls to store32(tagFor()) and store32(payloadFor())
701         with emitStoreInt32(), emitStoreBool(), and emitStoreCell().
702
703         * jit/JIT.h:
704         * jit/JITArithmetic.cpp:
705         (JSC::JIT::emit_op_negate):
706         (JSC::JIT::emit_op_lshift):
707         (JSC::JIT::emit_op_rshift):
708         (JSC::JIT::emit_op_bitand):
709         (JSC::JIT::emitBitAnd32Constant):
710         (JSC::JIT::emit_op_bitor):
711         (JSC::JIT::emitBitOr32Constant):
712         (JSC::JIT::emit_op_bitxor):
713         (JSC::JIT::emitBitXor32Constant):
714         (JSC::JIT::emit_op_bitnot):
715         (JSC::JIT::emit_op_post_inc):
716         (JSC::JIT::emit_op_post_dec):
717         (JSC::JIT::emit_op_pre_inc):
718         (JSC::JIT::emit_op_pre_dec):
719         (JSC::JIT::emit_op_add):
720         (JSC::JIT::emitAdd32Constant):
721         (JSC::JIT::emit_op_sub):
722         (JSC::JIT::emitSub32ConstantLeft):
723         (JSC::JIT::emitSub32ConstantRight):
724         (JSC::JIT::emit_op_mul):
725         (JSC::JIT::emitSlow_op_mul):
726         (JSC::JIT::emit_op_div):
727         (JSC::JIT::emit_op_mod):
728         * jit/JITCall.cpp:
729         (JSC::JIT::emit_op_load_varargs):
730         * jit/JITInlineMethods.h:
731         (JSC::JIT::emitStoreInt32):
732         (JSC::JIT::emitStoreCell):
733         (JSC::JIT::emitStoreBool):
734         (JSC::JIT::emitStore):
735         * jit/JITOpcodes.cpp:
736         (JSC::JIT::emit_op_instanceof):
737         (JSC::JIT::emit_op_not):
738         (JSC::JIT::emit_op_eq):
739         (JSC::JIT::emitSlow_op_eq):
740         (JSC::JIT::emit_op_neq):
741         (JSC::JIT::emitSlow_op_neq):
742         (JSC::JIT::compileOpStrictEq):
743         (JSC::JIT::emit_op_eq_null):
744         (JSC::JIT::emit_op_neq_null):
745         * jit/JITStubCall.h:
746         (JSC::JITStubCall::call):
747
748 2009-06-30  Geoffrey Garen  <ggaren@apple.com>
749
750         Reviewed by Sam Weinig.
751         
752         Standardized the rest of the property access instructions to put { tag,
753         payload } in { regT1, regT0 }.
754
755         Small v8 speedup, 0.2% SunSpider slowdown.
756
757         * jit/JIT.h:
758         * jit/JITInlineMethods.h:
759         (JSC::JIT::emitLoad):
760         (JSC::JIT::emitLoad2):
761         * jit/JITPropertyAccess.cpp:
762         (JSC::JIT::emit_op_get_by_val):
763         (JSC::JIT::emitSlow_op_get_by_val):
764         (JSC::JIT::emit_op_put_by_val):
765         (JSC::JIT::emitSlow_op_put_by_val):
766         (JSC::JIT::emit_op_put_by_id):
767         (JSC::JIT::emitSlow_op_put_by_id):
768         (JSC::JIT::patchPutByIdReplace):
769
770 2009-06-29  Sam Weinig  <sam@webkit.org>
771
772         Reviewed by Gavin Barraclough.
773
774         Various cleanups.
775         - Use fpRegT* instead of X86::xmm*.
776         - Use a switch statement in emitBinaryDoubleOp instead of a bunch of
777           if/elses.
778
779         * jit/JITArithmetic.cpp:
780         (JSC::JIT::emitAdd32Constant):
781         (JSC::JIT::emitBinaryDoubleOp):
782         (JSC::JIT::emit_op_div):
783
784 2009-06-29  Sam Weinig  <sam@webkit.org>
785
786         Reviewed by Geoffrey Garen.
787
788         Add inline code dealing with doubles for op_jfalse and op_jtrue.
789
790         * assembler/MacroAssemblerX86Common.h:
791         (JSC::MacroAssemblerX86Common::):
792         (JSC::MacroAssemblerX86Common::zeroDouble):
793         * jit/JITOpcodes.cpp:
794         (JSC::JIT::emit_op_jfalse):
795         (JSC::JIT::emit_op_jtrue):
796
797 2009-06-28  Geoffrey Garen  <ggaren@apple.com>
798
799         Reviewed by Sam Weinig.
800
801         Standardized op_get_by_id to put { tag, payload } in { regT1, regT0 }.
802         
803         SunSpider and v8 report maybe 0.2%-0.4% regressions, but the optimization
804         this enables will win much more than that back.
805
806         * jit/JIT.cpp:
807         (JSC::JIT::privateCompileCTIMachineTrampolines):
808         * jit/JIT.h:
809         * jit/JITPropertyAccess.cpp:
810         (JSC::JIT::emit_op_method_check):
811         (JSC::JIT::emit_op_get_by_id):
812         (JSC::JIT::compileGetByIdHotPath):
813         (JSC::JIT::compileGetByIdSlowCase):
814         (JSC::JIT::patchGetByIdSelf):
815         (JSC::JIT::privateCompilePatchGetArrayLength):
816         (JSC::JIT::privateCompileGetByIdProto):
817         (JSC::JIT::privateCompileGetByIdSelfList):
818         (JSC::JIT::privateCompileGetByIdProtoList):
819         (JSC::JIT::privateCompileGetByIdChainList):
820         (JSC::JIT::privateCompileGetByIdChain):
821
822 2009-06-26  Geoffrey Garen  <ggaren@apple.com>
823
824         Reviewed by Maciej Stachowiak.
825         
826         Standardized op_call to put { tag, payload } in { regT1, regT0 }.
827         
828         SunSpider and v8 report no change.
829
830         * jit/JIT.cpp:
831         (JSC::JIT::privateCompileCTIMachineTrampolines):
832         * jit/JITCall.cpp:
833         (JSC::JIT::compileOpCallInitializeCallFrame):
834         (JSC::JIT::compileOpCallSetupArgs):
835         (JSC::JIT::compileOpConstructSetupArgs):
836         (JSC::JIT::compileOpCallVarargsSetupArgs):
837         (JSC::JIT::compileOpCallVarargs):
838         (JSC::JIT::compileOpCall):
839         (JSC::JIT::compileOpCallSlowCase):
840
841 2009-06-26  Sam Weinig  <sam@webkit.org>
842
843         Reviewed by Geoffrey Garen.
844
845         Handle multiplying by zero a little better by
846         inlining the case that both operands are non-negative
847         into the slowpath.
848
849         * assembler/MacroAssemblerX86Common.h:
850         (JSC::MacroAssemblerX86Common::branchOr32):
851         * jit/JITArithmetic.cpp:
852         (JSC::JIT::emit_op_mul):
853         (JSC::JIT::emitSlow_op_mul):
854
855 2009-06-25  Geoffrey Garen  <ggaren@apple.com>
856
857         Reviewed by Sam Weinig.
858         
859         Optimize x++ to ++x inside for loops.
860         
861         Sadly, no measurable speedup, but this should help with result chaining.
862
863         * parser/Nodes.cpp:
864         (JSC::ForNode::emitBytecode):
865
866 2009-06-25  Geoffrey Garen  <ggaren@apple.com>
867
868         Reviewed by Sam Weinig.
869         
870         Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }.
871
872         * jit/JITArithmetic.cpp:
873         (JSC::JIT::emitSlow_op_bitnot):
874         (JSC::JIT::emit_op_post_inc):
875
876 2009-06-25  Geoffrey Garen  <ggaren@apple.com>
877
878         Reviewed by Sam Weinig.
879         
880         Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }.
881
882         * jit/JITArithmetic.cpp:
883         (JSC::JIT::emit_op_bitnot):
884         (JSC::JIT::emit_op_post_dec):
885         (JSC::JIT::emit_op_pre_inc):
886         (JSC::JIT::emitSlow_op_pre_inc):
887         (JSC::JIT::emit_op_pre_dec):
888         (JSC::JIT::emitSlow_op_pre_dec):
889
890 2009-06-25  Geoffrey Garen  <ggaren@apple.com>
891
892         Reviewed by Sam Weinig.
893         
894         Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }.
895
896         * jit/JITArithmetic.cpp:
897         (JSC::JIT::emit_op_negate):
898         (JSC::JIT::emitSlow_op_negate):
899         * jit/JITCall.cpp:
900         (JSC::JIT::emit_op_construct_verify):
901         (JSC::JIT::emitSlow_op_construct_verify):
902
903 2009-06-25  Geoffrey Garen  <ggaren@apple.com>
904
905         Reviewed by Sam Weinig.
906         
907         Standardized some more opcodes to put { tag, payload } in { regT1, regT0 }.
908
909         * jit/JITOpcodes.cpp:
910         (JSC::JIT::emit_op_loop_if_true):
911         (JSC::JIT::emit_op_jfalse):
912         (JSC::JIT::emit_op_jtrue):
913         (JSC::JIT::emit_op_jeq_null):
914         (JSC::JIT::emit_op_jneq_null):
915         (JSC::JIT::emit_op_eq_null):
916         (JSC::JIT::emit_op_neq_null):
917
918 2009-06-25  Geoffrey Garen  <ggaren@apple.com>
919
920         Reviewed by Sam Weinig (sort of, maybe).
921         
922         Fixed some ASSERTs in http/tests/security.
923         
924         These ASSERTs were introduced by http://trac.webkit.org/changeset/45057,
925         but the underlying problem was actually older. http://trac.webkit.org/changeset/45057
926         just exposed the problem by enabling optimization in more cases.
927         
928         The ASSERTs fired because we tested PropertySlot::slotBase() for validity,
929         but slotBase() ASSERTs if it's invalid, so we would ASSERT before
930         the test could happen. Solution: Remove the ASSERT. Maybe it was valid
931         once, but it clearly goes against a pattern we've deployed of late.
932         
933         The underlying problem was that WebCore would re-use a PropertySlot in
934         the case of a forwarding access, and the second use would not completely
935         overwrite the first use. Solution: Make sure to overwrite m_offset when
936         setting a value on a PropertySlot. (Other values already get implicitly
937         overwritten during reuse.)
938
939         * runtime/PropertySlot.h:
940         (JSC::PropertySlot::PropertySlot):
941         (JSC::PropertySlot::setValueSlot):
942         (JSC::PropertySlot::setValue):
943         (JSC::PropertySlot::setRegisterSlot):
944         (JSC::PropertySlot::setUndefined):
945         (JSC::PropertySlot::slotBase):
946         (JSC::PropertySlot::clearOffset):
947
948 2009-06-24  Gavin Barraclough  <barraclough@apple.com>
949
950         Reviewed by Geoff Garen.
951
952         Enable JIT_OPTIMIZE_METHOD_CALLS on the branch, implementation matches current implemenatation in ToT.
953
954         * jit/JIT.h:
955         * jit/JITPropertyAccess.cpp:
956         (JSC::JIT::emit_op_method_check):
957         (JSC::JIT::emitSlow_op_method_check):
958         (JSC::JIT::emit_op_get_by_id):
959         (JSC::JIT::compileGetByIdHotPath):
960         (JSC::JIT::emitSlow_op_get_by_id):
961         (JSC::JIT::compileGetByIdSlowCase):
962
963 2009-06-23  Geoffrey Garen  <ggaren@apple.com>
964
965         Reviewed by Sam Weinig.
966
967         Bit off a tiny bit more of standardizing opcode behavior to help with result
968         caching.
969         
970         SunSpider reports no change, v8 maybe a tiny speedup.
971
972         * jit/JITOpcodes.cpp:
973         (JSC::JIT::emit_op_to_jsnumber):
974         (JSC::JIT::emitSlow_op_to_jsnumber):
975         (JSC::JIT::emit_op_convert_this):
976         (JSC::JIT::emitSlow_op_convert_this):
977
978 2009-06-23  Geoffrey Garen  <ggaren@apple.com>
979
980         Reviewed by Sam Weinig.
981
982         Bit off a tiny bit more of standardizing opcode behavior to help with result
983         caching -- including removing my old enemy, op_resolve_function, because
984         it was non-standard, and removing it felt better than helping it limp along.
985         
986         SunSpider reports no change, v8 maybe a tiny speedup.
987         
988         * bytecode/CodeBlock.cpp:
989         (JSC::CodeBlock::dump):
990         * bytecode/Opcode.h:
991         * bytecompiler/BytecodeGenerator.cpp:
992         * bytecompiler/BytecodeGenerator.h:
993         * interpreter/Interpreter.cpp:
994         (JSC::Interpreter::privateExecute):
995         * jit/JIT.cpp:
996         (JSC::JIT::privateCompileMainPass):
997         * jit/JIT.h:
998         * jit/JITOpcodes.cpp:
999         (JSC::JIT::emit_op_get_scoped_var):
1000         (JSC::JIT::emit_op_put_scoped_var):
1001         (JSC::JIT::emit_op_to_primitive):
1002         (JSC::JIT::emitSlow_op_to_primitive):
1003         * jit/JITStubs.cpp:
1004         * jit/JITStubs.h:
1005         * parser/Nodes.cpp:
1006         (JSC::FunctionCallResolveNode::emitBytecode):
1007
1008 2009-06-23  Geoffrey Garen  <ggaren@apple.com>
1009
1010         Reviewed by Sam Weinig.
1011         
1012         Bit off a tiny bit of standardizing opcode behavior to help with result
1013         caching.
1014         
1015         0.6% SunSpider speedup. 0.3% v8 speedup.
1016
1017         * jit/JITInlineMethods.h:
1018         (JSC::JIT::emitLoad): Accomodate a base register that overlaps with payload
1019         by loading tag before payload, to avoid stomping base/payload.
1020
1021         * jit/JITOpcodes.cpp:
1022         (JSC::JIT::emit_op_mov): Abide by the standard "tag in regT1, payload in
1023         regT0" semantics.
1024
1025         (JSC::JIT::emit_op_get_global_var):
1026         (JSC::JIT::emit_op_put_global_var): Ditto. Also, removed some irrelevent
1027         loads while I was at it. The global object's "d" pointer never changes
1028         after construction.
1029
1030 2009-06-23  Gavin Barraclough  <barraclough@apple.com>
1031
1032         Reviewed by Sam Weinig.
1033
1034         Remove 'arguments' field from Register union (again).
1035         This time do so without breaking tests (radical, I know).
1036
1037         * interpreter/CallFrame.h:
1038         (JSC::ExecState::optionalCalleeArguments):
1039         (JSC::ExecState::setArgumentCount):
1040         (JSC::ExecState::init):
1041         * interpreter/Interpreter.cpp:
1042         (JSC::Interpreter::dumpRegisters):
1043         (JSC::Interpreter::unwindCallFrame):
1044         (JSC::Interpreter::privateExecute):
1045         (JSC::Interpreter::retrieveArguments):
1046         * interpreter/Register.h:
1047         (JSC::Register::withInt):
1048         (JSC::Register::):
1049         (JSC::Register::Register):
1050         (JSC::Register::i):
1051         * jit/JITStubs.cpp:
1052         (JSC::JITStubs::cti_op_tear_off_arguments):
1053         * runtime/Arguments.h:
1054         (JSC::JSActivation::copyRegisters):
1055         (JSC::Register::arguments):
1056         * runtime/JSActivation.cpp:
1057         (JSC::JSActivation::argumentsGetter):
1058         * runtime/JSActivation.h:
1059
1060 2009-06-23  Geoffrey Garen  <ggaren@apple.com>
1061
1062         Reviewed by Sam Weinig.
1063         
1064         Removed some result register tracking cruft in preparation for a new
1065         result tracking mechanism.
1066         
1067         SunSpider reports no change.
1068
1069         * assembler/AbstractMacroAssembler.h:
1070         * assembler/X86Assembler.h:
1071         (JSC::X86Assembler::JmpDst::JmpDst): No need to track jump targets in
1072         machine code; we already do this in bytecode.
1073
1074         * jit/JIT.cpp:
1075         (JSC::JIT::JIT):
1076         (JSC::JIT::emitTimeoutCheck): Make sure to save and restore the result
1077         registers, so an opcode with a timeout check can still benefit from result
1078         register caching.
1079
1080         (JSC::JIT::privateCompileMainPass):
1081         (JSC::JIT::privateCompileSlowCases): Removed calls to killLastResultRegister()
1082         in preparation for something new.
1083
1084         * jit/JIT.h:
1085         * jit/JITArithmetic.cpp:
1086         (JSC::JIT::emit_op_jnless):
1087         (JSC::JIT::emit_op_jnlesseq):
1088         * jit/JITInlineMethods.h:
1089         (JSC::JIT::emitGetFromCallFrameHeaderPtr):
1090         (JSC::JIT::emitGetFromCallFrameHeader32):
1091         * jit/JITOpcodes.cpp:
1092         (JSC::JIT::emit_op_jmp):
1093         (JSC::JIT::emit_op_jfalse):
1094         (JSC::JIT::emit_op_jtrue):
1095         (JSC::JIT::emit_op_jeq_null):
1096         (JSC::JIT::emit_op_jneq_null):
1097         (JSC::JIT::emit_op_jneq_ptr):
1098         (JSC::JIT::emit_op_jsr):
1099         (JSC::JIT::emit_op_sret):
1100         (JSC::JIT::emit_op_jmp_scopes): ditto
1101
1102         * jit/JITStubCall.h:
1103         (JSC::JITStubCall::JITStubCall):
1104         (JSC::JITStubCall::getArgument): added a mechanism for reloading an argument
1105         you passed to a JIT stub, for use in emitTimeoutCheck.
1106
1107 2009-06-23  Sam Weinig  <sam@webkit.org>
1108
1109         Reviewed by Geoffrey Garen.
1110
1111         Remove now-useless inplace variants of binary ops.
1112
1113         * jit/JIT.h:
1114         * jit/JITArithmetic.cpp:
1115         (JSC::JIT::emit_op_bitand):
1116         (JSC::JIT::emit_op_bitor):
1117         (JSC::JIT::emit_op_bitxor):
1118         (JSC::JIT::emit_op_add):
1119         (JSC::JIT::emit_op_sub):
1120         (JSC::JIT::emit_op_mul):
1121
1122 2009-06-23  Sam Weinig  <sam@webkit.org>
1123
1124         Reviewed by Geoffrey Garen.
1125
1126         Move off memory operands to aid in re-enabling result caching.
1127
1128         - No regression measured.
1129
1130         * jit/JIT.h:
1131         * jit/JITArithmetic.cpp:
1132         (JSC::JIT::emit_op_negate):
1133         (JSC::JIT::emit_op_jnless):
1134         (JSC::JIT::emit_op_jnlesseq):
1135         (JSC::JIT::emit_op_lshift):
1136         (JSC::JIT::emit_op_rshift):
1137         (JSC::JIT::emit_op_bitand):
1138         (JSC::JIT::emitBitAnd32Constant):
1139         (JSC::JIT::emitBitAnd32InPlace):
1140         (JSC::JIT::emit_op_bitor):
1141         (JSC::JIT::emitBitOr32Constant):
1142         (JSC::JIT::emitBitOr32InPlace):
1143         (JSC::JIT::emit_op_bitxor):
1144         (JSC::JIT::emitBitXor32Constant):
1145         (JSC::JIT::emitBitXor32InPlace):
1146         (JSC::JIT::emit_op_bitnot):
1147         (JSC::JIT::emit_op_post_inc):
1148         (JSC::JIT::emit_op_post_dec):
1149         (JSC::JIT::emit_op_pre_inc):
1150         (JSC::JIT::emitSlow_op_pre_inc):
1151         (JSC::JIT::emit_op_pre_dec):
1152         (JSC::JIT::emitSlow_op_pre_dec):
1153         (JSC::JIT::emit_op_add):
1154         (JSC::JIT::emitAdd32Constant):
1155         (JSC::JIT::emitAdd32InPlace):
1156         (JSC::JIT::emitSlow_op_add):
1157         (JSC::JIT::emitSlowAdd32Constant):
1158         (JSC::JIT::emit_op_sub):
1159         (JSC::JIT::emitSlow_op_sub):
1160         (JSC::JIT::emitSub32ConstantLeft):
1161         (JSC::JIT::emitSub32ConstantRight):
1162         (JSC::JIT::emitSub32InPlaceLeft):
1163         (JSC::JIT::emitSub32InPlaceRight):
1164         (JSC::JIT::emitBinaryDoubleOp):
1165         (JSC::JIT::emit_op_mul):
1166         (JSC::JIT::emitMul32InPlace):
1167         (JSC::JIT::emit_op_div):
1168         (JSC::JIT::emit_op_mod):
1169         * jit/JITCall.cpp:
1170         (JSC::JIT::compileOpCallVarargs):
1171         * jit/JITOpcodes.cpp:
1172         (JSC::JIT::emit_op_loop_if_less):
1173         (JSC::JIT::emit_op_loop_if_lesseq):
1174         (JSC::JIT::emit_op_instanceof):
1175         (JSC::JIT::emit_op_to_primitive):
1176         (JSC::JIT::emit_op_not):
1177         (JSC::JIT::emit_op_jneq_ptr):
1178         (JSC::JIT::emit_op_eq):
1179         (JSC::JIT::emit_op_neq):
1180         (JSC::JIT::emit_op_to_jsnumber):
1181         * jit/JITPropertyAccess.cpp:
1182         (JSC::JIT::emit_op_get_by_val):
1183         (JSC::JIT::emit_op_put_by_val):
1184
1185 2009-06-23  Geoffrey Garen  <ggaren@apple.com>
1186
1187         Reviewed by Sam Weinig.
1188         
1189         Fixed some missing and/or misplaced labels in bytecode generation, so
1190         we don't have to work around them in JIT code generation.
1191
1192         * bytecompiler/BytecodeGenerator.cpp:
1193         (JSC::BytecodeGenerator::emitJumpSubroutine):
1194         * parser/Nodes.cpp:
1195         (JSC::TryNode::emitBytecode):
1196
1197 2009-06-22  Geoffrey Garen  <ggaren@apple.com>
1198
1199         Reviewed by Sam Weinig.
1200         
1201         For member function calls, emit "this" directly into the "this" slot
1202         for the function call, instead of moving it there later. This reduces
1203         time spent in op_mov during certain calls, like "a.b.c()".
1204         
1205         1%-2% speedup on v8, mostly richards and delta-blue.
1206
1207         * parser/Nodes.cpp:
1208         (JSC::FunctionCallDotNode::emitBytecode):
1209
1210 2009-06-22  Gavin Barraclough  <barraclough@apple.com>
1211
1212         Reviewed by Sam Weinig.
1213
1214         Remove 'arguments' field from Register union.  Having JSCell derived types in the union is
1215         dangerous since it opens the possibility for the field to be written as a raw pointer but
1216         then read as a JSValue.  This will lead to statle data being read for the tag, which may
1217         be dangerous.  Having removed Arguments* types form Register, all arguments objects must
1218         always explicitly be stored in the register file as JSValues.
1219
1220         * interpreter/CallFrame.h:
1221         (JSC::ExecState::optionalCalleeArguments):
1222         * interpreter/Interpreter.cpp:
1223         (JSC::Interpreter::unwindCallFrame):
1224         (JSC::Interpreter::privateExecute):
1225         (JSC::Interpreter::retrieveArguments):
1226         * interpreter/Register.h:
1227         (JSC::Register::):
1228         * jit/JITStubs.cpp:
1229         (JSC::JITStubs::cti_op_tear_off_arguments):
1230         * runtime/Arguments.h:
1231         (JSC::JSActivation::copyRegisters):
1232         * runtime/JSActivation.cpp:
1233         (JSC::JSActivation::argumentsGetter):
1234         * runtime/JSActivation.h:
1235
1236 2009-06-03  Sam Weinig  <sam@webkit.org>
1237
1238         Reviewed by Geoffrey Garen.
1239
1240         Add back known this value optimization by abstracting
1241         slow case if not JSCell jumps.
1242
1243         * jit/JIT.h:
1244         * jit/JITCall.cpp:
1245         (JSC::JIT::compileOpCallVarargs):
1246         (JSC::JIT::compileOpCallVarargsSlowCase):
1247         (JSC::JIT::compileOpCall):
1248         (JSC::JIT::compileOpCallSlowCase):
1249         * jit/JITInlineMethods.h:
1250         (JSC::JIT::emitJumpSlowCaseIfNotJSCell):
1251         (JSC::JIT::linkSlowCaseIfNotJSCell):
1252         * jit/JITOpcodes.cpp:
1253         (JSC::JIT::emit_op_instanceof):
1254         (JSC::JIT::emitSlow_op_instanceof):
1255         * jit/JITPropertyAccess.cpp:
1256         (JSC::JIT::emit_op_get_by_val):
1257         (JSC::JIT::emitSlow_op_get_by_val):
1258         (JSC::JIT::emit_op_put_by_val):
1259         (JSC::JIT::emitSlow_op_put_by_val):
1260         (JSC::JIT::emit_op_get_by_id):
1261         (JSC::JIT::emitSlow_op_get_by_id):
1262         (JSC::JIT::emit_op_put_by_id):
1263         (JSC::JIT::emitSlow_op_put_by_id):
1264
1265 2009-06-01  Geoffrey Garen  <ggaren@apple.com>
1266
1267         Reviewed by Sam Weinig.
1268         
1269         Fixed some of the regression in crypto-aes.js. (8.5% speedup in
1270         crypto-aes.js.)
1271         
1272         SunSpider reports no change overall.
1273         
1274         Division was producing double results, which took the slow path through
1275         array access code.
1276         
1277         Strangely, all my attempts at versions of this patch that modified array
1278         access code to accept ints encoded as doubles along the fast or slow paths
1279         were regressions. So I did this instead.
1280
1281         * jit/JITArithmetic.cpp:
1282         (JSC::JIT::emit_op_div): When dividing an int by an int, go ahead and try
1283         to turn the result into an int. Don't just do int division, though, because
1284         testing shows it to be slower than SSE double division, and the corner
1285         cases are pretty complicated / lengthy on top of that. Also, don't try
1286         to canonicalize division of known tiny numerators into ints, since that's a
1287         waste of time.
1288
1289 2009-05-26  Geoffrey Garen  <ggaren@apple.com>
1290
1291         Reviewed by Oliver Hunt.
1292         
1293         Fixed a regression caused by my recent fix for NaN.
1294
1295         * jit/JITArithmetic.cpp:
1296         (JSC::JIT::emitBinaryDoubleOp): Actually do the comparison in reverse
1297         order, like the ChangeLog said we would, bokay?
1298
1299 2009-05-26  Geoffrey Garen  <ggaren@apple.com>
1300
1301         Reviewed by Sam Weinig and Oliver Hunt.
1302         
1303         Fixed two edge cases in %:
1304         
1305         - Don't do -2147483648 % x as a fast case, since you might do -2147483648 % -1,
1306         which will signal a hardware exception due to overflow.
1307
1308         - In the case of a zero remainder, be sure to store negative zero if the
1309         dividend was zero.
1310         
1311         SunSpider reports no change.
1312
1313         * jit/JITArithmetic.cpp:
1314         (JSC::JIT::emit_op_mod):
1315         (JSC::JIT::emitSlow_op_mod):
1316
1317 2009-05-25  Geoffrey Garen  <ggaren@apple.com>
1318
1319         Reviewed by Maciej Stachowiak.
1320         
1321         Fixed a regression when comparing to NaN.
1322
1323         * jit/JITArithmetic.cpp:
1324         (JSC::JIT::emitBinaryDoubleOp): For op_jnless and op_jnless_eq, do the
1325         comparison in reverse order, and jump if the result is below or 
1326         below-or-equal. This ensures that we do jump in the case of NaN.
1327
1328 2009-05-25  Geoffrey Garen  <ggaren@apple.com>
1329
1330         Reviewed by Oliver Hunt.
1331         
1332         SunSpider says no change.
1333         
1334         Fixed regressions in fast/js/var-declarations-shadowing.html and
1335         fast/js/equality.html, caused by recent == and != optimizations.
1336
1337         * jit/JITStubs.cpp:
1338         (JSC::JITStubs::cti_op_eq): Don't treat "compare to string" as always
1339         numeric or string comparison. If the second operand is an object, you
1340         need to ToPrimitive it, and start all over again. Also, I wrote out each
1341         of the possible cases explicitly, to cut down on redundant branching.
1342
1343 2009-05-25  Sam Weinig  <sam@webkit.org>
1344
1345         Reviewed by Mark Rowe.
1346
1347         Fix bug in fast/js/constant-folding.html where we were not negating
1348         -0 properly.
1349
1350         * jit/JITArithmetic.cpp:
1351         (JSC::JIT::emit_op_negate):
1352
1353 2009-05-23  Geoffrey Garen  <ggaren@apple.com>
1354
1355         Reviewed by Oliver Hunt.
1356         
1357         Refactored new slow case codegen for == and !=.
1358         
1359         SunSpider reports no change, maybe a tiny speedup.
1360
1361         * jit/JITOpcodes.cpp:
1362         (JSC::JIT::emitSlow_op_eq):
1363         (JSC::JIT::emitSlow_op_neq): Made a vptr comparison a *Ptr operation,
1364         instead of *32, to make it portable to 64bit. Reorganized the string
1365         and generic cases to make their control flow a little clearer.
1366
1367 2009-05-23  Geoffrey Garen  <ggaren@apple.com>
1368
1369         Reviewed by Maciej Stachowiak.
1370         
1371         Optimized == and != for our new value representation -- especially for strings.
1372         
1373         14% speedup on date-format-tofte.
1374
1375         * jit/JITOpcodes.cpp:
1376         (JSC::JIT::emit_op_eq):
1377         (JSC::JIT::emitSlow_op_eq):
1378         (JSC::JIT::emit_op_neq):
1379         (JSC::JIT::emitSlow_op_neq):
1380         * jit/JITStubCall.h:
1381         (JSC::JITStubCall::JITStubCall):
1382         * jit/JITStubs.cpp:
1383         (JSC::JITStubs::cti_op_eq):
1384         (JSC::JITStubs::cti_op_eq_strings):
1385         (JSC::JITStubs::cti_op_call_eval):
1386         * jit/JITStubs.h:
1387         (JSC::):
1388         * runtime/JSValue.h:
1389
1390 2009-05-22  Sam Weinig  <sam@webkit.org>
1391
1392         Reviewed by Gavin Barraclough.
1393
1394         Fix non-SSE enabled builds.
1395
1396         * jit/JITArithmetic.cpp:
1397         (JSC::JIT::emitSlow_op_add): Don't early return here, we still need to call the JIT stub.
1398         (JSC::JIT::emitSlow_op_sub): Ditto.
1399
1400 2009-05-22  Geoffrey Garen  <ggaren@apple.com>
1401
1402         Reviewed by Sam Weinig.
1403         
1404         Here's a thought: let's not take a jit stub call just to multiply by 1,
1405         bokay?
1406         
1407         imul doesn't set the zero flag, so to test for a zero result, we need
1408         an explicit instruction. (Luckily, it does set the overflow flag, so
1409         we can still use that.)
1410
1411         * jit/JIT.h:
1412         * jit/JITArithmetic.cpp:
1413         (JSC::JIT::emit_op_mul):
1414         (JSC::JIT::emitSlow_op_mul):
1415         (JSC::JIT::emitMul32InPlace):
1416
1417 2009-05-22  Sam Weinig  <sam@webkit.org>
1418
1419         Reviewed by Geoffrey "Premature Commit" Garen.
1420
1421         Add back constant integer cases for op_add.
1422
1423         * jit/JIT.h:
1424         * jit/JITArithmetic.cpp:
1425         (JSC::JIT::emit_op_add):
1426         (JSC::JIT::emitAdd32Constant):
1427         (JSC::JIT::emitSlow_op_add):
1428         (JSC::JIT::emitSlowAdd32Constant):
1429         * jit/JITInlineMethods.h:
1430         (JSC::JIT::getConstantOperandImmediateDouble):
1431         (JSC::JIT::isOperandConstantImmediateDouble):
1432
1433 2009-05-22  Geoffrey Garen  <ggaren@apple.com>
1434
1435         Reviewed by Sam Weinig.
1436         
1437         Added fast double cases for op_jnless and op_jnlesseq.
1438
1439         * assembler/AbstractMacroAssembler.h:
1440         (JSC::AbstractMacroAssembler::JumpList::jumps): New accesor, used by
1441         addSlowCase.
1442
1443         * assembler/X86Assembler.h:
1444         (JSC::X86Assembler::ucomisd_rm): New method for comparing register to
1445         memory.
1446
1447         * jit/JIT.h:
1448         * jit/JITArithmetic.cpp:
1449         (JSC::JIT::emit_op_jnless):
1450         (JSC::JIT::emitSlow_op_jnless):
1451         (JSC::JIT::emit_op_jnlesseq):
1452         (JSC::JIT::emitSlow_op_jnlesseq):
1453         (JSC::JIT::emit_op_add):
1454         (JSC::JIT::emit_op_sub):
1455         (JSC::JIT::emitBinaryDoubleOp):
1456         (JSC::JIT::emit_op_mul):
1457         (JSC::JIT::emit_op_div): Modified emitBinaryDoubleOp to accept comparison/jump
1458         operations in addition to operations with explicit result registers.
1459
1460         * jit/JITInlineMethods.h:
1461         (JSC::JIT::addSlowCase): Added an "addSlowCase" for JumpLists, so clients
1462         can track multiple jumps to the same slow case condition together.
1463
1464 2009-05-21  Sam Weinig  <sam@webkit.org>
1465
1466         Reviewed by Gavin Barraclough.
1467
1468         Implement op_negate inline fast cases.
1469
1470         * assembler/MacroAssemblerX86Common.h:
1471         (JSC::MacroAssemblerX86Common::neg32):
1472         * assembler/X86Assembler.h:
1473         (JSC::X86Assembler::):
1474         (JSC::X86Assembler::negl_m):
1475         (JSC::X86Assembler::xorpd_rr):
1476         * jit/JIT.cpp:
1477         (JSC::JIT::privateCompileMainPass):
1478         (JSC::JIT::privateCompileSlowCases):
1479         * jit/JIT.h:
1480         * jit/JITArithmetic.cpp:
1481         (JSC::JIT::emit_op_negate):
1482         (JSC::JIT::emitSlow_op_negate):
1483
1484 2009-05-20  Sam Weinig  <sam@webkit.org>
1485
1486         Reviewed by Gavin Barraclough.
1487
1488         Update the patchOffsetGetByIdSlowCaseCall constant for the
1489         case that OPCODE_SAMPLING is enabled.
1490
1491         * jit/JIT.h:
1492
1493 2009-05-20  Geoffrey Garen  <ggaren@apple.com>
1494
1495         Reviewed by Sam Weinig.
1496
1497         Added support for inline subtraction of doubles.
1498
1499         * jit/JITArithmetic.cpp:
1500         (JSC::JIT::emit_op_sub):
1501         (JSC::JIT::emitSlow_op_sub):
1502         (JSC::JIT::emitSlowSub32InPlaceLeft):
1503         (JSC::JIT::emitBinaryDoubleOp):
1504
1505 2009-05-20  Sam Weinig  <sam@webkit.org>
1506
1507         Reviewed by Geoffrey Garen.
1508
1509         Added support for inline division.
1510
1511         * assembler/X86Assembler.h:
1512         (JSC::X86Assembler::):
1513         (JSC::X86Assembler::divsd_rr):
1514         (JSC::X86Assembler::divsd_mr):
1515         * bytecode/CodeBlock.cpp:
1516         (JSC::CodeBlock::dump):
1517         * bytecode/Opcode.h:
1518         * bytecompiler/BytecodeGenerator.cpp:
1519         (JSC::BytecodeGenerator::emitBinaryOp):
1520         * interpreter/Interpreter.cpp:
1521         (JSC::Interpreter::privateExecute):
1522         * jit/JIT.cpp:
1523         (JSC::JIT::privateCompileMainPass):
1524         (JSC::JIT::privateCompileSlowCases):
1525         * jit/JIT.h:
1526         * jit/JITArithmetic.cpp:
1527         (JSC::JIT::emitBinaryDoubleOp):
1528         (JSC::JIT::emit_op_div):
1529         (JSC::JIT::emitSlow_op_div):
1530
1531 2009-05-20  Geoffrey Garen  <ggaren@apple.com>
1532
1533         Reviewed by Sam Weinig.
1534
1535         Added support for inline addition of doubles.
1536
1537         * jit/JITArithmetic.cpp:
1538         (JSC::JIT::emit_op_add):
1539         (JSC::JIT::emitSlow_op_add):
1540         (JSC::JIT::emitSlowAdd32InPlace):
1541         (JSC::JIT::emitBinaryDoubleOp):
1542         (JSC::JIT::emit_op_mul):
1543         (JSC::JIT::emitSlow_op_mul):
1544
1545 2009-05-20  Geoffrey Garen  <ggaren@apple.com>
1546
1547         Reviewed by Sam Weinig.
1548         
1549         Factored inline double operations into a helper function, so that we
1550         can reuse this code for other math operations.
1551
1552         * jit/JIT.h:
1553         * jit/JITArithmetic.cpp:
1554         (JSC::JIT::emitBinaryDoubleOp):
1555         (JSC::JIT::emit_op_mul):
1556         * jit/JITCall.cpp:
1557         (JSC::JIT::compileOpCallInitializeCallFrame):
1558
1559 2009-05-20  Geoffrey Garen  <ggaren@apple.com>
1560
1561         Reviewed by Sam Weinig.
1562         
1563         Added support for inline multiplication of doubles.
1564
1565         * assembler/X86Assembler.h:
1566         (JSC::X86Assembler::cvtsi2sd_mr): New function, useful for loading an
1567         int32 into a double register.
1568
1569         * jit/JITArithmetic.cpp:
1570         (JSC::JIT::emit_op_mul):
1571         (JSC::JIT::emitSlow_op_mul): Filled out these cases for double arithmetic.
1572
1573         * jit/JIT.h:
1574         * jit/JITInlineMethods.h:
1575         (JSC::JIT::addressFor): New function, useful for addressing a JSValue's
1576         full 64bits as a double.
1577
1578 2009-05-19  Sam Weinig  <sam@webkit.org>
1579
1580         Reviewed by Geoffrey Garen.
1581
1582         Implement and enable optimized calls.
1583
1584         * jit/JIT.cpp:
1585         (JSC::JIT::privateCompileCTIMachineTrampolines): Add ENABLE(JIT_OPTIMIZE_CALL) guards
1586         around the the optimize call only trampolines (virtualCallPreLink and virtualCallLink).
1587         Update the trampolines to account for the new JSValue representation.
1588         (JSC::JIT::unlinkCall): Use NULL instead of JSValue noValue. 
1589
1590         * jit/JITCall.cpp:
1591         (JSC::JIT::compileOpCall): Update to account for the new JSValue representation
1592         (JSC::JIT::compileOpCallSlowCase): Ditto.
1593
1594         * jit/JITStubs.h: Remove incorrect !ENABLE(JIT_OPTIMIZE_CALL) guard.
1595
1596         * wtf/Platform.h: Enable ENABLE_JIT_OPTIMIZE_CALL.
1597
1598 2009-05-19  Sam Weinig  <sam@webkit.org>
1599
1600         Reviewed by Geoffrey Garen.
1601
1602         Implement and enable optimized property access.
1603
1604         * assembler/AbstractMacroAssembler.h: Fix comment.
1605         * jit/JIT.cpp:
1606         (JSC::JIT::privateCompileCTIMachineTrampolines): Remove array length trampoline
1607         and implement the string length trampoline.
1608         * jit/JIT.h: Add new constants for patch offsets.
1609         * jit/JITInlineMethods.h: Remove FIELD_OFFSET which is now in StdLibExtras.h.
1610         * jit/JITPropertyAccess.cpp: 
1611         (JSC::JIT::emit_op_get_by_id):
1612         (JSC::JIT::emitSlow_op_get_by_id):
1613         (JSC::JIT::emit_op_put_by_id):
1614         (JSC::JIT::emitSlow_op_put_by_id):
1615         (JSC::JIT::compilePutDirectOffset):
1616         (JSC::JIT::compileGetDirectOffset):
1617         (JSC::JIT::privateCompilePutByIdTransition):
1618         (JSC::JIT::patchGetByIdSelf):
1619         (JSC::JIT::patchPutByIdReplace):
1620         (JSC::JIT::privateCompilePatchGetArrayLength):
1621         (JSC::JIT::privateCompileGetByIdProto):
1622         (JSC::JIT::privateCompileGetByIdSelfList):
1623         (JSC::JIT::privateCompileGetByIdProtoList):
1624         (JSC::JIT::privateCompileGetByIdChainList):
1625         (JSC::JIT::privateCompileGetByIdChain):
1626         * jit/JITStubCall.h:
1627         (JSC::JITStubCall::addArgument): Add version of addArgument that takes
1628         two registers for the tag and payload.
1629         * jit/JITStubs.cpp:
1630         (JSC::JITStubs::JITStubs): Remove array length trampoline pointer.
1631         (JSC::JITStubs::cti_op_get_by_id_self_fail): 
1632         * jit/JITStubs.h:
1633         * runtime/JSObject.h:
1634         (JSC::JSObject::JSObject): Move m_inheritorID below the property storage
1635         to align it to a 16 byte boundary.
1636         * wtf/Platform.h: Enable ENABLE_JIT_OPTIMIZE_PROPERTY_ACCESS
1637         * wtf/StdLibExtras.h: Move FIELD_OFFSET here.
1638
1639 2009-05-17  Sam Weinig  <sam@webkit.org>
1640
1641         Reviewed by Geoffrey Garen.
1642
1643         Remove unneeded ExecState parameter from the number JSValue constructors.
1644
1645         * runtime/JSValue.h:
1646         (JSC::jsNumber):
1647         (JSC::jsNaN):
1648         (JSC::JSValue::JSValue):
1649
1650 2009-05-15  Sam Weinig  <sam@webkit.org>
1651
1652         Reviewed by Geoffrey Garen.
1653
1654         Implemented fast path for op_put_by_val when putting to arrays.
1655
1656         * jit/JITPropertyAccess.cpp:
1657         (JSC::JIT::emit_op_put_by_val):
1658         (JSC::JIT::emitSlow_op_put_by_val):
1659
1660 2009-05-15  Geoffrey Garen  <ggaren@apple.com> (Mostly by Sam)
1661
1662         Reviewed by Sam Weinig.
1663         
1664         Implemented fast path for op_get_by_val when accessing array.
1665
1666         * jit/JIT.cpp:
1667         * jit/JITPropertyAccess.cpp:
1668         (JSC::JIT::emit_op_get_by_val):
1669         (JSC::JIT::emitSlow_op_get_by_val):
1670
1671 2009-05-14  Geoffrey Garen  <ggaren@apple.com>
1672
1673         Reviewed by Sam Weinig.
1674         
1675         Fixed a failure in fast/js/math-transforms.html caused by failing to
1676         preserve -0 in multiplication.
1677
1678         * assembler/X86Assembler.h:
1679         (JSC::X86Assembler::jz):
1680         * jit/JITArithmetic.cpp:
1681         (JSC::JIT::emit_op_mul):
1682         (JSC::JIT::emitSlow_op_mul):
1683         (JSC::JIT::emitMul32Constant):
1684         (JSC::JIT::emitMul32InPlace): Check both for overflow and for zero when
1685         doing multiplication. Use a slow case to get these right.
1686
1687 2009-05-14  Geoffrey Garen  <ggaren@apple.com>
1688
1689         Reviewed by Sam Weinig.
1690         
1691         Fixed a bug in the varargs calling convention.
1692
1693         * jit/JITCall.cpp:
1694         (JSC::JIT::compileOpCallVarargs): Move the argument count into regT1,
1695         since that's where ctiVirtualCall expects it to be.
1696
1697 2009-05-14  Geoffrey Garen  <ggaren@apple.com>
1698
1699         Reviewed by Sam Weinig.
1700
1701         Fixed a small bug in instanceof's looping code.
1702
1703         * jit/JITOpcodes.cpp:
1704         (JSC::JIT::emit_op_instanceof): NULL means the object has no prototype,
1705         so only loop when *not* equal to NULL.
1706
1707 2009-05-14  Geoffrey Garen  <ggaren@apple.com>
1708
1709         Reviewed by Sam Weinig.
1710         
1711         Fixed a small bug in instanceof's result writing code.
1712
1713         * jit/JITOpcodes.cpp:
1714         (JSC::JIT::emit_op_instanceof): Make sure to fill out the payload bits
1715         in all cases.
1716
1717 2009-05-14  Sam Weinig  <sam@webkit.org>
1718
1719         Reviewed by Geoffrey Garen.
1720
1721         Removed an invalid assertion in cti_op_urshift which
1722         depended on a fast path for op_urshift which has
1723         never existed.
1724
1725         * jit/JITStubs.cpp:
1726         (JSC::JITStubs::cti_op_urshift):
1727
1728 2009-05-14  Geoffrey Garen  <ggaren@apple.com>
1729
1730         Reviewed by Sam Weinig.
1731         
1732         Fixed loop_if_true, which had the same reversed test that jtrue had.
1733
1734         * jit/JITOpcodes.cpp:
1735         (JSC::JIT::emit_op_loop_if_true):
1736
1737 2009-05-14  Sam Weinig  <sam@webkit.org>
1738
1739         Reviewed by Geoffrey Garen.
1740
1741         In op_neq, we apparently want to check that one value
1742         does *not* equal another.  Go figure.
1743
1744         * jit/JITOpcodes.cpp:
1745         (JSC::JIT::emit_op_neq):
1746
1747 2009-05-14  Sam Weinig  <sam@webkit.org>
1748
1749         Reviewed by Geoffrey Garen.
1750
1751         The slow case of op_mod should call op_mod's jit stub,
1752         not op_mul.  That would be dumb.
1753
1754         * jit/JITArithmetic.cpp:
1755         (JSC::JIT::emitSlow_op_mod):
1756
1757 2009-05-14  Geoffrey Garen  <ggaren@apple.com>
1758
1759         Reviewed by Sam Weinig.
1760         
1761         Fixed problems when using 'arguments' due to a half-initialized register.
1762
1763         * interpreter/CallFrame.h:
1764         (JSC::ExecState::setCalleeArguments):
1765         (JSC::ExecState::init): Require a full JSValue when setting up the 
1766         'arguments' virtual register, since this register is accessible from JIT
1767         code and bytecode, and needs to be a true JSValue.
1768
1769         * interpreter/CallFrameClosure.h:
1770         (JSC::CallFrameClosure::resetCallFrame): ditto
1771
1772         * interpreter/Interpreter.cpp:
1773         (JSC::Interpreter::privateExecute): ditto
1774
1775         * interpreter/Register.h: Removed the constructor that allowed assignment
1776         of a JSArguments* to a register. That is not safe. See above.
1777
1778         * jit/JITStubs.cpp:
1779         (JSC::JITStubs::cti_op_create_arguments):
1780         (JSC::JITStubs::cti_op_create_arguments_no_params): ditto
1781
1782 2009-05-14  Sam Weinig  <sam@webkit.org>
1783
1784         Reviewed by Geoffrey Garen.
1785
1786         We really want to go to the slow case in op_jfalse and
1787         op_jtrue if the value is *not* boolean. 
1788
1789         * jit/JITOpcodes.cpp:
1790         (JSC::JIT::emit_op_jfalse):
1791         (JSC::JIT::emit_op_jtrue):
1792
1793 2009-05-14  Sam Weinig  <sam@webkit.org>
1794
1795         Reviewed by Geoffrey Garen.
1796
1797         Flipped the condition when emitting a an op_loop_if_less or op_loop_if_lesseq
1798         if the first operand is a constant.
1799
1800         * jit/JITOpcodes.cpp:
1801         (JSC::JIT::emit_op_loop_if_less):
1802         (JSC::JIT::emit_op_loop_if_lesseq):
1803
1804 2009-05-14  Sam Weinig  <sam@webkit.org>
1805
1806         Reviewed by Geoffrey Garen.
1807
1808         Added missing return in op_jnless and op_jnlesseq. 
1809
1810         * jit/JITArithmetic.cpp:
1811         (JSC::JIT::emit_op_jnless):
1812         (JSC::JIT::emit_op_jnlesseq):
1813
1814 2009-05-14  Sam Weinig  <sam@webkit.org>
1815
1816         Reviewed by Geoffrey Garen.
1817
1818         Load constants into the the register file as a temporary measure to
1819         aid bring up.  This allows us to use to treat constants like any
1820         other virtual register.
1821
1822         * jit/JITOpcodes.cpp:
1823         (JSC::JIT::emit_op_enter):
1824         (JSC::JIT::emit_op_enter_with_activation):
1825
1826 2009-05-14  Geoffrey Garen  <ggaren@apple.com>
1827
1828         Reviewed by Sam Weinig.
1829         
1830         Implemented op_strict_eq. Original patch by Snowy, by way of Sam and Gavin.
1831
1832         * assembler/MacroAssemblerX86Common.h:
1833         (JSC::MacroAssemblerX86Common::set8): Added set8, since it's slightly
1834         faster than set32, and the new value representation usually doesn't
1835         need set32.
1836
1837         * jit/JIT.cpp:
1838         * jit/JIT.h:
1839         * jit/JITInlineMethods.h:
1840         (JSC::JIT::emitLoadTag):
1841         (JSC::JIT::emitLoadPayload): Added helper functions for dealing with
1842         constants. Eventually, we should write special cases for all constants,
1843         but these are helpful in the short term.
1844
1845         * jit/JITOpcodes.cpp:
1846         (JSC::JIT::compileOpStrictEq):
1847         (JSC::JIT::emitSlow_op_stricteq):
1848         (JSC::JIT::emitSlow_op_nstricteq): teh opcodez.
1849
1850         * runtime/JSValue.h:
1851         (JSC::JSValue::):
1852         (JSC::JSValue::isDouble): Added a LowestTag for clarity.
1853
1854 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1855
1856         Reviewed by Sam Weinig.
1857         
1858         Fixed some bugs in host function calls.
1859         
1860         testapi now passes!
1861
1862         * jit/JIT.cpp: Changed some registers around to avoid overwriting edx:eax,
1863         which is how JSValues are now returned. Also changed the code that
1864         passes thisValue to pass the full 64bits of the value. Also added
1865         an #error compiler directive to other platform builds, since the JSValue
1866         return signature probably won't return in edx:eax on those platforms,
1867         and we'll have to investigate a solution.
1868
1869 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1870
1871         Reviewed by Sam Weinig.
1872         
1873         Removed parameters from functions that are intended never to use their
1874         parameters.
1875
1876         * jit/JITPropertyAccess.cpp:
1877         (JSC::JIT::emitSlow_op_get_by_val):
1878         (JSC::JIT::emitSlow_op_put_by_val):
1879
1880 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1881
1882         Reviewed by Sam Weinig.
1883         
1884         Ported op_instance_of from TOT. It's basically the same, but some register
1885         stuff changed to memory stuff.
1886
1887         * jit/JITInlineMethods.h:
1888         (JSC::JIT::emitPutJITStubArgFromVirtualRegister):
1889         (JSC::JIT::emitStore): Changed to use helper functions.
1890
1891         * jit/JITOpcodes.cpp:
1892         (JSC::JIT::emit_op_instanceof):
1893         (JSC::JIT::emitSlow_op_instanceof): Ported from TOT.
1894
1895 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1896
1897         Reviewed by Gavin Barraclough.
1898         
1899         Added a comment to explain an exception-handling subtelty that we found
1900         hard to remember when reviewing my last patch.
1901
1902         * jit/JITOpcodes.cpp:
1903         (JSC::JIT::emit_op_catch):
1904
1905 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1906
1907         Reviewed by Sam Weinig.
1908         
1909         Implemented try/catch.
1910
1911         * jit/JITOpcodes.cpp:
1912         (JSC::JIT::emit_op_throw): Updated to use JITStackFrame abstraction.
1913         (JSC::JIT::emit_op_catch): Filled out.
1914
1915 2009-05-13  Sam Weinig  <sam@webkit.org>
1916
1917         Reviewed by Geoffrey Garen.
1918
1919         Implemented op_loop_if_true, op_jfalse, op_jtrue, op_jeq_null and op_jneq_null
1920
1921         * jit/JITOpcodes.cpp:
1922         (JSC::JIT::emitSlow_op_instanceof): Moved from below to be next to its
1923         fast brother.
1924
1925         (JSC::JIT::emit_op_loop_if_true): Similar to the old version
1926         in that it tries to do the integer case first and reduce the
1927         number of jumps you might need to take.
1928         (JSC::JIT::emitSlow_op_loop_if_true):
1929
1930         (JSC::JIT::emit_op_jfalse): Very similar to op_loop_if_true, only
1931         the inverse and without a timeout check.
1932         (JSC::JIT::emitSlow_op_jfalse):
1933
1934         (JSC::JIT::emit_op_jtrue): Very similar to op_loop_if_true except
1935         without the timeout check.
1936         (JSC::JIT::emitSlow_op_jtrue):
1937
1938         (JSC::JIT::emit_op_jeq_null): Very similar to the implementation
1939         of op_eq, except it takes jumps instead of copying the condition
1940         to a dst.
1941         (JSC::JIT::emit_op_jneq_null): Ditto but for op_neq.
1942
1943 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1944
1945         Reviewed by Sam Weinig.
1946         
1947         Implemented op_call_varargs.
1948
1949         * jit/JITCall.cpp:
1950         (JSC::JIT::compileOpCallVarargsSetupArgs):
1951         (JSC::JIT::compileOpCallVarargs):
1952         (JSC::JIT::emit_op_call):
1953         (JSC::JIT::emit_op_call_eval):
1954         (JSC::JIT::emit_op_load_varargs):
1955         (JSC::JIT::emit_op_call_varargs):
1956         (JSC::JIT::emit_op_construct):
1957         * jit/JITOpcodes.cpp:
1958         (JSC::JIT::emit_op_jneq_ptr):
1959
1960 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1961
1962         Reviewed by Sam Weinig.
1963         
1964         Implemented op_call_eval.
1965
1966         * jit/JITCall.cpp:
1967         (JSC::JIT::compileOpCallVarargsSetupArgs):
1968         (JSC::JIT::compileOpCall):
1969         * jit/JITStubCall.h:
1970         (JSC::CallEvalJITStub::CallEvalJITStub):
1971
1972 2009-05-13  Sam Weinig  <sam@webkit.org>
1973
1974         Reviewed by Gavin Barraclough.
1975
1976         Implemented op_not. (Gavin did most of the work!)
1977
1978         * jit/JITOpcodes.cpp:
1979         (JSC::JIT::emit_op_not):
1980         (JSC::JIT::emitSlow_op_not):
1981
1982 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
1983
1984         Reviewed by Sam Weinig.
1985         
1986         Implemented op_global_resolve.
1987
1988         * jit/JITOpcodes.cpp:
1989         (JSC::JIT::emit_op_loop_if_less):
1990         (JSC::JIT::emit_op_loop_if_lesseq): Added back accidentally removed
1991         early returns. 
1992
1993         (JSC::JIT::emit_op_resolve_global):
1994         * jit/JITStubs.cpp:
1995         (JSC::JITStubs::cti_op_resolve_global): Pretty similar to the old code,
1996         but we need two reads and a TimesEight step in order to account for the
1997         64bit value size.
1998
1999         * jit/JITStubs.h:
2000         (JSC::): Slightly tweaked this code to specialize for a JSGlobalObject*,
2001         to avoid having to pass an irrelevant tag pointer to the stub.
2002
2003 2009-05-13  Sam Weinig  <sam@webkit.org>
2004
2005         Reviewed by Geoffrey Garen.
2006
2007         Implemented op_to_jsnumber.
2008
2009         * jit/JITOpcodes.cpp:
2010         (JSC::JIT::emit_op_to_jsnumber):
2011         (JSC::JIT::emitSlow_op_to_jsnumber):
2012
2013 2009-05-13  Sam Weinig  <sam@webkit.org>
2014
2015         Reviewed by Geoffrey Garen.
2016
2017         Implemented op_convert_this.
2018
2019         * jit/JITOpcodes.cpp:
2020         (JSC::JIT::emit_op_convert_this):
2021         (JSC::JIT::emitSlow_op_convert_this):
2022
2023 2009-05-13  Geoffrey Garen  <ggaren@apple.com>
2024
2025         Reviewed by Sam Weinig.
2026         
2027         Got basic JS function and constructor calls working.
2028
2029         * jit/JIT.cpp:
2030         (JSC::JIT::privateCompileCTIMachineTrampolines):
2031         * jit/JIT.h:
2032         * jit/JITCall.cpp:
2033         (JSC::JIT::compileOpCallSetupArgs):
2034         (JSC::JIT::compileOpCallVarargsSetupArgs):
2035         (JSC::JIT::compileOpConstructSetupArgs):
2036         (JSC::JIT::emit_op_ret):
2037         (JSC::JIT::emit_op_construct_verify):
2038         (JSC::JIT::emitSlow_op_construct_verify):
2039         (JSC::JIT::emitSlow_op_call):
2040         (JSC::JIT::emitSlow_op_call_eval):
2041         (JSC::JIT::emitSlow_op_call_varargs):
2042         (JSC::JIT::emitSlow_op_construct):
2043         (JSC::JIT::compileOpCall): Filled out these cases, with call_eval #if'd out.
2044
2045         * jit/JITInlineMethods.h:
2046         (JSC::JIT::emitPutJITStubArgFromVirtualRegister):
2047         (JSC::JIT::emitLoad): Restored some legacy "*CTIArg*" functions,
2048         since I wanted to avoid the complexity of revamping the API here while
2049         trying to bring it up. Eventually, we should re-remove all of these functions.
2050
2051         (JSC::JIT::recordJumpTarget): Removed unnecessary macro cruft. You will
2052         not silence me, Sam Weinig! The world will know that you are a crufty,
2053         crufty, crufty programmer!!!
2054
2055         * jit/JITOpcodes.cpp:
2056         * jit/JITStubs.cpp:
2057         (JSC::):
2058         * jit/JITStubs.h: Changed up some offsets in the JITStackFrame class, since
2059         and off-by-one error was causing stack misalignment.
2060
2061 2009-05-13  Sam Weinig  <sam@webkit.org>
2062
2063         Reviewed by Geoffrey Garen.
2064
2065         Implement op_eq_null and op_neq_null.
2066
2067         * assembler/MacroAssemblerX86Common.h:
2068         (JSC::MacroAssemblerX86Common::set8):
2069         (JSC::MacroAssemblerX86Common::setTest8):
2070         * jit/JITOpcodes.cpp:
2071         (JSC::JIT::emit_op_stricteq):
2072         (JSC::JIT::emitSlow_op_stricteq):
2073         (JSC::JIT::emit_op_nstricteq):
2074         (JSC::JIT::emitSlow_op_nstricteq):
2075         (JSC::JIT::emit_op_eq_null):
2076         (JSC::JIT::emit_op_neq_null):
2077         * jsc.cpp:
2078
2079 2009-05-12  Sam Weinig  <sam@webkit.org>
2080
2081         Reviewed by Geoffrey Garen.
2082
2083         Implement op_new_error.
2084
2085         * jit/JITOpcodes.cpp:
2086         (JSC::JIT::emit_op_new_error):
2087         * jit/JITStubCall.h:
2088         (JSC::JITStubCall::addArgument): Add a version of addArgument
2089         that takes a constant JSValue.
2090
2091 2009-05-12  Sam Weinig  <sam@webkit.org>
2092
2093         Reviewed by Geoffrey Garen.
2094
2095         Remove now unused emitGetVariableObjectRegister and emitPutVariableObjectRegister.
2096
2097         * jit/JIT.cpp:
2098         * jit/JIT.h:
2099
2100 2009-05-12  Sam Weinig  <sam@webkit.org>
2101
2102         Reviewed by Geoffrey Garen.
2103
2104         Implement op_to_primitive and op_next_pname.
2105
2106         * jit/JITOpcodes.cpp:
2107         (JSC::JIT::emitSlow_op_construct_verify):
2108         (JSC::JIT::emit_op_to_primitive):
2109         (JSC::JIT::emitSlow_op_to_primitive):
2110         (JSC::JIT::emitSlow_op_loop_if_true):
2111         (JSC::JIT::emit_op_jtrue):
2112         (JSC::JIT::emit_op_next_pname):
2113
2114 2009-05-12  Sam Weinig  <sam@webkit.org>
2115
2116         Reviewed by Geoffrey Garen.
2117
2118         Add op_get_global_var, op_put_global_var, emit_op_get_scoped_var, emit_op_put_scoped_var and
2119         op_unexpected_load.
2120
2121         * jit/JIT.h:
2122         * jit/JITInlineMethods.h:
2123         (JSC::JIT::tagFor):
2124         (JSC::JIT::payloadFor):
2125         (JSC::JIT::emitLoad):
2126         (JSC::JIT::emitStore):
2127         (JSC::JIT::emitLoadReturnValue):
2128         * jit/JITOpcodes.cpp:
2129         (JSC::JIT::emit_op_get_global_var):
2130         (JSC::JIT::emit_op_put_global_var):
2131         (JSC::JIT::emit_op_get_scoped_var):
2132         (JSC::JIT::emit_op_put_scoped_var):
2133         (JSC::JIT::emit_op_unexpected_load):
2134
2135 2009-05-12  Geoffrey Garen  <ggaren@apple.com>
2136
2137         Reviewed by Sam Weinig.
2138
2139         Added overflow handling to op_sub.
2140
2141         * jit/JIT.h:
2142         * jit/JITArithmetic.cpp:
2143         (JSC::JIT::emitSlow_op_sub):
2144         (JSC::JIT::emitSlowSub32InPlaceLeft):
2145
2146 2009-05-12  Sam Weinig  <sam@webkit.org>
2147
2148         Reviewed by Geoffrey Garen.
2149
2150         Remove a function call by folding op_get_by_id and op_put_by_id into
2151         their respective compile functions.
2152
2153         * jit/JIT.h:
2154         * jit/JITPropertyAccess.cpp:
2155         (JSC::JIT::emit_op_get_by_id):
2156         (JSC::JIT::emitSlow_op_get_by_id):
2157         (JSC::JIT::emit_op_put_by_id):
2158         (JSC::JIT::emitSlow_op_put_by_id):
2159
2160 2009-05-12  Sam Weinig  <sam@webkit.org>
2161
2162         Reviewed by Geoffrey Garen.
2163
2164         Make JITStubCall work in 64bit by making the stack index
2165         step dependent on the size of void*.
2166
2167         * jit/JITStubCall.h:
2168         (JSC::JITStubCall::JITStubCall):
2169         (JSC::JITStubCall::addArgument):
2170
2171 2009-05-12  Sam Weinig  <sam@webkit.org>
2172
2173         Reviewed by Geoffrey Garen.
2174
2175         Implement simple version of property access opcodes
2176         which just call a stub functions.
2177
2178         * jit/JITOpcodes.cpp:
2179         * jit/JITPropertyAccess.cpp:
2180         (JSC::JIT::emitSlow_op_put_by_id):
2181         (JSC::JIT::emitSlow_op_get_by_id):
2182         (JSC::JIT::emit_op_get_by_val):
2183         (JSC::JIT::emitSlow_op_get_by_val):
2184         (JSC::JIT::emit_op_put_by_val):
2185         (JSC::JIT::emitSlow_op_put_by_val):
2186         (JSC::JIT::emit_op_put_by_index):
2187         (JSC::JIT::emit_op_put_getter):
2188         (JSC::JIT::emit_op_put_setter):
2189         (JSC::JIT::emit_op_del_by_id):
2190         (JSC::JIT::compileGetByIdHotPath):
2191         (JSC::JIT::compilePutByIdHotPath):
2192         * jit/JITStubCall.h:
2193         (JSC::JITStubCall::addArgument):
2194         * jsc.cpp:
2195
2196 2009-05-12  Geoffrey Garen  <ggaren@apple.com>
2197
2198         Reviewed by Sam Weinig.
2199         
2200         Added work-around for XCode debugging echo problem.
2201
2202         * jsc.cpp:
2203         (runInteractive):
2204
2205 2009-05-12  Geoffrey Garen  <ggaren@apple.com>
2206
2207         Reviewed by Sam Weinig.
2208         
2209         Added overflow handling to op_add.
2210
2211         * jit/JIT.h:
2212         * jit/JITArithmetic.cpp:
2213         (JSC::JIT::emitSlow_op_add):
2214         (JSC::JIT::emitSlowAdd32InPlace):
2215
2216 2009-05-12  Sam Weinig  <sam@webkit.org>
2217
2218         Reviewed by Geoffrey Garen.
2219
2220         Add slow cases for op_jnless or emit_op_jnlesseq.
2221
2222         * jit/JITArithmetic.cpp:
2223         (JSC::JIT::emitSlow_op_jnless):
2224         (JSC::JIT::emitSlow_op_jnlesseq):
2225
2226 2009-05-12  Sam Weinig  <sam@webkit.org>
2227
2228         Reviewed by Geoffrey Garen.
2229
2230         Add implementations for op_jnless, emit_op_jnlesseq, op_loop_if_less and op_loop_if_lesseq.
2231         No slow cases for op_jnless or emit_op_jnlesseq yet.
2232
2233         * jit/JITArithmetic.cpp:
2234         (JSC::JIT::emit_op_jnless):
2235         (JSC::JIT::emitSlow_op_jnless):
2236         (JSC::JIT::emit_op_jnlesseq):
2237         (JSC::JIT::emitSlow_op_jnlesseq):
2238         * jit/JITOpcodes.cpp:
2239         (JSC::JIT::emit_op_loop_if_less):
2240         (JSC::JIT::emitSlow_op_loop_if_less):
2241         (JSC::JIT::emit_op_loop_if_lesseq):
2242         (JSC::JIT::emitSlow_op_loop_if_lesseq):
2243
2244 2009-05-12  Sam Weinig  <sam@webkit.org>
2245
2246         Reviewed by Geoffrey Garen.
2247
2248         Turn the RECORD_JUMP_TARGET macro into an inline function.
2249
2250         * jit/JIT.h:
2251         * jit/JITInlineMethods.h:
2252         (JSC::JIT::recordJumpTarget):
2253         * jit/JITOpcodes.cpp:
2254         (JSC::JIT::emit_op_jmp):
2255         (JSC::JIT::emit_op_jsr):
2256         (JSC::JIT::emit_op_jmp_scopes):
2257
2258 2009-05-12  Sam Weinig  <sam@webkit.org>
2259
2260         Add MacroAssemblerX86Common::set8 to fix the build.
2261
2262         * assembler/MacroAssemblerX86Common.h:
2263         (JSC::MacroAssemblerX86Common::set8):
2264
2265 2009-05-12  Geoffrey Garen  <ggaren@apple.com>
2266
2267         Reviewed by Sam Weinig.
2268         
2269         Added overflow recovery for pre_inc and pre_dec.
2270         
2271         Turned some short-circuit code into early returns, as is the WebKit style.
2272
2273         * jit/JITArithmetic.cpp:
2274         (JSC::JIT::emit_op_post_inc):
2275         (JSC::JIT::emitSlow_op_post_inc):
2276         (JSC::JIT::emit_op_post_dec):
2277         (JSC::JIT::emitSlow_op_post_dec):
2278         (JSC::JIT::emitSlow_op_pre_inc):
2279         (JSC::JIT::emitSlow_op_pre_dec):
2280
2281 2009-05-12  Sam Weinig  <sam@webkit.org>
2282
2283         Reviewed by Geoffrey Garen.
2284
2285         Implement op_jmp, op_loop, op_eq and op_neq.
2286
2287         * jit/JITOpcodes.cpp:
2288         (JSC::JIT::emit_op_jmp):
2289         (JSC::JIT::emit_op_loop):
2290         (JSC::JIT::emit_op_eq):
2291         (JSC::JIT::emitSlow_op_eq):
2292         (JSC::JIT::emit_op_neq):
2293         (JSC::JIT::emitSlow_op_neq):
2294         (JSC::JIT::emit_op_enter):
2295         (JSC::JIT::emit_op_enter_with_activation):
2296
2297 2009-05-12  Sam Weinig  <sam@webkit.org>
2298
2299         Reviewed by Geoffrey Garen.
2300
2301         Implement the slow cases for arithmetic opcodes.
2302
2303         * jit/JITArithmetic.cpp:
2304         (JSC::JIT::emitSlow_op_lshift):
2305         (JSC::JIT::emitSlow_op_rshift):
2306         (JSC::JIT::emitSlow_op_bitand):
2307         (JSC::JIT::emitSlow_op_bitor):
2308         (JSC::JIT::emitSlow_op_bitxor):
2309         (JSC::JIT::emitSlow_op_bitnot):
2310         (JSC::JIT::emitSlow_op_sub):
2311         (JSC::JIT::emitSlow_op_mul):
2312         (JSC::JIT::emitSlow_op_mod):
2313         (JSC::JIT::emit_op_mod):
2314
2315 2009-05-12  Sam Weinig  <sam@webkit.org>
2316
2317         Reviewed by Geoffrey Garen.
2318
2319         Implement op_bitnot.
2320
2321         * assembler/MacroAssemblerX86Common.h:
2322         (JSC::MacroAssemblerX86Common::not32):
2323         * assembler/X86Assembler.h:
2324         (JSC::X86Assembler::notl_m):
2325         * jit/JITArithmetic.cpp:
2326         (JSC::JIT::emit_op_bitnot):
2327
2328 2009-05-12  Sam Weinig  <sam@webkit.org>
2329
2330         Reviewed by Geoffrey Garen.
2331
2332         Add arithmetic opcode implementations from the old nitro-extreme branch.
2333
2334         * jit/JIT.h:
2335         * jit/JITArithmetic.cpp:
2336         (JSC::JIT::emit_op_jnless):
2337         (JSC::JIT::emitSlow_op_jnless):
2338         (JSC::JIT::emit_op_jnlesseq):
2339         (JSC::JIT::emitSlow_op_jnlesseq):
2340         (JSC::JIT::emit_op_lshift):
2341         (JSC::JIT::emitSlow_op_lshift):
2342         (JSC::JIT::emit_op_rshift):
2343         (JSC::JIT::emitSlow_op_rshift):
2344         (JSC::JIT::emit_op_bitand):
2345         (JSC::JIT::emitBitAnd32Constant):
2346         (JSC::JIT::emitBitAnd32InPlace):
2347         (JSC::JIT::emit_op_bitor):
2348         (JSC::JIT::emitSlow_op_bitor):
2349         (JSC::JIT::emitBitOr32Constant):
2350         (JSC::JIT::emitBitOr32InPlace):
2351         (JSC::JIT::emit_op_bitxor):
2352         (JSC::JIT::emitSlow_op_bitxor):
2353         (JSC::JIT::emitBitXor32Constant):
2354         (JSC::JIT::emitBitXor32InPlace):
2355         (JSC::JIT::emit_op_bitnot):
2356         (JSC::JIT::emitSlow_op_bitnot):
2357         (JSC::JIT::emit_op_post_inc):
2358         (JSC::JIT::emitSlow_op_post_inc):
2359         (JSC::JIT::emit_op_post_dec):
2360         (JSC::JIT::emitSlow_op_post_dec):
2361         (JSC::JIT::emit_op_pre_inc):
2362         (JSC::JIT::emitSlow_op_pre_inc):
2363         (JSC::JIT::emit_op_pre_dec):
2364         (JSC::JIT::emitSlow_op_pre_dec):
2365         (JSC::JIT::emit_op_add):
2366         (JSC::JIT::emitAdd32Constant):
2367         (JSC::JIT::emitAdd32InPlace):
2368         (JSC::JIT::emitSlow_op_add):
2369         (JSC::JIT::emit_op_sub):
2370         (JSC::JIT::emitSlow_op_sub):
2371         (JSC::JIT::emitSub32ConstantLeft):
2372         (JSC::JIT::emitSub32ConstantRight):
2373         (JSC::JIT::emitSub32InPlaceLeft):
2374         (JSC::JIT::emitSub32InPlaceRight):
2375         (JSC::JIT::emit_op_mul):
2376         (JSC::JIT::emitSlow_op_mul):
2377         (JSC::JIT::emitMul32Constant):
2378         (JSC::JIT::emitMul32InPlace):
2379         (JSC::JIT::emit_op_mod):
2380         (JSC::JIT::emitSlow_op_mod):
2381         * jit/JITOpcodes.cpp:
2382
2383 2009-05-12  Geoffrey Garen  <ggaren@apple.com>
2384
2385         Removed JIT_OPTIMIZE_ARITHMETIC setting, since it was all about 32bit
2386         value representations.
2387         
2388         Added JSAPIValueWrapper to the repository.
2389
2390         * jit/JIT.h:
2391         * jit/JITArithmetic.cpp:
2392         * runtime/JSAPIValueWrapper.cpp: Added.
2393         (JSC::JSAPIValueWrapper::toPrimitive):
2394         (JSC::JSAPIValueWrapper::getPrimitiveNumber):
2395         (JSC::JSAPIValueWrapper::toBoolean):
2396         (JSC::JSAPIValueWrapper::toNumber):
2397         (JSC::JSAPIValueWrapper::toString):
2398         (JSC::JSAPIValueWrapper::toObject):
2399         * runtime/JSAPIValueWrapper.h: Added.
2400         (JSC::JSAPIValueWrapper::value):
2401         (JSC::JSAPIValueWrapper::isAPIValueWrapper):
2402         (JSC::JSAPIValueWrapper::JSAPIValueWrapper):
2403         (JSC::jsAPIValueWrapper):
2404         * wtf/Platform.h:
2405
2406 2009-05-12  Geoffrey Garen  <ggaren@apple.com>
2407
2408         Turned on the JIT and got it building and running the most trivial of
2409         programs.
2410         
2411         All configurable optimizations are turned off, and a few opcodes are ad
2412         hoc #if'd out.
2413         
2414         So far, I've only merged op_mov and op_end, but some stub-reliant
2415         opcodes work as-is from TOT.
2416         
2417         * bytecode/CodeBlock.cpp:
2418         (JSC::CodeBlock::~CodeBlock):
2419         * bytecode/CodeBlock.h:
2420         * jit/JIT.cpp:
2421         (JSC::JIT::compileOpStrictEq):
2422         * jit/JIT.h:
2423         * jit/JITArithmetic.cpp:
2424         (JSC::JIT::emit_op_lshift):
2425         (JSC::JIT::emitSlow_op_lshift):
2426         (JSC::JIT::emit_op_rshift):
2427         (JSC::JIT::emitSlow_op_rshift):
2428         (JSC::JIT::emit_op_jnless):
2429         (JSC::JIT::emitSlow_op_jnless):
2430         (JSC::JIT::emit_op_jnlesseq):
2431         (JSC::JIT::emitSlow_op_jnlesseq):
2432         (JSC::JIT::emit_op_bitand):
2433         (JSC::JIT::emitSlow_op_bitand):
2434         (JSC::JIT::emit_op_post_inc):
2435         (JSC::JIT::emitSlow_op_post_inc):
2436         (JSC::JIT::emit_op_post_dec):
2437         (JSC::JIT::emitSlow_op_post_dec):
2438         (JSC::JIT::emit_op_pre_inc):
2439         (JSC::JIT::emitSlow_op_pre_inc):
2440         (JSC::JIT::emit_op_pre_dec):
2441         (JSC::JIT::emitSlow_op_pre_dec):
2442         (JSC::JIT::emit_op_mod):
2443         (JSC::JIT::emitSlow_op_mod):
2444         (JSC::JIT::emit_op_add):
2445         (JSC::JIT::emit_op_mul):
2446         (JSC::JIT::emit_op_sub):
2447         (JSC::JIT::compileBinaryArithOpSlowCase):
2448         (JSC::JIT::emitSlow_op_add):
2449         (JSC::JIT::emitSlow_op_mul):
2450         * jit/JITCall.cpp:
2451         (JSC::JIT::compileOpCallInitializeCallFrame):
2452         (JSC::JIT::compileOpConstructSetupArgs):
2453         (JSC::JIT::compileOpCallVarargs):
2454         (JSC::JIT::compileOpCall):
2455         (JSC::JIT::compileOpCallSlowCase):
2456         * jit/JITInlineMethods.h:
2457         (JSC::JIT::getConstantOperandImmediateInt):
2458         (JSC::JIT::isOperandConstantImmediateInt):
2459         (JSC::JIT::emitInitRegister):
2460         (JSC::JIT::addSlowCase):
2461         (JSC::JIT::addJump):
2462         (JSC::JIT::emitJumpSlowToHot):
2463         (JSC::JIT::tagFor):
2464         (JSC::JIT::payloadFor):
2465         (JSC::JIT::emitLoad):
2466         (JSC::JIT::emitLoadReturnValue):
2467         (JSC::JIT::emitStore):
2468         (JSC::JIT::emitStoreReturnValue):
2469         * jit/JITOpcodes.cpp:
2470         (JSC::JIT::emit_op_mov):
2471         (JSC::JIT::emit_op_end):
2472         (JSC::JIT::emit_op_jmp):
2473         (JSC::JIT::emit_op_loop):
2474         (JSC::JIT::emit_op_loop_if_less):
2475         (JSC::JIT::emit_op_loop_if_lesseq):
2476         (JSC::JIT::emit_op_instanceof):
2477         (JSC::JIT::emit_op_get_global_var):
2478         (JSC::JIT::emit_op_put_global_var):
2479         (JSC::JIT::emit_op_get_scoped_var):
2480         (JSC::JIT::emit_op_put_scoped_var):
2481         (JSC::JIT::emit_op_tear_off_activation):
2482         (JSC::JIT::emit_op_ret):
2483         (JSC::JIT::emit_op_construct_verify):
2484         (JSC::JIT::emit_op_to_primitive):
2485         (JSC::JIT::emit_op_loop_if_true):
2486         (JSC::JIT::emit_op_resolve_global):
2487         (JSC::JIT::emit_op_not):
2488         (JSC::JIT::emit_op_jfalse):
2489         (JSC::JIT::emit_op_jeq_null):
2490         (JSC::JIT::emit_op_jneq_null):
2491         (JSC::JIT::emit_op_jneq_ptr):
2492         (JSC::JIT::emit_op_unexpected_load):
2493         (JSC::JIT::emit_op_eq):
2494         (JSC::JIT::emit_op_bitnot):
2495         (JSC::JIT::emit_op_jtrue):
2496         (JSC::JIT::emit_op_neq):
2497         (JSC::JIT::emit_op_bitxor):
2498         (JSC::JIT::emit_op_bitor):
2499         (JSC::JIT::emit_op_throw):
2500         (JSC::JIT::emit_op_next_pname):
2501         (JSC::JIT::emit_op_push_scope):
2502         (JSC::JIT::emit_op_to_jsnumber):
2503         (JSC::JIT::emit_op_push_new_scope):
2504         (JSC::JIT::emit_op_catch):
2505         (JSC::JIT::emit_op_switch_imm):
2506         (JSC::JIT::emit_op_switch_char):
2507         (JSC::JIT::emit_op_switch_string):
2508         (JSC::JIT::emit_op_new_error):
2509         (JSC::JIT::emit_op_eq_null):
2510         (JSC::JIT::emit_op_neq_null):
2511         (JSC::JIT::emit_op_convert_this):
2512         (JSC::JIT::emit_op_profile_will_call):
2513         (JSC::JIT::emit_op_profile_did_call):
2514         (JSC::JIT::emitSlow_op_construct_verify):
2515         (JSC::JIT::emitSlow_op_get_by_val):
2516         (JSC::JIT::emitSlow_op_loop_if_less):
2517         (JSC::JIT::emitSlow_op_loop_if_lesseq):
2518         (JSC::JIT::emitSlow_op_put_by_val):
2519         (JSC::JIT::emitSlow_op_not):
2520         (JSC::JIT::emitSlow_op_instanceof):
2521         * jit/JITPropertyAccess.cpp:
2522         (JSC::JIT::emit_op_get_by_val):
2523         (JSC::JIT::emit_op_put_by_val):
2524         (JSC::JIT::emit_op_put_by_index):
2525         (JSC::JIT::emit_op_put_getter):
2526         (JSC::JIT::emit_op_put_setter):
2527         (JSC::JIT::emit_op_del_by_id):
2528         (JSC::JIT::compileGetByIdHotPath):
2529         (JSC::JIT::compilePutByIdHotPath):
2530         * jit/JITStubCall.h:
2531         (JSC::JITStubCall::JITStubCall):
2532         (JSC::JITStubCall::addArgument):
2533         (JSC::JITStubCall::call):
2534         (JSC::JITStubCall::):
2535         (JSC::CallEvalJITStub::CallEvalJITStub):
2536         * jit/JITStubs.cpp:
2537         (JSC::):
2538         (JSC::JITStubs::cti_op_add):
2539         (JSC::JITStubs::cti_op_pre_inc):
2540         (JSC::JITStubs::cti_op_mul):
2541         (JSC::JITStubs::cti_op_get_by_val):
2542         (JSC::JITStubs::cti_op_get_by_val_string):
2543         (JSC::JITStubs::cti_op_get_by_val_byte_array):
2544         (JSC::JITStubs::cti_op_sub):
2545         (JSC::JITStubs::cti_op_put_by_val):
2546         (JSC::JITStubs::cti_op_put_by_val_array):
2547         (JSC::JITStubs::cti_op_put_by_val_byte_array):
2548         (JSC::JITStubs::cti_op_negate):
2549         (JSC::JITStubs::cti_op_div):
2550         (JSC::JITStubs::cti_op_pre_dec):
2551         (JSC::JITStubs::cti_op_post_inc):
2552         (JSC::JITStubs::cti_op_eq):
2553         (JSC::JITStubs::cti_op_lshift):
2554         (JSC::JITStubs::cti_op_bitand):
2555         (JSC::JITStubs::cti_op_rshift):
2556         (JSC::JITStubs::cti_op_bitnot):
2557         (JSC::JITStubs::cti_op_mod):
2558         (JSC::JITStubs::cti_op_neq):
2559         (JSC::JITStubs::cti_op_post_dec):
2560         (JSC::JITStubs::cti_op_urshift):
2561         (JSC::JITStubs::cti_op_bitxor):
2562         (JSC::JITStubs::cti_op_bitor):
2563         (JSC::JITStubs::cti_op_switch_imm):
2564         * jit/JITStubs.h:
2565         * runtime/JSArray.cpp:
2566         (JSC::JSArray::JSArray):
2567         * runtime/JSFunction.cpp:
2568         (JSC::JSFunction::~JSFunction):
2569         * runtime/JSValue.h:
2570         (JSC::JSValue::payload):
2571         * wtf/Platform.h:
2572
2573 2009-05-07  Sam Weinig  <sam@webkit.org>
2574
2575         Reviewed by Geoffrey Garen.
2576
2577         Add some new MacroAssembler and assembler functions that will be needed shortly.
2578
2579         * assembler/MacroAssemblerX86Common.h:
2580         (JSC::MacroAssemblerX86Common::add32):
2581         (JSC::MacroAssemblerX86Common::and32):
2582         (JSC::MacroAssemblerX86Common::mul32):
2583         (JSC::MacroAssemblerX86Common::neg32):
2584         (JSC::MacroAssemblerX86Common::or32):
2585         (JSC::MacroAssemblerX86Common::sub32):
2586         (JSC::MacroAssemblerX86Common::xor32):
2587         (JSC::MacroAssemblerX86Common::branchAdd32):
2588         (JSC::MacroAssemblerX86Common::branchMul32):
2589         (JSC::MacroAssemblerX86Common::branchSub32):
2590         * assembler/X86Assembler.h:
2591         (JSC::X86Assembler::):
2592         (JSC::X86Assembler::addl_rm):
2593         (JSC::X86Assembler::andl_mr):
2594         (JSC::X86Assembler::andl_rm):
2595         (JSC::X86Assembler::andl_im):
2596         (JSC::X86Assembler::negl_r):
2597         (JSC::X86Assembler::notl_r):
2598         (JSC::X86Assembler::orl_rm):
2599         (JSC::X86Assembler::orl_im):
2600         (JSC::X86Assembler::subl_rm):
2601         (JSC::X86Assembler::xorl_mr):
2602         (JSC::X86Assembler::xorl_rm):
2603         (JSC::X86Assembler::xorl_im):
2604         (JSC::X86Assembler::imull_mr):
2605
2606 2009-05-11  Sam Weinig  <sam@webkit.org>
2607
2608         Reviewed by Cameron Zwarich.
2609
2610         Remove the NumberHeap.
2611
2612         * JavaScriptCore.exp:
2613         * runtime/Collector.cpp:
2614         (JSC::Heap::Heap):
2615         (JSC::Heap::destroy):
2616         (JSC::Heap::recordExtraCost):
2617         (JSC::Heap::heapAllocate):
2618         (JSC::Heap::markConservatively):
2619         (JSC::Heap::sweep):
2620         (JSC::Heap::collect):
2621         (JSC::Heap::objectCount):
2622         (JSC::Heap::statistics):
2623         (JSC::typeName):
2624         (JSC::Heap::isBusy):
2625         * runtime/Collector.h:
2626         (JSC::Heap::globalData):
2627         * runtime/JSCell.h:
2628
2629 2009-05-11  Geoffrey Garen  <ggaren@apple.com>
2630
2631         Reviewed by Sam Weinig.
2632
2633         Land initial commit of new number representation for 32 bit platforms,
2634         with JIT disabled.
2635
2636         * API/APICast.h:
2637         (toJS):
2638         (toRef):
2639         * API/JSCallbackObjectFunctions.h:
2640         (JSC::::hasInstance):
2641         (JSC::::toNumber):
2642         (JSC::::toString):
2643         * API/tests/testapi.c:
2644         (EvilExceptionObject_convertToType):
2645         * AllInOneFile.cpp:
2646         * JavaScriptCore.exp:
2647         * JavaScriptCore.xcodeproj/project.pbxproj:
2648         * bytecode/CodeBlock.cpp:
2649         (JSC::valueToSourceString):
2650         * bytecompiler/BytecodeGenerator.cpp:
2651         (JSC::BytecodeGenerator::emitLoad):
2652         (JSC::BytecodeGenerator::emitUnexpectedLoad):
2653         (JSC::keyForImmediateSwitch):
2654         * bytecompiler/BytecodeGenerator.h:
2655         * interpreter/Interpreter.cpp:
2656         (JSC::Interpreter::dumpRegisters):
2657         (JSC::Interpreter::privateExecute):
2658         * parser/Nodes.cpp:
2659         (JSC::ArrayNode::emitBytecode):
2660         (JSC::processClauseList):
2661         * runtime/ArgList.h:
2662         * runtime/Collector.h:
2663         (JSC::sizeof):
2664         * runtime/DateMath.cpp:
2665         * runtime/ExceptionHelpers.h:
2666         * runtime/InitializeThreading.cpp:
2667         * runtime/JSArray.cpp:
2668         (JSC::JSArray::JSArray):
2669         * runtime/JSCell.cpp:
2670         * runtime/JSCell.h:
2671         (JSC::JSCell::isAPIValueWrapper):
2672         (JSC::JSValue::isString):
2673         (JSC::JSValue::isGetterSetter):
2674         (JSC::JSValue::isObject):
2675         (JSC::JSValue::getString):
2676         (JSC::JSValue::getObject):
2677         (JSC::JSValue::getCallData):
2678         (JSC::JSValue::getConstructData):
2679         (JSC::JSValue::getUInt32):
2680         (JSC::JSValue::marked):
2681         (JSC::JSValue::toPrimitive):
2682         (JSC::JSValue::getPrimitiveNumber):
2683         (JSC::JSValue::toBoolean):
2684         (JSC::JSValue::toNumber):
2685         (JSC::JSValue::toString):
2686         (JSC::JSValue::needsThisConversion):
2687         (JSC::JSValue::toThisString):
2688         (JSC::JSValue::getJSNumber):
2689         (JSC::JSValue::toObject):
2690         (JSC::JSValue::toThisObject):
2691         * runtime/JSGlobalData.cpp:
2692         (JSC::JSGlobalData::JSGlobalData):
2693         * runtime/JSGlobalData.h:
2694         * runtime/JSGlobalObject.h:
2695         (JSC::Structure::prototypeForLookup):
2696         * runtime/JSGlobalObjectFunctions.cpp:
2697         (JSC::globalFuncParseInt):
2698         * runtime/JSImmediate.h:
2699         * runtime/JSNumberCell.cpp: Removed.
2700         * runtime/JSNumberCell.h: Removed.
2701         * runtime/JSObject.h:
2702         (JSC::JSValue::get):
2703         (JSC::JSValue::put):
2704         * runtime/JSString.h:
2705         (JSC::JSValue::toThisJSString):
2706         * runtime/JSValue.cpp:
2707         (JSC::JSValue::toInteger):
2708         (JSC::JSValue::toIntegerPreserveNaN):
2709         (JSC::JSValue::toObjectSlowCase):
2710         (JSC::JSValue::toThisObjectSlowCase):
2711         (JSC::JSValue::synthesizeObject):
2712         (JSC::JSValue::synthesizePrototype):
2713         (JSC::JSValue::description):
2714         (JSC::nonInlineNaN):
2715         * runtime/JSValue.h:
2716         (JSC::JSValue::):
2717         (JSC::EncodedJSValueHashTraits::emptyValue):
2718         (JSC::jsNaN):
2719         (JSC::operator==):
2720         (JSC::operator!=):
2721         (JSC::toInt32):
2722         (JSC::toUInt32):
2723         (JSC::JSValue::encode):
2724         (JSC::JSValue::decode):
2725         (JSC::JSValue::JSValue):
2726         (JSC::JSValue::operator bool):
2727         (JSC::JSValue::operator==):
2728         (JSC::JSValue::operator!=):
2729         (JSC::JSValue::isUndefined):
2730         (JSC::JSValue::isNull):
2731         (JSC::JSValue::isUndefinedOrNull):
2732         (JSC::JSValue::isCell):
2733         (JSC::JSValue::isInt32):
2734         (JSC::JSValue::isUInt32):
2735         (JSC::JSValue::isDouble):
2736         (JSC::JSValue::isTrue):
2737         (JSC::JSValue::isFalse):
2738         (JSC::JSValue::tag):
2739         (JSC::JSValue::asInt32):
2740         (JSC::JSValue::asUInt32):
2741         (JSC::JSValue::asDouble):
2742         (JSC::JSValue::asCell):
2743         (JSC::JSValue::isNumber):
2744         (JSC::JSValue::isBoolean):
2745         (JSC::JSValue::getBoolean):
2746         (JSC::JSValue::uncheckedGetNumber):
2747         (JSC::JSValue::toJSNumber):
2748         (JSC::JSValue::getNumber):
2749         (JSC::JSValue::toInt32):
2750         (JSC::JSValue::toUInt32):
2751         * runtime/Operations.h:
2752         (JSC::JSValue::equal):
2753         (JSC::JSValue::equalSlowCaseInline):
2754         (JSC::JSValue::strictEqual):
2755         (JSC::JSValue::strictEqualSlowCaseInline):
2756         (JSC::jsLess):
2757         (JSC::jsLessEq):
2758         (JSC::jsAdd):
2759         * runtime/PropertySlot.h:
2760         * runtime/StringPrototype.cpp:
2761         (JSC::stringProtoFuncCharAt):
2762         (JSC::stringProtoFuncCharCodeAt):
2763         (JSC::stringProtoFuncIndexOf):
2764         * wtf/Platform.h:
2765
2766 === Start merge of nitro-extreme branch 2009-07-30 ===
2767
2768 2009-07-29  Laszlo Gombos  <laszlo.1.gombos@nokia.com>
2769
2770         Reviewed by George Staikos.
2771
2772         Resolve class/struct mixup in forward declarations
2773         https://bugs.webkit.org/show_bug.cgi?id=27708
2774
2775         * API/JSClassRef.h:
2776         * bytecode/SamplingTool.h:
2777         * interpreter/Interpreter.h:
2778         * jit/JIT.h:
2779         * profiler/ProfileGenerator.h:
2780         * profiler/Profiler.h:
2781         * runtime/ClassInfo.h:
2782         * runtime/ExceptionHelpers.h:
2783         * runtime/JSByteArray.h:
2784         * runtime/JSCell.h:
2785         * runtime/JSFunction.h:
2786         * runtime/JSGlobalData.h:
2787         * runtime/JSObject.h:
2788         * runtime/JSString.h:
2789
2790 2009-07-28  Ada Chan  <adachan@apple.com>        
2791
2792         Reviewed by Darin Adler.
2793
2794         https://bugs.webkit.org/show_bug.cgi?id=27236
2795         - Implement TCMalloc_SystemRelease and TCMalloc_SystemCommit for Windows.
2796         - Use a background thread to periodically scavenge memory to release back to the system.
2797
2798         * wtf/FastMalloc.cpp:
2799         (WTF::TCMalloc_PageHeap::init):
2800         (WTF::TCMalloc_PageHeap::runScavengerThread):
2801         (WTF::TCMalloc_PageHeap::scavenge):
2802         (WTF::TCMalloc_PageHeap::shouldContinueScavenging):
2803         (WTF::TCMalloc_PageHeap::New):
2804         (WTF::TCMalloc_PageHeap::AllocLarge):
2805         (WTF::TCMalloc_PageHeap::Delete):
2806         (WTF::TCMalloc_PageHeap::GrowHeap):
2807         (WTF::sleep):
2808         (WTF::TCMalloc_PageHeap::scavengerThread):
2809         * wtf/TCSystemAlloc.cpp:
2810         (TCMalloc_SystemRelease):
2811         (TCMalloc_SystemCommit):
2812         * wtf/TCSystemAlloc.h:
2813
2814 2009-07-28  Xan Lopez  <xlopez@igalia.com>
2815
2816         Add new files, fixes distcheck.
2817
2818         * GNUmakefile.am:
2819
2820 2009-07-28  Csaba Osztrogonac  <oszi@inf.u-szeged.hu>
2821
2822         Reviewed by Simon Hausmann.
2823
2824         [Qt] Determining whether to use JIT or interpreter
2825         moved from JavaScriptCore.pri to Platform.h
2826
2827         * JavaScriptCore.pri:
2828         * wtf/Platform.h:
2829
2830 2009-07-27  Brian Weinstein  <bweinstein@apple.com>
2831
2832         Fix of misuse of sort command.
2833
2834         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
2835         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
2836
2837 2009-07-27  Brian Weinstein  <bweinstein@apple.com>
2838
2839         Build fix for Windows.
2840
2841         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
2842         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
2843
2844 2009-07-27  Gavin Barraclough  <barraclough@apple.com>
2845
2846         Rubber stamped by Oliver Hunt.
2847
2848         Fix tyop in JIT, renamed preverveReturnAddressAfterCall -> preserveReturnAddressAfterCall.
2849
2850         * jit/JIT.cpp:
2851         (JSC::JIT::privateCompile):
2852         (JSC::JIT::privateCompileCTIMachineTrampolines):
2853         * jit/JIT.h:
2854         * jit/JITInlineMethods.h:
2855         (JSC::JIT::preserveReturnAddressAfterCall):
2856         * jit/JITPropertyAccess.cpp:
2857         (JSC::JIT::privateCompilePutByIdTransition):
2858
2859 2009-07-27  Alexey Proskuryakov  <ap@webkit.org>
2860
2861         Gtk build fix.
2862
2863         * runtime/JSLock.cpp: (JSC::JSLock::JSLock): Fix "no threading" case.
2864
2865 2009-07-27  Alexey Proskuryakov  <ap@webkit.org>
2866
2867         Release build fix.
2868
2869         * runtime/JSLock.h: (JSC::JSLock::~JSLock):
2870
2871 2009-07-27  Alexey Proskuryakov  <ap@webkit.org>
2872
2873         Reviewed by Darin Adler.
2874
2875         https://bugs.webkit.org/show_bug.cgi?id=27735
2876         Give a helpful name to JSLock constructor argument
2877
2878         * API/JSBase.cpp:
2879         (JSGarbageCollect):
2880         * API/JSContextRef.cpp:
2881         * API/JSObjectRef.cpp:
2882         (JSPropertyNameArrayRelease):
2883         (JSPropertyNameAccumulatorAddName):
2884         * JavaScriptCore.exp:
2885         * jsc.cpp:
2886         (functionGC):
2887         (cleanupGlobalData):
2888         (jscmain):
2889         * runtime/Collector.cpp:
2890         (JSC::Heap::destroy):
2891         * runtime/JSLock.cpp:
2892         (JSC::JSLock::JSLock):
2893         (JSC::JSLock::lock):
2894         (JSC::JSLock::unlock):
2895         (JSC::JSLock::DropAllLocks::DropAllLocks):
2896         (JSC::JSLock::DropAllLocks::~DropAllLocks):
2897         * runtime/JSLock.h:
2898         (JSC::):
2899         (JSC::JSLock::JSLock):
2900         (JSC::JSLock::~JSLock):
2901
2902 2009-07-25  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
2903
2904         Reviewed by Eric Seidel.
2905
2906         Allow custom memory allocation control for OpaqueJSPropertyNameArray struct
2907         https://bugs.webkit.org/show_bug.cgi?id=27342
2908
2909         Inherits OpaqueJSPropertyNameArray struct from FastAllocBase because it has been
2910         instantiated by 'new' JavaScriptCore/API/JSObjectRef.cpp:473.
2911
2912         * API/JSObjectRef.cpp:
2913
2914 2009-07-24  Ada Chan  <adachan@apple.com>
2915
2916         In preparation for https://bugs.webkit.org/show_bug.cgi?id=27236:
2917         Remove TCMALLOC_TRACK_DECOMMITED_SPANS.  We'll always track decommitted spans.
2918         We have tested this and show it has little impact on performance.
2919
2920         Reviewed by Mark Rowe.
2921
2922         * wtf/FastMalloc.cpp:
2923         (WTF::TCMalloc_PageHeap::New):
2924         (WTF::TCMalloc_PageHeap::AllocLarge):
2925         (WTF::propagateDecommittedState):
2926         (WTF::mergeDecommittedStates):
2927         (WTF::TCMalloc_PageHeap::Delete):
2928         (WTF::TCMalloc_PageHeap::IncrementalScavenge):
2929
2930 2009-07-24  Csaba Osztrogonac  <oszi@inf.u-szeged.hu>
2931
2932         Reviewed by Darin Adler and Adam Barth.
2933
2934         Build fix for x86 platforms.
2935         https://bugs.webkit.org/show_bug.cgi?id=27602
2936
2937         * jit/JIT.cpp:
2938
2939 2009-07-23  Kevin Ollivier  <kevino@theolliviers.com>
2940
2941         wx build fix, adding missing header.
2942
2943         * jit/JIT.cpp:
2944
2945 2009-07-22  Yong Li  <yong.li@torchmobile.com>
2946
2947         Reviewed by George Staikos.
2948
2949         Add wince specific memory files into wtf/wince
2950         https://bugs.webkit.org/show_bug.cgi?id=27550
2951
2952         * wtf/wince/FastMallocWince.h: Added.
2953         * wtf/wince/MemoryManager.cpp: Added.
2954         * wtf/wince/MemoryManager.h: Added.
2955
2956 2009-07-23  Norbert Leser  <norbert.leser@nokia.com>
2957
2958         Reviewed by Simon Hausmann.
2959
2960         Fix for missing mmap features in Symbian
2961         https://bugs.webkit.org/show_bug.cgi?id=24540
2962
2963         Fix, conditionally for PLATFORM(SYMBIAN), as an alternative 
2964         to missing support for the MAP_ANON property flag in mmap. 
2965         It utilizes Symbian specific memory allocation features.
2966
2967         * runtime/Collector.cpp
2968
2969 2009-07-22  Gavin Barraclough  <barraclough@apple.com>
2970
2971         Reviewed by Sam Weinig.
2972
2973         With ENABLE(ASSEMBLER_WX_EXCLUSIVE), only change permissions once per repatch event.
2974         ( https://bugs.webkit.org/show_bug.cgi?id=27564 )
2975
2976         Currently we change permissions forwards and backwards for each instruction modified,
2977         instead we should only change permissions once per complete repatching event.
2978
2979         2.5% progression running with ENABLE(ASSEMBLER_WX_EXCLUSIVE) enabled,
2980         which recoups 1/3 of the penalty of running with this mode enabled.
2981
2982         * assembler/ARMAssembler.cpp:
2983         (JSC::ARMAssembler::linkBranch):
2984             - Replace usage of MakeWritable with cacheFlush.
2985         
2986         * assembler/ARMAssembler.h:
2987         (JSC::ARMAssembler::patchPointerInternal):
2988         (JSC::ARMAssembler::repatchLoadPtrToLEA):
2989             - Replace usage of MakeWritable with cacheFlush.
2990
2991         * assembler/ARMv7Assembler.h:
2992         (JSC::ARMv7Assembler::relinkJump):
2993         (JSC::ARMv7Assembler::relinkCall):
2994         (JSC::ARMv7Assembler::repatchInt32):
2995         (JSC::ARMv7Assembler::repatchPointer):
2996         (JSC::ARMv7Assembler::repatchLoadPtrToLEA):
2997         (JSC::ARMv7Assembler::setInt32):
2998             - Replace usage of MakeWritable with cacheFlush.
2999
3000         * assembler/LinkBuffer.h:
3001         (JSC::LinkBuffer::performFinalization):
3002             - Make explicit call to cacheFlush.
3003
3004         * assembler/MacroAssemblerCodeRef.h:
3005         (JSC::MacroAssemblerCodeRef::MacroAssemblerCodeRef):
3006             - Make size always available.
3007
3008         * assembler/RepatchBuffer.h:
3009         (JSC::RepatchBuffer::RepatchBuffer):
3010         (JSC::RepatchBuffer::~RepatchBuffer):
3011             - Add calls to MakeWritable & makeExecutable.
3012
3013         * assembler/X86Assembler.h:
3014         (JSC::X86Assembler::relinkJump):
3015         (JSC::X86Assembler::relinkCall):
3016         (JSC::X86Assembler::repatchInt32):
3017         (JSC::X86Assembler::repatchPointer):
3018         (JSC::X86Assembler::repatchLoadPtrToLEA):
3019             - Remove usage of MakeWritable.
3020
3021         * bytecode/CodeBlock.h:
3022         (JSC::CodeBlock::getJITCode):
3023             - Provide access to CodeBlock's JITCode.
3024
3025         * jit/ExecutableAllocator.h:
3026         (JSC::ExecutableAllocator::makeExecutable):
3027         (JSC::ExecutableAllocator::cacheFlush):
3028             - Remove MakeWritable, make cacheFlush public.
3029
3030         * jit/JIT.cpp:
3031         (JSC::ctiPatchNearCallByReturnAddress):
3032         (JSC::ctiPatchCallByReturnAddress):
3033         (JSC::JIT::privateCompile):
3034         (JSC::JIT::unlinkCall):
3035         (JSC::JIT::linkCall):
3036             - Add CodeBlock argument to RepatchBuffer.
3037
3038         * jit/JIT.h:
3039             - Pass CodeBlock argument for use by RepatchBuffer.
3040
3041         * jit/JITCode.h:
3042         (JSC::JITCode::start):
3043         (JSC::JITCode::size):
3044             - Provide access to code start & size.
3045
3046         * jit/JITPropertyAccess.cpp:
3047         (JSC::JIT::privateCompilePutByIdTransition):
3048         (JSC::JIT::patchGetByIdSelf):
3049         (JSC::JIT::patchMethodCallProto):
3050         (JSC::JIT::patchPutByIdReplace):
3051         (JSC::JIT::privateCompilePatchGetArrayLength):
3052         (JSC::JIT::privateCompileGetByIdProto):
3053         (JSC::JIT::privateCompileGetByIdSelfList):
3054         (JSC::JIT::privateCompileGetByIdProtoList):
3055         (JSC::JIT::privateCompileGetByIdChainList):
3056         (JSC::JIT::privateCompileGetByIdChain):
3057             - Add CodeBlock argument to RepatchBuffer.
3058
3059         * jit/JITStubs.cpp:
3060         (JSC::JITThunks::tryCachePutByID):
3061         (JSC::JITThunks::tryCacheGetByID):
3062         (JSC::JITStubs::DEFINE_STUB_FUNCTION):
3063             - Pass CodeBlock argument for use by RepatchBuffer.
3064
3065 2009-07-21  Zoltan Herczeg  <zherczeg@inf.u-szeged.hu>
3066
3067         Reviewed by Gavin Barraclough.
3068
3069         Cache not only the structure of the method, but the
3070         structure of its prototype as well.
3071         https://bugs.webkit.org/show_bug.cgi?id=27077
3072
3073         * bytecode/CodeBlock.cpp:
3074         (JSC::CodeBlock::~CodeBlock):
3075         * bytecode/CodeBlock.h:
3076         (JSC::MethodCallLinkInfo::MethodCallLinkInfo):
3077         * jit/JITPropertyAccess.cpp:
3078         (JSC::JIT::patchMethodCallProto):
3079
3080 2009-07-21  Gavin Barraclough  <barraclough@apple.com>
3081
3082         Reviewed by Sam Weinig.
3083
3084         Move call linking / repatching down from AbstractMacroAssembler into MacroAssemblerARCH classes.
3085         ( https://bugs.webkit.org/show_bug.cgi?id=27527 )
3086
3087         This allows the implementation to be defined per architecture.  Specifically this addresses the
3088         fact that x86-64 MacroAssembler implements far calls as a load to register, followed by a call
3089         to register.  Patching the call actually requires the pointer load to be patched, rather than
3090         the call to be patched.  This is implementation detail specific to MacroAssemblerX86_64, and as
3091         such is best handled there.
3092
3093         * assembler/AbstractMacroAssembler.h:
3094         * assembler/MacroAssemblerARM.h:
3095         (JSC::MacroAssemblerARM::linkCall):
3096         (JSC::MacroAssemblerARM::repatchCall):
3097         * assembler/MacroAssemblerARMv7.h:
3098         (JSC::MacroAssemblerARMv7::linkCall):
3099         (JSC::MacroAssemblerARMv7::repatchCall):
3100         * assembler/MacroAssemblerX86.h:
3101         (JSC::MacroAssemblerX86::linkCall):
3102         (JSC::MacroAssemblerX86::repatchCall):
3103         * assembler/MacroAssemblerX86_64.h:
3104         (JSC::MacroAssemblerX86_64::linkCall):
3105         (JSC::MacroAssemblerX86_64::repatchCall):
3106
3107 2009-07-21  Adam Treat  <adam.treat@torchmobile.com>
3108
3109         Reviewed by George Staikos.
3110
3111         Every wtf file includes other wtf files with <> style includes
3112         except this one.  Fix the exception.
3113
3114         * wtf/ByteArray.h:
3115
3116 2009-07-21  Gavin Barraclough  <barraclough@apple.com>
3117
3118         Reviewed by Oliver Hunt.
3119
3120         Move LinkBuffer/RepatchBuffer out of AbstractMacroAssembler.
3121         ( https://bugs.webkit.org/show_bug.cgi?id=27485 )
3122
3123         This change is the first step in a process to move code that should be in
3124         the architecture-specific MacroAssembler classes up out of Assmbler and
3125         AbstractMacroAssembler.
3126
3127         * JavaScriptCore.xcodeproj/project.pbxproj:
3128             - added new files
3129         
3130         * assembler/ARMAssembler.h:
3131         (JSC::ARMAssembler::linkPointer):
3132             - rename patchPointer to bring it in line with the current link/repatch naming scheme
3133         
3134         * assembler/ARMv7Assembler.h:
3135         (JSC::ARMv7Assembler::linkCall):
3136         (JSC::ARMv7Assembler::linkPointer):
3137         (JSC::ARMv7Assembler::relinkCall):
3138         (JSC::ARMv7Assembler::repatchInt32):
3139         (JSC::ARMv7Assembler::repatchPointer):
3140         (JSC::ARMv7Assembler::setInt32):
3141         (JSC::ARMv7Assembler::setPointer):
3142             - rename patchPointer to bring it in line with the current link/repatch naming scheme
3143
3144         * assembler/AbstractMacroAssembler.h:
3145         (JSC::AbstractMacroAssembler::linkJump):
3146         (JSC::AbstractMacroAssembler::linkCall):
3147         (JSC::AbstractMacroAssembler::linkPointer):
3148         (JSC::AbstractMacroAssembler::getLinkerAddress):
3149         (JSC::AbstractMacroAssembler::getLinkerCallReturnOffset):
3150         (JSC::AbstractMacroAssembler::repatchJump):
3151         (JSC::AbstractMacroAssembler::repatchCall):
3152         (JSC::AbstractMacroAssembler::repatchNearCall):
3153         (JSC::AbstractMacroAssembler::repatchInt32):
3154         (JSC::AbstractMacroAssembler::repatchPointer):
3155         (JSC::AbstractMacroAssembler::repatchLoadPtrToLEA):
3156             - remove the LinkBuffer/RepatchBuffer classes, but leave a set of (private, friended) methods to interface to the Assembler
3157
3158         * assembler/LinkBuffer.h: Added.
3159         (JSC::LinkBuffer::LinkBuffer):
3160         (JSC::LinkBuffer::~LinkBuffer):
3161         (JSC::LinkBuffer::link):
3162         (JSC::LinkBuffer::patch):
3163         (JSC::LinkBuffer::locationOf):
3164         (JSC::LinkBuffer::locationOfNearCall):
3165         (JSC::LinkBuffer::returnAddressOffset):
3166         (JSC::LinkBuffer::finalizeCode):
3167         (JSC::LinkBuffer::finalizeCodeAddendum):
3168         (JSC::LinkBuffer::code):
3169         (JSC::LinkBuffer::performFinalization):
3170             - new file containing the LinkBuffer class, previously a member of AbstractMacroAssembler
3171
3172         * assembler/RepatchBuffer.h: Added.
3173         (JSC::RepatchBuffer::RepatchBuffer):
3174         (JSC::RepatchBuffer::relink):
3175         (JSC::RepatchBuffer::repatch):
3176         (JSC::RepatchBuffer::repatchLoadPtrToLEA):
3177         (JSC::RepatchBuffer::relinkCallerToTrampoline):
3178         (JSC::RepatchBuffer::relinkCallerToFunction):
3179         (JSC::RepatchBuffer::relinkNearCallerToTrampoline):
3180             - new file containing the RepatchBuffer class, previously a member of AbstractMacroAssembler
3181
3182         * assembler/X86Assembler.h:
3183         (JSC::X86Assembler::linkJump):
3184         (JSC::X86Assembler::linkCall):
3185         (JSC::X86Assembler::linkPointerForCall):
3186         (JSC::X86Assembler::linkPointer):
3187         (JSC::X86Assembler::relinkJump):
3188         (JSC::X86Assembler::relinkCall):
3189         (JSC::X86Assembler::repatchInt32):
3190         (JSC::X86Assembler::repatchPointer):
3191         (JSC::X86Assembler::setPointer):
3192         (JSC::X86Assembler::setInt32):
3193         (JSC::X86Assembler::setRel32):
3194             - rename patchPointer to bring it in line with the current link/repatch naming scheme
3195
3196         * jit/JIT.cpp:
3197         (JSC::ctiPatchNearCallByReturnAddress):
3198         (JSC::ctiPatchCallByReturnAddress):
3199             - include new headers
3200             - remove MacroAssembler:: specification from RepatchBuffer usage
3201
3202         * jit/JITPropertyAccess.cpp:
3203         * yarr/RegexJIT.cpp:
3204             - include new headers
3205
3206 2009-07-21  Robert Agoston  <Agoston.Robert@stud.u-szeged.hu>
3207
3208         Reviewed by David Levin.
3209
3210         Fixed #undef typo.
3211         https://bugs.webkit.org/show_bug.cgi?id=27506
3212
3213         * bytecode/Opcode.h:
3214
3215 2009-07-21  Adam Roben  <aroben@apple.com>
3216
3217         Roll out r46153, r46154, and r46155
3218
3219         These changes were causing build failures and assertion failures on
3220         Windows.
3221
3222         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
3223         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
3224         * JavaScriptCore.xcodeproj/project.pbxproj:
3225         * runtime/JSArray.cpp:
3226         * runtime/StringPrototype.cpp:
3227         * runtime/UString.cpp:
3228         * runtime/UString.h:
3229         * wtf/FastMalloc.cpp:
3230         * wtf/FastMalloc.h:
3231         * wtf/Platform.h:
3232         * wtf/PossiblyNull.h: Removed.
3233
3234 2009-07-21  Roland Steiner  <rolandsteiner@google.com>
3235
3236         Reviewed by David Levin.
3237
3238         Add ENABLE_RUBY to list of build options
3239         https://bugs.webkit.org/show_bug.cgi?id=27324
3240
3241         * Configurations/FeatureDefines.xcconfig: Added flag ENABLE_RUBY.
3242
3243 2009-07-20  Oliver Hunt  <oliver@apple.com>
3244
3245         Reviewed by NOBODY (Build fix).
3246
3247         Build fix attempt #2
3248
3249         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
3250         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
3251
3252 2009-07-20  Oliver Hunt  <oliver@apple.com>
3253
3254         Reviewed by NOBODY (Build fix).
3255
3256         Build fix attempt #1
3257
3258         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
3259         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore_debug.def:
3260
3261 2009-07-20  Oliver Hunt  <oliver@apple.com>
3262
3263         Reviewed by Gavin Barraclough.
3264
3265         Make it harder to misuse try* allocation routines
3266         https://bugs.webkit.org/show_bug.cgi?id=27469
3267
3268         Jump through a few hoops to make it much harder to accidentally
3269         miss null-checking of values returned by the try-* allocation
3270         routines.
3271
3272         * JavaScriptCore.xcodeproj/project.pbxproj:
3273         * runtime/JSArray.cpp:
3274         (JSC::JSArray::putSlowCase):
3275         (JSC::JSArray::increaseVectorLength):
3276         * runtime/StringPrototype.cpp:
3277         (JSC::stringProtoFuncFontsize):
3278         (JSC::stringProtoFuncLink):
3279         * runtime/UString.cpp:
3280         (JSC::allocChars):
3281         (JSC::reallocChars):
3282         (JSC::expandCapacity):
3283         (JSC::UString::Rep::reserveCapacity):
3284         (JSC::UString::expandPreCapacity):
3285         (JSC::createRep):
3286         (JSC::concatenate):
3287         (JSC::UString::spliceSubstringsWithSeparators):
3288         (JSC::UString::replaceRange):
3289         (JSC::UString::append):
3290         (JSC::UString::operator=):
3291         * runtime/UString.h:
3292         (JSC::UString::Rep::createEmptyBuffer):
3293         * wtf/FastMalloc.cpp:
3294         (WTF::tryFastZeroedMalloc):
3295         (WTF::tryFastMalloc):
3296         (WTF::tryFastCalloc):
3297         (WTF::tryFastRealloc):
3298         (WTF::TCMallocStats::tryFastMalloc):
3299         (WTF::TCMallocStats::tryFastCalloc):
3300         (WTF::TCMallocStats::tryFastRealloc):
3301         * wtf/FastMalloc.h:
3302         (WTF::TryMallocReturnValue::TryMallocReturnValue):
3303         (WTF::TryMallocReturnValue::~TryMallocReturnValue):
3304         (WTF::TryMallocReturnValue::operator Maybe<T>):
3305         (WTF::TryMallocReturnValue::getValue):
3306         * wtf/PossiblyNull.h:
3307         (WTF::PossiblyNull::PossiblyNull):
3308         (WTF::PossiblyNull::~PossiblyNull):
3309         (WTF::PossiblyNull::getValue):
3310         * wtf/Platform.h:
3311
3312 2009-07-20  Gavin Barraclough  <barraclough@apple.com>
3313
3314         RS Oliver Hunt.
3315
3316         Add ARM assembler files to xcodeproj, for convenience editing.
3317
3318         * JavaScriptCore.xcodeproj/project.pbxproj:
3319
3320 2009-07-20  Jessie Berlin  <jberlin@apple.com>
3321
3322         Reviewed by David Levin.
3323
3324         Fix an incorrect assertion in Vector::remove.
3325         
3326         https://bugs.webkit.org/show_bug.cgi?id=27477
3327
3328         * wtf/Vector.h:
3329         (WTF::::remove):
3330         Assert that the position at which to start removing elements + the
3331         length (the number of elements to remove) is less than or equal to the
3332         size of the entire Vector.
3333
3334 2009-07-20  Peter Kasting  <pkasting@google.com>
3335
3336         Reviewed by Mark Rowe.
3337
3338         https://bugs.webkit.org/show_bug.cgi?id=27468
3339         Back out r46060, which caused problems for some Apple developers.
3340
3341         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreCommon.vsprops:
3342         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreGenerated.vcproj:
3343         * JavaScriptCore.vcproj/WTF/WTFCommon.vsprops:
3344         * JavaScriptCore.vcproj/jsc/jscCommon.vsprops:
3345         * JavaScriptCore.vcproj/testapi/testapiCommon.vsprops:
3346
3347 2009-07-20  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
3348
3349         Reviewed by Oliver Hunt.
3350
3351         Allow custom memory allocation control in NewThreadContext
3352         https://bugs.webkit.org/show_bug.cgi?id=27338
3353
3354         Inherits NewThreadContext struct from FastAllocBase because it
3355         has been instantiated by 'new' JavaScriptCore/wtf/Threading.cpp:76.
3356
3357         * wtf/Threading.cpp:
3358
3359 2009-07-20  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
3360
3361         Reviewed by Oliver Hunt.
3362
3363         Allow custom memory allocation control in JavaScriptCore's JSClassRef.h
3364         https://bugs.webkit.org/show_bug.cgi?id=27340
3365
3366         Inherit StaticValueEntry and StaticFunctionEntry struct from FastAllocBase because these
3367         have been instantiated by 'new' in JavaScriptCore/API/JSClassRef.cpp:153
3368         and in JavaScriptCore/API/JSClassRef.cpp:166.
3369
3370         * API/JSClassRef.h:
3371
3372 2009-07-20  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
3373
3374         Reviewed by Darin Adler.
3375
3376         Allow custom memory allocation control in JavaScriptCore's RegexPattern.h
3377         https://bugs.webkit.org/show_bug.cgi?id=27343
3378
3379         Inherits RegexPattern.h's structs (which have been instantiated by operator new) from FastAllocBase:
3380
3381         CharacterClass (new call: JavaScriptCore/yarr/RegexCompiler.cpp:144)
3382         PatternAlternative (new call: JavaScriptCore/yarr/RegexPattern.h:221) 
3383         PatternDisjunction (new call: JavaScriptCore/yarr/RegexCompiler.cpp:446)
3384
3385         * yarr/RegexPattern.h:
3386
3387 2009-07-20  Zoltan Horvath  <hzoltan@inf.u-szeged.hu>
3388
3389         Reviewed by Darin Adler.
3390
3391         Allow custom memory allocation control for JavaScriptCore's MatchFrame struct
3392         https://bugs.webkit.org/show_bug.cgi?id=27344
3393
3394         Inherits MatchFrame struct from FastAllocBase because it has
3395         been instantiated by 'new' JavaScriptCore/pcre/pcre_exec.cpp:359.
3396
3397         * pcre/pcre_exec.cpp:
3398
3399 2009-07-20  Laszlo Gombos  <laszlo.1.gombos@nokia.com>
3400
3401         Reviewed by Holger Freyther.
3402
3403         Remove some outdated S60 platform specific code
3404         https://bugs.webkit.org/show_bug.cgi?id=27423
3405
3406         * wtf/Platform.h:
3407
3408 2009-07-20  Csaba Osztrogonac  <oszi@inf.u-szeged.hu>
3409
3410         Reviewed by Simon Hausmann.
3411
3412         Qt build fix with MSVC and MinGW.
3413
3414         * jsc.pro: Make sure jsc is a console application, and turn off
3415         exceptions and stl support to fix the build.
3416
3417 2009-07-20  Xan Lopez  <xlopez@igalia.com>
3418
3419         Reviewed by Gustavo Noronha.
3420
3421         Do not use C++-style comments in preprocessor directives.
3422
3423         GCC does not like this in some configurations, using C-style
3424         comments is safer.
3425
3426         * wtf/Platform.h:
3427
3428 2009-07-17  Peter Kasting  <pkasting@google.com>
3429
3430         Reviewed by Steve Falkenburg.
3431
3432         https://bugs.webkit.org/show_bug.cgi?id=27323
3433         Only add Cygwin to the path when it isn't already there.  This avoids
3434         causing problems for people who purposefully have non-Cygwin versions of
3435         executables like svn in front of the Cygwin ones in their paths.
3436
3437         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreCommon.vsprops:
3438         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreGenerated.vcproj:
3439         * JavaScriptCore.vcproj/WTF/WTFCommon.vsprops:
3440         * JavaScriptCore.vcproj/jsc/jscCommon.vsprops:
3441         * JavaScriptCore.vcproj/testapi/testapiCommon.vsprops:
3442
3443 2009-07-17  Gabor Loki  <loki@inf.u-szeged.hu>
3444
3445         Reviewed by Gavin Barraclough.
3446
3447         Add YARR support for generic ARM platforms (disabled by default).
3448         https://bugs.webkit.org/show_bug.cgi?id=24986
3449
3450         Add generic ARM port for MacroAssembler. It supports the whole
3451         MacroAssembler functionality except floating point.
3452
3453         The class JmpSrc is extended with a flag which enables to patch
3454         the jump destination offset during execution. This feature is
3455         required for generic ARM port.
3456
3457         Signed off by Zoltan Herczeg <zherczeg@inf.u-szeged.hu>
3458         Signed off by Gabor Loki <loki@inf.u-szeged.hu>
3459
3460         * JavaScriptCore.pri:
3461         * assembler/ARMAssembler.cpp: Added.
3462         (JSC::ARMAssembler::getLdrImmAddress):
3463         (JSC::ARMAssembler::linkBranch):
3464         (JSC::ARMAssembler::patchConstantPoolLoad):
3465         (JSC::ARMAssembler::getOp2):
3466         (JSC::ARMAssembler::genInt):
3467         (JSC::ARMAssembler::getImm):
3468         (JSC::ARMAssembler::moveImm):
3469         (JSC::ARMAssembler::dataTransfer32):
3470         (JSC::ARMAssembler::baseIndexTransfer32):
3471         (JSC::ARMAssembler::executableCopy):
3472         * assembler/ARMAssembler.h: Added.
3473         (JSC::ARM::):
3474         (JSC::ARMAssembler::ARMAssembler):
3475         (JSC::ARMAssembler::):
3476         (JSC::ARMAssembler::JmpSrc::JmpSrc):
3477         (JSC::ARMAssembler::JmpSrc::enableLatePatch):
3478         (JSC::ARMAssembler::JmpDst::JmpDst):
3479         (JSC::ARMAssembler::JmpDst::isUsed):
3480         (JSC::ARMAssembler::JmpDst::used):
3481         (JSC::ARMAssembler::emitInst):
3482         (JSC::ARMAssembler::and_r):
3483         (JSC::ARMAssembler::ands_r):
3484         (JSC::ARMAssembler::eor_r):
3485         (JSC::ARMAssembler::eors_r):
3486         (JSC::ARMAssembler::sub_r):
3487         (JSC::ARMAssembler::subs_r):
3488         (JSC::ARMAssembler::rsb_r):
3489         (JSC::ARMAssembler::rsbs_r):
3490         (JSC::ARMAssembler::add_r):
3491         (JSC::ARMAssembler::adds_r):
3492         (JSC::ARMAssembler::adc_r):
3493         (JSC::ARMAssembler::adcs_r):
3494         (JSC::ARMAssembler::sbc_r):
3495         (JSC::ARMAssembler::sbcs_r):
3496         (JSC::ARMAssembler::rsc_r):
3497         (JSC::ARMAssembler::rscs_r):
3498         (JSC::ARMAssembler::tst_r):
3499         (JSC::ARMAssembler::teq_r):
3500         (JSC::ARMAssembler::cmp_r):
3501         (JSC::ARMAssembler::orr_r):
3502         (JSC::ARMAssembler::orrs_r):
3503         (JSC::ARMAssembler::mov_r):
3504         (JSC::ARMAssembler::movs_r):
3505         (JSC::ARMAssembler::bic_r):
3506         (JSC::ARMAssembler::bics_r):
3507         (JSC::ARMAssembler::mvn_r):
3508         (JSC::ARMAssembler::mvns_r):
3509         (JSC::ARMAssembler::mul_r):
3510         (JSC::ARMAssembler::muls_r):
3511         (JSC::ARMAssembler::mull_r):
3512         (JSC::ARMAssembler::ldr_imm):
3513         (JSC::ARMAssembler::ldr_un_imm):
3514         (JSC::ARMAssembler::dtr_u):
3515         (JSC::ARMAssembler::dtr_ur):
3516         (JSC::ARMAssembler::dtr_d):
3517         (JSC::ARMAssembler::dtr_dr):
3518         (JSC::ARMAssembler::ldrh_r):
3519         (JSC::ARMAssembler::ldrh_d):
3520         (JSC::ARMAssembler::ldrh_u):
3521         (JSC::ARMAssembler::strh_r):
3522         (JSC::ARMAssembler::push_r):
3523         (JSC::ARMAssembler::pop_r):
3524         (JSC::ARMAssembler::poke_r):
3525         (JSC::ARMAssembler::peek_r):
3526         (JSC::ARMAssembler::clz_r):
3527         (JSC::ARMAssembler::bkpt):
3528         (JSC::ARMAssembler::lsl):
3529         (JSC::ARMAssembler::lsr):
3530         (JSC::ARMAssembler::asr):
3531         (JSC::ARMAssembler::lsl_r):
3532         (JSC::ARMAssembler::lsr_r):
3533         (JSC::ARMAssembler::asr_r):
3534         (JSC::ARMAssembler::size):
3535         (JSC::ARMAssembler::ensureSpace):
3536         (JSC::ARMAssembler::label):
3537         (JSC::ARMAssembler::align):
3538         (JSC::ARMAssembler::jmp):
3539         (JSC::ARMAssembler::patchPointerInternal):
3540         (JSC::ARMAssembler::patchConstantPoolLoad):
3541         (JSC::ARMAssembler::patchPointer):
3542         (JSC::ARMAssembler::repatchInt32):
3543         (JSC::ARMAssembler::repatchPointer):
3544         (JSC::ARMAssembler::repatchLoadPtrToLEA):
3545         (JSC::ARMAssembler::linkJump):
3546         (JSC::ARMAssembler::relinkJump):
3547         (JSC::ARMAssembler::linkCall):
3548         (JSC::ARMAssembler::relinkCall):
3549         (JSC::ARMAssembler::getRelocatedAddress):
3550         (JSC::ARMAssembler::getDifferenceBetweenLabels):
3551         (JSC::ARMAssembler::getCallReturnOffset):
3552         (JSC::ARMAssembler::getOp2Byte):
3553         (JSC::ARMAssembler::placeConstantPoolBarrier):
3554         (JSC::ARMAssembler::RM):
3555         (JSC::ARMAssembler::RS):
3556         (JSC::ARMAssembler::RD):
3557         (JSC::ARMAssembler::RN):
3558         (JSC::ARMAssembler::getConditionalField):
3559         * assembler/ARMv7Assembler.h:
3560         (JSC::ARMv7Assembler::JmpSrc::enableLatePatch):
3561         * assembler/AbstractMacroAssembler.h:
3562         (JSC::AbstractMacroAssembler::Call::enableLatePatch):
3563         (JSC::AbstractMacroAssembler::Jump::enableLatePatch):
3564         * assembler/MacroAssembler.h:
3565         * assembler/MacroAssemblerARM.h: Added.
3566         (JSC::MacroAssemblerARM::):
3567         (JSC::MacroAssemblerARM::add32):
3568         (JSC::MacroAssemblerARM::and32):
3569         (JSC::MacroAssemblerARM::lshift32):
3570         (JSC::MacroAssemblerARM::mul32):
3571         (JSC::MacroAssemblerARM::not32):
3572         (JSC::MacroAssemblerARM::or32):
3573         (JSC::MacroAssemblerARM::rshift32):
3574         (JSC::MacroAssemblerARM::sub32):
3575         (JSC::MacroAssemblerARM::xor32):
3576         (JSC::MacroAssemblerARM::load32):
3577         (JSC::MacroAssemblerARM::load32WithAddressOffsetPatch):
3578         (JSC::MacroAssemblerARM::loadPtrWithPatchToLEA):
3579         (JSC::MacroAssemblerARM::load16):
3580         (JSC::MacroAssemblerARM::store32WithAddressOffsetPatch):
3581         (JSC::MacroAssemblerARM::store32):
3582         (JSC::MacroAssemblerARM::pop):
3583         (JSC::MacroAssemblerARM::push):
3584         (JSC::MacroAssemblerARM::move):
3585         (JSC::MacroAssemblerARM::swap):
3586         (JSC::MacroAssemblerARM::signExtend32ToPtr):
3587         (JSC::MacroAssemblerARM::zeroExtend32ToPtr):
3588         (JSC::MacroAssemblerARM::branch32):
3589         (JSC::MacroAssemblerARM::branch16):
3590         (JSC::MacroAssemblerARM::branchTest32):
3591         (JSC::MacroAssemblerARM::jump):
3592         (JSC::MacroAssemblerARM::branchAdd32):
3593         (JSC::MacroAssemblerARM::mull32):
3594         (JSC::MacroAssemblerARM::branchMul32):
3595         (JSC::MacroAssemblerARM::branchSub32):
3596         (JSC::MacroAssemblerARM::breakpoint):
3597         (JSC::MacroAssemblerARM::nearCall):
3598         (JSC::MacroAssemblerARM::call):
3599         (JSC::MacroAssemblerARM::ret):
3600         (JSC::MacroAssemblerARM::set32):
3601         (JSC::MacroAssemblerARM::setTest32):
3602         (JSC::MacroAssemblerARM::tailRecursiveCall):
3603         (JSC::MacroAssemblerARM::makeTailRecursiveCall):
3604         (JSC::MacroAssemblerARM::moveWithPatch):
3605         (JSC::MacroAssemblerARM::branchPtrWithPatch):
3606         (JSC::MacroAssemblerARM::storePtrWithPatch):
3607         (JSC::MacroAssemblerARM::supportsFloatingPoint):
3608         (JSC::MacroAssemblerARM::supportsFloatingPointTruncate):
3609         (JSC::MacroAssemblerARM::loadDouble):
3610         (JSC::MacroAssemblerARM::storeDouble):
3611         (JSC::MacroAssemblerARM::addDouble):
3612         (JSC::MacroAssemblerARM::subDouble):
3613         (JSC::MacroAssemblerARM::mulDouble):
3614         (JSC::MacroAssemblerARM::convertInt32ToDouble):
3615         (JSC::MacroAssemblerARM::branchDouble):
3616         (JSC::MacroAssemblerARM::branchTruncateDoubleToInt32):