jneq_ptr shouldn't have a pointer
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2012-09-26  Filip Pizlo  <fpizlo@apple.com>
2
3         jneq_ptr shouldn't have a pointer
4         https://bugs.webkit.org/show_bug.cgi?id=97739
5
6         Reviewed by Oliver Hunt.
7
8         Slamming pointers directly into bytecode is sometimes cool, but in this case it's
9         unwieldy and confusing. Switched the instruction to use an enum instead. This has
10         zero effect on code gen behavior in the JITs. In the LLInt, there is now more
11         indirection, but that doesn't affect benchmarks.
12
13         * CMakeLists.txt:
14         * GNUmakefile.list.am:
15         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
16         * JavaScriptCore.xcodeproj/project.pbxproj:
17         * Target.pri:
18         * bytecode/Instruction.h:
19         (JSC::Instruction::Instruction):
20         (Instruction):
21         * bytecode/SpecialPointer.cpp: Added.
22         (JSC):
23         (JSC::actualPointerFor):
24         * bytecode/SpecialPointer.h: Added.
25         (JSC):
26         (JSC::pointerIsFunction):
27         (JSC::pointerIsCell):
28         * bytecompiler/BytecodeGenerator.cpp:
29         (JSC::BytecodeGenerator::emitJumpIfNotFunctionCall):
30         (JSC::BytecodeGenerator::emitJumpIfNotFunctionApply):
31         * dfg/DFGByteCodeParser.cpp:
32         (JSC::DFG::ByteCodeParser::parseBlock):
33         * jit/JITOpcodes.cpp:
34         (JSC::JIT::emit_op_jneq_ptr):
35         * jit/JITOpcodes32_64.cpp:
36         (JSC::JIT::emit_op_jneq_ptr):
37         * llint/LowLevelInterpreter32_64.asm:
38         * llint/LowLevelInterpreter64.asm:
39         * runtime/JSGlobalObject.cpp:
40         (JSC::JSGlobalObject::reset):
41         (JSC):
42         * runtime/JSGlobalObject.h:
43         (JSGlobalObject):
44         (JSC::JSGlobalObject::actualPointerFor):
45
46 2012-09-26  Gavin Barraclough  <barraclough@apple.com>
47
48         REGRESSION (r129456): http/tests/security/xss-eval.html is failing on JSC platforms
49         https://bugs.webkit.org/show_bug.cgi?id=97529
50
51         Reviewed by Filip Pizlo.
52
53         A recent patch changed JSC's EvalError behaviour; bring this more into line with other browsers.
54
55         JSC currently throws an EvalError if you try to call eval with a this object that doesn't
56         match the given eval function. This does not match other browsers, which generally just
57         ignore the this value that was passed, and eval the string in the eval function's environment.
58
59         * runtime/JSGlobalObjectFunctions.cpp:
60         (JSC::globalFuncEval):
61             - Remove EvalError, ignore passed this value.
62
63 2012-09-26  Gavin Barraclough  <barraclough@apple.com>
64
65         Proxy the global this in JSC
66         https://bugs.webkit.org/show_bug.cgi?id=97734
67
68         Reviewed by Oliver Hunt.
69
70         Having jsc diverge from WebCore here is not beneficial; it potentially masks bugs and/or performance
71         problems from command line testing.
72
73         * jsc.cpp:
74         (GlobalObject::create):
75             - Create a this value proxy for the global object.
76         * runtime/JSGlobalObject.h:
77         (JSGlobalObject):
78             - Make setGlobalThis protected.
79         * runtime/JSProxy.h:
80         (JSC::JSProxy::create):
81         (JSC::JSProxy::target):
82         (JSC::JSProxy::finishCreation):
83         (JSProxy):
84             - Allow proxy target to be a JSObject, add target to create method.
85
86 2012-09-26  Gavin Barraclough  <barraclough@apple.com>
87
88         Speculative Windows build fix.
89
90         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
91
92 2012-09-26  Filip Pizlo  <fpizlo@apple.com>
93
94         JSObject::ensureArrayStorage() ignores the possibility that extensions have been prevented
95         https://bugs.webkit.org/show_bug.cgi?id=97719
96
97         Reviewed by Gavin Barraclough.
98
99         * runtime/JSObject.cpp:
100         (JSC::JSObject::ensureArrayStorageSlow):
101         (JSC):
102         * runtime/JSObject.h:
103         (JSC::JSObject::ensureArrayStorage):
104         (JSObject):
105
106 2012-09-26  Gavin Barraclough  <barraclough@apple.com>
107
108         Generalize JSGlobalThis as JSProxy
109         https://bugs.webkit.org/show_bug.cgi?id=97716
110
111         Reviewed by Oliver Hunt.
112
113         Generalize JSGlobalThis as JSProxy and move proxying functionality up from the window shell into JSProxy.
114
115         * CMakeLists.txt:
116         * GNUmakefile.list.am:
117         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
118         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
119         * JavaScriptCore.xcodeproj/project.pbxproj:
120         * Target.pri:
121         * runtime/JSGlobalObject.cpp:
122         (JSC::JSGlobalObject::toThisObject):
123             - Hoist toThisObject from WebCore.
124         (JSC):
125         * runtime/JSGlobalObject.h:
126             - removed include.
127         (JSC::JSGlobalObject::finishCreation):
128             - JSGlobalThis -> JSObject
129         (JSGlobalObject):
130             - Hoist toThisObject from WebCore.
131         * runtime/JSGlobalThis.cpp: Removed.
132         * runtime/JSGlobalThis.h: Removed.
133         * runtime/JSObject.cpp:
134             - removed include.
135         * runtime/JSObject.h:
136         (JSObject):
137         (JSC::JSObject::isProxy):
138             - isGlobalThis -> isProxy
139             - GlobalThisType -> ProxyType
140         * runtime/JSProxy.cpp: Copied from Source/JavaScriptCore/runtime/JSGlobalThis.cpp.
141         (JSC):
142         (JSC::JSProxy::visitChildren):
143         (JSC::JSProxy::setTarget):
144         (JSC::JSProxy::className):
145         (JSC::JSProxy::getOwnPropertySlot):
146         (JSC::JSProxy::getOwnPropertySlotByIndex):
147         (JSC::JSProxy::getOwnPropertyDescriptor):
148         (JSC::JSProxy::put):
149         (JSC::JSProxy::putByIndex):
150         (JSC::JSProxy::putDirectVirtual):
151         (JSC::JSProxy::defineOwnProperty):
152         (JSC::JSProxy::deleteProperty):
153         (JSC::JSProxy::deletePropertyByIndex):
154         (JSC::JSProxy::getPropertyNames):
155         (JSC::JSProxy::getOwnPropertyNames):
156             - Class cretaed from JSGlobalThis, JSDOMWindowShell.
157         * runtime/JSProxy.h: Copied from Source/JavaScriptCore/runtime/JSGlobalThis.h.
158         (JSC::JSProxy::create):
159         (JSC::JSProxy::createStructure):
160         (JSProxy):
161         (JSC::JSProxy::target):
162         (JSC::JSProxy::JSProxy):
163             - Class cretaed from JSGlobalThis, JSDOMWindowShell.
164         * runtime/JSType.h:
165             - GlobalThisType -> ProxyType
166
167 2012-09-26  Michael Saboff  <msaboff@apple.com>
168
169         Add ability for JSArray::unshiftCount to unshift in middle of an array
170         https://bugs.webkit.org/show_bug.cgi?id=97691
171
172         Reviewed by Filip Pizlo.
173
174         Changed JSArray::unshiftCount and unshiftCountSlowCase to handle unshifting from the middle of an
175         array.  Depending on where the unshift point is, either the front part of the array will be moved
176         "left" or the back part will be moved right.  Given that unshiftCount only works on contiguous
177         arrays it is safe to use memmove for the moves.
178
179         This change is worth 25% performance improvement on pdfjs.  It doesn't seem to have any impact on
180         any other benchmarks.
181
182         * runtime/ArrayPrototype.cpp:
183         (JSC::unshift):
184         * runtime/JSArray.cpp:
185         (JSC::JSArray::unshiftCountSlowCase):
186         (JSC::JSArray::unshiftCount):
187         * runtime/JSArray.h:
188         (JSArray):
189
190 2012-09-26  Sheriff Bot  <webkit.review.bot@gmail.com>
191
192         Unreviewed, rolling out r129592.
193         http://trac.webkit.org/changeset/129592
194         https://bugs.webkit.org/show_bug.cgi?id=97670
195
196         Failures in Chromium security tests (Requested by schenney on
197         #webkit).
198
199         * runtime/JSGlobalObjectFunctions.cpp:
200         (JSC::globalFuncEval):
201
202 2012-09-25  Gavin Barraclough  <barraclough@apple.com>
203
204         REGRESSION (r129456): http/tests/security/xss-eval.html is failing on JSC platforms
205         https://bugs.webkit.org/show_bug.cgi?id=97529
206
207         Reviewed by Filip Pizlo.
208
209         A recent patch changed JSC's EvalError behaviour; bring this more into line with other browsers.
210
211         JSC currently throws an EvalError if you try to call eval with a this object that doesn't
212         match the given eval function. This does not match other browsers, which generally just
213         ignore the this value that was passed, and eval the string in the eval function's environment.
214
215         * runtime/JSGlobalObjectFunctions.cpp:
216         (JSC::globalFuncEval):
217             - Remove EvalError, ignore passed this value.
218
219 2012-09-25  Filip Pizlo  <fpizlo@apple.com>
220
221         DFG ArrayPush, ArrayPop don't handle clobbering or having a bad time correctly
222         https://bugs.webkit.org/show_bug.cgi?id=97535
223
224         Reviewed by Oliver Hunt.
225
226         * dfg/DFGAbstractState.cpp:
227         (JSC::DFG::AbstractState::execute):
228         * dfg/DFGByteCodeParser.cpp:
229         (JSC::DFG::ByteCodeParser::handleIntrinsic):
230         * dfg/DFGStructureCheckHoistingPhase.cpp:
231         (JSC::DFG::StructureCheckHoistingPhase::run):
232
233 2012-09-25  Geoffrey Garen  <ggaren@apple.com>
234
235         JSC should dump object size inference statistics
236         https://bugs.webkit.org/show_bug.cgi?id=97618
237
238         Reviewed by Filip Pizlo.
239
240         Added an option to dump object size inference statistics.
241
242         To see statistics on live objects:
243
244             jsc --showHeapStatistics=1
245
246         To see cumulative statistics on all objects ever allocated:
247
248             jsc --showHeapStatistics=1 --objectsAreImmortal=1
249
250             (This is useful for showing GC churn caused by over-allocation.)
251
252         To support this second mode, I refactored Zombies to separate out their
253         immortality feature so I could reuse it.
254
255         * heap/Heap.cpp:
256         (JSC::MarkObject): Helper for making things immortal. We have to checked
257         for being zapped because blocks start out in this state.
258
259         (JSC::StorageStatistics): Gather statistics by walking the heap. Ignore
260         arrays and hash tables for now because they're not our focus. (We'll
261         remove these exceptions in future.)
262
263         (JSC::Heap::collect): Moved zombify to the end so it wouldn't interfere
264         with statistics gathering.
265
266         (JSC::Heap::showStatistics):
267         (JSC::Heap::markAllObjects): Factored out helper, so statistics could
268         take advantage of immortal objects.
269
270         (Zombify): Don't mark immortal objects -- that's another class's job now.
271
272         (JSC::Zombify::operator()):
273         (JSC::Heap::zombifyDeadObjects): Take advantage of forEachDeadCell instead
274         of rolling our own.
275
276         * heap/Heap.h:
277         (Heap):
278         * heap/MarkedSpace.h:
279         (MarkedSpace):
280         (JSC::MarkedSpace::forEachDeadCell): Added, so clients don't have to do
281         the iteration logic themselves.
282
283         * runtime/Options.cpp:
284         (JSC::Options::initialize):
285         * runtime/Options.h: New options, listed above. Make sure to initialize
286         based on environment variable first, so we can override with specific settings.
287
288 2012-09-25  Filip Pizlo  <fpizlo@apple.com>
289
290         We shouldn't use the optimized versions of shift/unshift if the user is doing crazy things to the array
291         https://bugs.webkit.org/show_bug.cgi?id=97603
292         <rdar://problem/12370864>
293
294         Reviewed by Gavin Barraclough.
295
296         You changed the length behind our backs? No optimizations for you then!
297
298         * runtime/ArrayPrototype.cpp:
299         (JSC::shift):
300         (JSC::unshift):
301         * runtime/JSArray.cpp:
302         (JSC::JSArray::shiftCount):
303
304 2012-09-25  Filip Pizlo  <fpizlo@apple.com>
305
306         JSC bindings appear to sometimes ignore the possibility of arrays being in sparse mode
307         https://bugs.webkit.org/show_bug.cgi?id=95610
308
309         Reviewed by Oliver Hunt.
310
311         Add better support for quickly accessing the indexed storage from bindings.
312
313         * runtime/JSObject.h:
314         (JSC::JSObject::tryGetIndexQuickly):
315         (JSObject):
316         (JSC::JSObject::getDirectIndex):
317         (JSC::JSObject::getIndex):
318
319 2012-09-25  Filip Pizlo  <fpizlo@apple.com>
320
321         Structure check hoisting phase doesn't know about the side-effecting nature of Arrayify
322         https://bugs.webkit.org/show_bug.cgi?id=97537
323
324         Reviewed by Mark Hahnenberg.
325
326         No tests because if we use Arrayify then we also use PutByVal(BlankToXYZ), and the latter is
327         already known to be side-effecting. So this bug shouldn't have had any symptoms, as far as I
328         can tell.
329
330         * dfg/DFGStructureCheckHoistingPhase.cpp:
331         (JSC::DFG::StructureCheckHoistingPhase::run):
332
333 2012-09-25  Gavin Barraclough  <barraclough@apple.com>
334
335         Regression: put beyond vector length prefers prototype setters to sparse properties
336         https://bugs.webkit.org/show_bug.cgi?id=97593
337
338         Reviewed by Geoff Garen & Filip Pizlo.
339
340         * runtime/JSObject.cpp:
341         (JSC::JSObject::putByIndexBeyondVectorLength):
342             - Check for self properties in the sparse map - if present, don't examine the protochain.
343
344 2012-09-24  Gavin Barraclough  <barraclough@apple.com>
345
346         https://bugs.webkit.org/show_bug.cgi?id=97530
347         Regression, freeze applied to numeric properties of non-array objects
348
349         Reviewed by Filip Pizlo.
350
351         Object.freeze has a fast implementation in JSObject, but this hasn't been updated to take into account numeric properties in butterflies.
352         For now, just fall back to the generic implementation if the object has numeric properties.
353
354         * runtime/ObjectConstructor.cpp:
355         (JSC::objectConstructorFreeze):
356             - fallback if the object has a non-zero indexed property vector length.
357
358 2012-09-24  Gavin Barraclough  <barraclough@apple.com>
359
360         Bug in numeric accessors on global environment
361         https://bugs.webkit.org/show_bug.cgi?id=97526
362
363         Reviewed by Geoff Garen.
364
365         I've hit this assert in test262 in browser, but haven't yet worked out how to repro in a test case :-/
366         The sparsemap is failing to map back from the global object to the window shell.
367         A test case would need to resolve a numeric property name against the global environment.
368
369         (JSC::SparseArrayEntry::get):
370         (JSC::SparseArrayEntry::put):
371             - Add missing toThisObject calls.
372
373 2012-09-24  Filip Pizlo  <fpizlo@apple.com>
374
375         SerializedScriptValue isn't aware of indexed storage, but should be
376         https://bugs.webkit.org/show_bug.cgi?id=97515
377         <rdar://problem/12361874>
378
379         Reviewed by Sam Weinig.
380
381         Export a method that WebCore now uses.
382
383         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
384         * runtime/JSObject.h:
385         (JSObject):
386
387 2012-09-24  Gavin Barraclough  <barraclough@apple.com>
388
389         Remove JSObject::unwrappedGlobalObject(), JSObject::unwrappedObject()
390         https://bugs.webkit.org/show_bug.cgi?id=97519
391
392         Reviewed by Geoff Garen.
393
394         unwrappedGlobalObject() was only needed because globalObject() doesn't always return a helpful result -
395         specifically for WebCore's window shell the structure's globalObject is set to null. We can fix this by
396         simply keeping the structure up to date as the window navigates, obviating the need for this function.
397
398         The only other use of unwrappedObject() came from globalFuncEval(), and this can be trivially removed
399         by flipping the way we perform this globalObject check (which we may also be able to remove!) - instead
400         of getting the globalObject from the provided this value & comparing to the expected globalObject, we
401         can get the this value from the expected globalObject, and compare to that provided.
402
403         * runtime/JSGlobalObject.cpp:
404             - Call globalObject() instead of unwrappedGlobalObject().
405         * runtime/JSGlobalObjectFunctions.cpp:
406         (JSC::globalFuncEval):
407             - Changed to compare this object values, instead of globalObjects -
408               this means we only need to be able to map globalObject -> this,
409               and not vice versa.
410         * runtime/JSObject.cpp:
411         (JSC::JSObject::allowsAccessFrom):
412         (JSC::JSObject::createInheritorID):
413             - Call globalObject() instead of unwrappedGlobalObject().
414         * runtime/JSObject.h:
415         (JSObject):
416             - Removed unwrappedGlobalObject(), unwrappedObject().
417
418 2012-09-24  Mark Lam  <mark.lam@apple.com>
419
420         Deleting the classic interpreter and cleaning up some build options.
421         https://bugs.webkit.org/show_bug.cgi?id=96969.
422
423         Reviewed by Geoffrey Garen.
424
425         * bytecode/CodeBlock.cpp:
426         (JSC::CodeBlock::dump):
427         (JSC::CodeBlock::finalizeUnconditionally):
428         (JSC::CodeBlock::stronglyVisitStrongReferences):
429         (JSC):
430         * bytecode/Instruction.h:
431         (JSC::Instruction::Instruction):
432         * interpreter/AbstractPC.cpp:
433         (JSC::AbstractPC::AbstractPC):
434         * interpreter/AbstractPC.h:
435         (AbstractPC):
436         * interpreter/CallFrame.h:
437         (ExecState):
438         * interpreter/Interpreter.cpp:
439         (JSC):
440         (JSC::Interpreter::Interpreter):
441         (JSC::Interpreter::~Interpreter):
442         (JSC::Interpreter::initialize):
443         (JSC::Interpreter::isOpcode):
444         (JSC::Interpreter::unwindCallFrame):
445         (JSC::getLineNumberForCallFrame):
446         (JSC::getCallerInfo):
447         (JSC::getSourceURLFromCallFrame):
448         (JSC::Interpreter::execute):
449         (JSC::Interpreter::executeCall):
450         (JSC::Interpreter::executeConstruct):
451         (JSC::Interpreter::retrieveArgumentsFromVMCode):
452         (JSC::Interpreter::retrieveCallerFromVMCode):
453         (JSC::Interpreter::retrieveLastCaller):
454         * interpreter/Interpreter.h:
455         (JSC::Interpreter::getOpcodeID):
456         (Interpreter):
457         * jit/ExecutableAllocatorFixedVMPool.cpp:
458         (JSC::FixedVMPoolExecutableAllocator::FixedVMPoolExecutableAllocator):
459         * offlineasm/asm.rb:
460         * offlineasm/offsets.rb:
461         * runtime/Executable.cpp:
462         (JSC::EvalExecutable::compileInternal):
463         (JSC::ProgramExecutable::compileInternal):
464         (JSC::FunctionExecutable::compileForCallInternal):
465         (JSC::FunctionExecutable::compileForConstructInternal):
466         * runtime/Executable.h:
467         (JSC::NativeExecutable::create):
468         (NativeExecutable):
469         (JSC::NativeExecutable::finishCreation):
470         * runtime/JSGlobalData.cpp:
471         (JSC):
472         (JSC::JSGlobalData::JSGlobalData):
473         (JSC::JSGlobalData::getHostFunction):
474         * runtime/JSGlobalData.h:
475         (JSGlobalData):
476         (JSC::JSGlobalData::canUseJIT):
477         (JSC::JSGlobalData::canUseRegExpJIT):
478         * runtime/Options.cpp:
479         (JSC::Options::initialize):
480
481 2012-09-24  Filip Pizlo  <fpizlo@apple.com>
482
483         Nested try/finally should not confuse the finally unpopper in BytecodeGenerator::emitComplexJumpScopes
484         https://bugs.webkit.org/show_bug.cgi?id=97508
485         <rdar://problem/12361132>
486
487         Reviewed by Sam Weinig.
488
489         We're reusing some vector for multiple iterations of a loop, but we were forgetting to clear its
490         contents from one iteration to the next. Hence if you did multiple iterations of finally unpopping
491         (like in a nested try/finally and a jump out of both of them) then you'd get a corrupted try
492         context stack afterwards.
493
494         * bytecompiler/BytecodeGenerator.cpp:
495         (JSC::BytecodeGenerator::emitComplexJumpScopes):
496
497 2012-09-24  Filip Pizlo  <fpizlo@apple.com>
498
499         ValueToInt32 bool case does bad things to registers
500         https://bugs.webkit.org/show_bug.cgi?id=97505
501         <rdar://problem/12356331>
502
503         Reviewed by Mark Hahnenberg.
504
505         * dfg/DFGSpeculativeJIT.cpp:
506         (JSC::DFG::SpeculativeJIT::compileValueToInt32):
507
508 2012-09-24  Mark Lam  <mark.lam@apple.com>
509
510         Add cloopDo instruction for debugging the llint C++ backend.
511         https://bugs.webkit.org/show_bug.cgi?id=97502.
512
513         Reviewed by Geoffrey Garen.
514
515         * offlineasm/cloop.rb:
516         * offlineasm/instructions.rb:
517         * offlineasm/parser.rb:
518
519 2012-09-24  Filip Pizlo  <fpizlo@apple.com>
520
521         JSArray::putByIndex asserts with readonly property on prototype
522         https://bugs.webkit.org/show_bug.cgi?id=97435
523         <rdar://problem/12357084>
524
525         Reviewed by Geoffrey Garen.
526
527         Boy, there were some problems:
528         
529         - putDirectIndex() should know that it can set the index quickly even if it's a hole and we're
530           in SlowPut mode, since that's the whole point of PutDirect.
531         
532         - We should have a fast path for putByIndex().
533         
534         - The LiteralParser should not use push(), since that may throw if we're having a bad time.
535
536         * interpreter/Interpreter.cpp:
537         (JSC::eval):
538         * runtime/JSObject.h:
539         (JSC::JSObject::putByIndexInline):
540         (JSObject):
541         (JSC::JSObject::putDirectIndex):
542         * runtime/LiteralParser.cpp:
543         (JSC::::parse):
544
545 2012-09-24  Mark Lam  <mark.lam@apple.com>
546
547         Added a missing "if VALUE_PROFILER" around an access to ArrayProfile record.
548         https://bugs.webkit.org/show_bug.cgi?id=97496.
549
550         Reviewed by Filip Pizlo.
551
552         * llint/LowLevelInterpreter32_64.asm:
553         * llint/LowLevelInterpreter64.asm:
554
555 2012-09-24  Geoffrey Garen  <ggaren@apple.com>
556
557         Inlined activation tear-off in the DFG
558         https://bugs.webkit.org/show_bug.cgi?id=97487
559
560         Reviewed by Filip Pizlo.
561
562         * dfg/DFGOperations.cpp:
563         * dfg/DFGOperations.h: Activation tear-off is always inlined now, so I
564         removed its out-of-line implementation.
565
566         * dfg/DFGSpeculativeJIT32_64.cpp:
567         (JSC::DFG::SpeculativeJIT::compile):
568         * dfg/DFGSpeculativeJIT64.cpp:
569         (JSC::DFG::SpeculativeJIT::compile): Inlined the variable copy and update
570         of JSVariableObject::m_registers. This usually turns into < 10 instructions,
571         which is close to pure win as compared to the operation function call.
572
573         * runtime/JSActivation.h:
574         (JSActivation):
575         (JSC::JSActivation::registersOffset):
576         (JSC::JSActivation::tearOff):
577         (JSC::JSActivation::isTornOff):
578         (JSC):
579         (JSC::JSActivation::storageOffset):
580         (JSC::JSActivation::storage): Tiny bit of refactoring so the JIT can
581         share the pointer math helper functions we use internally.
582
583 2012-09-24  Balazs Kilvady  <kilvadyb@homejinni.com>
584
585         MIPS: store8 functions added to MacroAssembler.
586
587         MIPS store8 functions
588         https://bugs.webkit.org/show_bug.cgi?id=97243
589
590         Reviewed by Oliver Hunt.
591
592         Add MIPS store8 functions.
593
594         * assembler/MIPSAssembler.h:
595         (JSC::MIPSAssembler::lhu): New function.
596         (MIPSAssembler):
597         (JSC::MIPSAssembler::sb): New function.
598         (JSC::MIPSAssembler::sh): New function.
599         * assembler/MacroAssemblerMIPS.h:
600         (JSC::MacroAssemblerMIPS::store8): New function.
601         (MacroAssemblerMIPS):
602         (JSC::MacroAssemblerMIPS::store16): New function.
603
604 2012-09-23  Geoffrey Garen  <ggaren@apple.com>
605
606         PutScopedVar should not be marked as clobbering the world
607         https://bugs.webkit.org/show_bug.cgi?id=97416
608
609         Reviewed by Filip Pizlo.
610
611         No performance change.
612
613         PutScopedVar doesn't have arbitrary side-effects, so it shouldn't be marked
614         as such.
615
616         * dfg/DFGNodeType.h:
617         (DFG):
618
619 2012-09-23  Geoffrey Garen  <ggaren@apple.com>
620
621         I accidentally the whole 32-bit :(.
622
623         Unbreak the DFG in 32-bit with the 32-bit path I forgot in my last patch.
624
625         * dfg/DFGSpeculativeJIT32_64.cpp:
626         (JSC::DFG::SpeculativeJIT::compile):
627
628 2012-09-23  Byungwoo Lee  <bw80.lee@gmail.com>
629
630         Fix build warnings : -Wunused-parameter, -Wparentheses, -Wuninitialized.
631         https://bugs.webkit.org/show_bug.cgi?id=97306
632
633         Reviewed by Benjamin Poulain.
634
635         Fix build warning about -Wunused-parameter on MachineStackMarker.cpp,
636         LLIntSlowPaths.cpp, DatePrototype.cpp, Options.cpp by using
637         UNUSED_PARAM() macro or remove parameter name.
638
639         * heap/MachineStackMarker.cpp:
640         (JSC::pthreadSignalHandlerSuspendResume):
641         * llint/LLIntSlowPaths.cpp:
642         (JSC::LLInt::entryOSR):
643         * runtime/DatePrototype.cpp:
644         (JSC::formatLocaleDate):
645         * runtime/Options.cpp:
646         (JSC::computeNumberOfGCMarkers):
647
648 2012-09-23  Gavin Barraclough  <barraclough@apple.com>
649
650         Sorting a non-array creates propreties (spec-violation)
651         https://bugs.webkit.org/show_bug.cgi?id=25477
652
653         Reviewed by Oliver Hunt.
654
655         We're just calling get() to get properties, which is converting missing properties to
656         undefined. Hole values should be retained, and moved to the end of the array.
657
658         * runtime/ArrayPrototype.cpp:
659         (JSC::getOrHole):
660             - Helper function, returns JSValue() instead of undefined for missing properties.
661         (JSC::arrayProtoFuncSort):
662             - Implemented per 15.4.4.11, see comments above.
663
664 2012-09-23  Geoffrey Garen  <ggaren@apple.com>
665
666         CSE for access to closure variables (get_/put_scoped_var)
667         https://bugs.webkit.org/show_bug.cgi?id=97414
668
669         Reviewed by Oliver Hunt.
670
671         I separated loading a scope from loading its storage pointer, so we can
672         CSE the storage pointer load. Then, I copied the global var CSE and adjusted
673         it for closure vars.
674
675         * dfg/DFGAbstractState.cpp:
676         (JSC::DFG::AbstractState::execute): Renamed GetScopeChain => GetScope to
677         reflect renames from a few weeks ago.
678
679         Added a case for the storage pointer load, similar to object storage pointer load.
680
681         * dfg/DFGByteCodeParser.cpp:
682         (JSC::DFG::ByteCodeParser::parseBlock): Added an independent node for
683         the storage pointer.
684
685         * dfg/DFGCSEPhase.cpp:
686         (JSC::DFG::CSEPhase::scopedVarLoadElimination):
687         (CSEPhase):
688         (JSC::DFG::CSEPhase::scopedVarStoreElimination):
689         (JSC::DFG::CSEPhase::getScopeLoadElimination):
690         (JSC::DFG::CSEPhase::getScopeRegistersLoadElimination):
691         (JSC::DFG::CSEPhase::setLocalStoreElimination):
692         (JSC::DFG::CSEPhase::performNodeCSE): Copied globalVarLoad/StoreElimination
693         and adapted the same logic to closure vars.
694
695         * dfg/DFGNode.h:
696         (JSC::DFG::Node::hasScopeChainDepth):
697         (JSC::DFG::Node::scope):
698         (Node):
699         * dfg/DFGNodeType.h:
700         (DFG): GetScopedVar and GetGlobalVar are no longer MustGenerate. I'm not
701         sure why they ever were. But these are simple load operations so, if they're
702         unused, they're truly dead.
703
704         * dfg/DFGPredictionPropagationPhase.cpp:
705         (JSC::DFG::PredictionPropagationPhase::propagate):
706         * dfg/DFGSpeculativeJIT32_64.cpp:
707         (JSC::DFG::SpeculativeJIT::compile):
708         * dfg/DFGSpeculativeJIT64.cpp:
709         (JSC::DFG::SpeculativeJIT::compile): Updated for renames and split-out
710         node for getting the storage pointer.
711
712 2012-09-21  Geoffrey Garen  <ggaren@apple.com>
713
714         Unreviewed, rolled out a line I committed by accident.
715
716         * interpreter/Interpreter.cpp:
717         (JSC::Interpreter::execute):
718
719 2012-09-21  Geoffrey Garen  <ggaren@apple.com>
720
721         Optimized closures that capture arguments
722         https://bugs.webkit.org/show_bug.cgi?id=97358
723
724         Reviewed by Oliver Hunt.
725
726         Previously, the activation object was responsible for capturing all
727         arguments in a way that was convenient for the arguments object. Now,
728         we move all captured variables into a contiguous region in the stack,
729         allocate an activation for exactly that size, and make the arguments
730         object responsible for knowing all the places to which arguments could
731         have moved.
732
733         This seems like the right tradeoff because
734
735             (a) Closures are common and long-lived, so we want them to be small.
736
737             (b) Our primary strategy for optimizing the arguments object is to make
738             it go away. If you're allocating arguments objects, you're already having
739             a bad time.
740
741             (c) It's common to use either the arguments object or named argument
742             closure, but not both.
743
744         * bytecode/CodeBlock.cpp:
745         (JSC::CodeBlock::dump):
746         (JSC::CodeBlock::CodeBlock):
747         * bytecode/CodeBlock.h:
748         (JSC::CodeBlock::argumentsRegister):
749         (JSC::CodeBlock::activationRegister):
750         (JSC::CodeBlock::isCaptured):
751         (JSC::CodeBlock::argumentIndexAfterCapture): m_numCapturedVars is gone
752         now -- we have an explicit range instead.
753
754         * bytecompiler/BytecodeGenerator.cpp:
755         (JSC::BytecodeGenerator::BytecodeGenerator): Move captured arguments
756         into the captured region of local variables for space efficiency. Record
757         precise data about where they moved for the sake of the arguments object.
758
759         Some of this data was previously wrong, but it didn't cause any problems
760         because the arguments weren't actually moving.
761
762         * dfg/DFGByteCodeParser.cpp:
763         (JSC::DFG::ByteCodeParser::flushArgumentsAndCapturedVariables): Don't
764         assume that captured vars are in any particular location -- always ask
765         the CodeBlock. This is better encapsulation.
766
767         (JSC::DFG::ByteCodeParser::parseCodeBlock):
768         * dfg/DFGSpeculativeJIT32_64.cpp:
769         (JSC::DFG::SpeculativeJIT::compile):
770         * dfg/DFGSpeculativeJIT64.cpp:
771         (JSC::DFG::SpeculativeJIT::compile): I rename things sometimes.
772
773         * runtime/Arguments.cpp:
774         (JSC::Arguments::tearOff): Account for a particularly nasty edge case.
775
776         (JSC::Arguments::didTearOffActivation): Don't allocate our slow arguments
777         data on tear-off. We need to allocate it eagerly instead, since we need
778         to know about displaced, captured arguments during access before tear-off.
779
780         * runtime/Arguments.h:
781         (JSC::Arguments::allocateSlowArguments):
782         (JSC::Arguments::argument): Tell our slow arguments array where all arguments
783         are, even if they are not captured. This simplifies some things, so we don't
784         have to account explicitly for the full matrix of (not torn off, torn off)
785         * (captured, not captured).
786
787         (JSC::Arguments::finishCreation): Allocate our slow arguments array eagerly
788         because we need to know about displaced, captured arguments during access
789         before tear-off.
790
791         * runtime/Executable.cpp:
792         (JSC::FunctionExecutable::FunctionExecutable):
793         (JSC::FunctionExecutable::compileForCallInternal):
794         (JSC::FunctionExecutable::compileForConstructInternal):
795         * runtime/Executable.h:
796         (JSC::FunctionExecutable::parameterCount):
797         (FunctionExecutable):
798         * runtime/JSActivation.cpp:
799         (JSC::JSActivation::visitChildren):
800         * runtime/JSActivation.h:
801         (JSActivation):
802         (JSC::JSActivation::create):
803         (JSC::JSActivation::JSActivation):
804         (JSC::JSActivation::registerOffset):
805         (JSC::JSActivation::tearOff):
806         (JSC::JSActivation::allocationSize):
807         (JSC::JSActivation::isValid): This is really the point of the patch. All
808         the pointer math in Activations basically boils away, since we always
809         copy a contiguous region of captured variables now.
810
811         * runtime/SymbolTable.h:
812         (JSC::SlowArgument::SlowArgument):
813         (SlowArgument):
814         (SharedSymbolTable):
815         (JSC::SharedSymbolTable::captureCount):
816         (JSC::SharedSymbolTable::SharedSymbolTable): AllOfTheThings capture mode
817         is gone now -- that's the point of the patch. indexIfCaptured gets renamed
818         to index because we always have an index, even if not captured. (The only
819         time when the index is meaningless is when we're Deleted.)
820
821 2012-09-21  Gavin Barraclough  <barraclough@apple.com>
822
823         Eeeep - broke early boyer in bug#97382
824         https://bugs.webkit.org/show_bug.cgi?id=97383
825
826         Rubber stamped by Sam Weinig.
827
828         missed a child3 -> child2!
829
830         * dfg/DFGSpeculativeJIT.cpp:
831         (JSC::DFG::SpeculativeJIT::compileInstanceOf):
832
833 2012-09-21  Gavin Barraclough  <barraclough@apple.com>
834
835         Unreviewed windows build fix.
836
837         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
838
839 2012-09-21  Gavin Barraclough  <barraclough@apple.com>
840
841         Pedantic test in Mozilla's JavaScript test suite fails. function-001.js function-001-n.js
842         https://bugs.webkit.org/show_bug.cgi?id=27219
843
844         Reviewed by Sam Weinig.
845
846         These tests are just wrong.
847         See ECMA 262 A.5, FunctionDelcaration does not require a semicolon.
848
849         * tests/mozilla/expected.html:
850         * tests/mozilla/js1_2/function/function-001-n.js:
851         * tests/mozilla/js1_3/Script/function-001-n.js:
852         * tests/mozilla/js1_3/regress/function-001-n.js:
853
854 2012-09-21  Gavin Barraclough  <barraclough@apple.com>
855
856         Remove redundant argument to op_instanceof
857         https://bugs.webkit.org/show_bug.cgi?id=97382
858
859         Reviewed by Geoff Garen.
860
861         No longer needed after my last change.
862
863         * bytecode/CodeBlock.cpp:
864         (JSC::CodeBlock::dump):
865         * bytecode/Opcode.h:
866         (JSC):
867         (JSC::padOpcodeName):
868         * bytecompiler/BytecodeGenerator.cpp:
869         (JSC::BytecodeGenerator::emitInstanceOf):
870         * bytecompiler/BytecodeGenerator.h:
871         (BytecodeGenerator):
872         * bytecompiler/NodesCodegen.cpp:
873         (JSC::InstanceOfNode::emitBytecode):
874         * dfg/DFGAbstractState.cpp:
875         (JSC::DFG::AbstractState::execute):
876         * dfg/DFGByteCodeParser.cpp:
877         (JSC::DFG::ByteCodeParser::parseBlock):
878         * dfg/DFGSpeculativeJIT.cpp:
879         (JSC::DFG::SpeculativeJIT::compileInstanceOf):
880         * interpreter/Interpreter.cpp:
881         (JSC::Interpreter::privateExecute):
882         * jit/JITOpcodes.cpp:
883         (JSC::JIT::emit_op_instanceof):
884         (JSC::JIT::emitSlow_op_instanceof):
885         * jit/JITOpcodes32_64.cpp:
886         (JSC::JIT::emit_op_instanceof):
887         (JSC::JIT::emitSlow_op_instanceof):
888         * jit/JITStubs.cpp:
889         (JSC::DEFINE_STUB_FUNCTION):
890         * llint/LLIntSlowPaths.cpp:
891         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
892         * llint/LowLevelInterpreter32_64.asm:
893         * llint/LowLevelInterpreter64.asm:
894
895 2012-09-21  Gavin Barraclough  <barraclough@apple.com>
896
897         Unreviewed windows build fix.
898
899         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
900
901 2012-09-21  Gavin Barraclough  <barraclough@apple.com>
902
903         instanceof should not get the prototype for non-default HasInstance
904         https://bugs.webkit.org/show_bug.cgi?id=68656
905
906         Reviewed by Oliver Hunt.
907
908         Instanceof is currently implemented as a sequance of three opcodes:
909             check_has_instance
910             get_by_id(prototype)
911             op_instanceof
912         There are three interesting types of base value that instanceof can be applied to:
913             (A) Objects supporting default instanceof behaviour (functions, other than those created with bind)
914             (B) Objects overriding the default instancecof behaviour with a custom one (API objects, bound functions)
915             (C) Values that do not respond to the [[HasInstance]] trap.
916         Currently check_has_instance handles case (C), leaving the op_instanceof opcode to handle (A) & (B). There are
917         two problems with this apporach. Firstly, this is suboptimal for case (A), since we have to check for
918         hasInstance support twice (once in check_has_instance, then for default behaviour in op_instanceof). Secondly,
919         this means that in cases (B) we also perform the get_by_id, which is both suboptimal and an observable spec
920         violation.
921
922         The fix here is to move handing of non-default instanceof (cases (B)) to the check_has_instance op, leaving
923         op_instanceof to handle only cases (A).
924
925         * API/JSCallbackObject.h:
926         (JSCallbackObject):
927         * API/JSCallbackObjectFunctions.h:
928         (JSC::::customHasInstance):
929         * API/JSValueRef.cpp:
930         (JSValueIsInstanceOfConstructor):
931             - renamed hasInstance to customHasInstance
932         * bytecode/CodeBlock.cpp:
933         (JSC::CodeBlock::dump):
934             - added additional parameters to check_has_instance opcode
935         * bytecode/Opcode.h:
936         (JSC):
937         (JSC::padOpcodeName):
938             - added additional parameters to check_has_instance opcode
939         * bytecompiler/BytecodeGenerator.cpp:
940         (JSC::BytecodeGenerator::emitCheckHasInstance):
941             - added additional parameters to check_has_instance opcode
942         * bytecompiler/BytecodeGenerator.h:
943         (BytecodeGenerator):
944             - added additional parameters to check_has_instance opcode
945         * bytecompiler/NodesCodegen.cpp:
946         (JSC::InstanceOfNode::emitBytecode):
947             - added additional parameters to check_has_instance opcode
948         * dfg/DFGByteCodeParser.cpp:
949         (JSC::DFG::ByteCodeParser::parseBlock):
950             - added additional parameters to check_has_instance opcode
951         * interpreter/Interpreter.cpp:
952         (JSC::isInvalidParamForIn):
953         (JSC::Interpreter::privateExecute):
954             - Add handling for non-default instanceof to op_check_has_instance
955         * jit/JITInlineMethods.h:
956         (JSC::JIT::emitArrayProfilingSiteForBytecodeIndex):
957             - Fixed no-LLInt no_DFG build
958         * jit/JITOpcodes.cpp:
959         (JSC::JIT::emit_op_check_has_instance):
960         (JSC::JIT::emitSlow_op_check_has_instance):
961             - check for ImplementsDefaultHasInstance, handle additional arguments to op_check_has_instance.
962         (JSC::JIT::emit_op_instanceof):
963         (JSC::JIT::emitSlow_op_instanceof):
964             - no need to check for ImplementsDefaultHasInstance.
965         * jit/JITOpcodes32_64.cpp:
966         (JSC::JIT::emit_op_check_has_instance):
967         (JSC::JIT::emitSlow_op_check_has_instance):
968             - check for ImplementsDefaultHasInstance, handle additional arguments to op_check_has_instance.
969         (JSC::JIT::emit_op_instanceof):
970         (JSC::JIT::emitSlow_op_instanceof):
971             - no need to check for ImplementsDefaultHasInstance.
972         * jit/JITStubs.cpp:
973         (JSC::DEFINE_STUB_FUNCTION):
974         * jit/JITStubs.h:
975             - Add handling for non-default instanceof to op_check_has_instance
976         * llint/LLIntSlowPaths.cpp:
977         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
978         * llint/LowLevelInterpreter32_64.asm:
979         * llint/LowLevelInterpreter64.asm:
980             - move check for ImplementsDefaultHasInstance, handle additional arguments to op_check_has_instance.
981         * runtime/ClassInfo.h:
982         (MethodTable):
983         (JSC):
984             - renamed hasInstance to customHasInstance
985         * runtime/CommonSlowPaths.h:
986         (CommonSlowPaths):
987             - removed opInstanceOfSlow (this was whittled down to one function call!)
988         * runtime/JSBoundFunction.cpp:
989         (JSC::JSBoundFunction::customHasInstance):
990         * runtime/JSBoundFunction.h:
991         (JSBoundFunction):
992             - renamed hasInstance to customHasInstance, reimplemented.
993         * runtime/JSCell.cpp:
994         (JSC::JSCell::customHasInstance):
995         * runtime/JSCell.h:
996         (JSCell):
997         * runtime/JSObject.cpp:
998         (JSC::JSObject::hasInstance):
999         (JSC):
1000         (JSC::JSObject::defaultHasInstance):
1001         * runtime/JSObject.h:
1002         (JSObject):
1003
1004 2012-09-21  Filip Pizlo  <fpizlo@apple.com>
1005
1006         Unreviewed, fix ARM build.
1007
1008         * assembler/MacroAssemblerARMv7.h:
1009         (JSC::MacroAssemblerARMv7::store8):
1010         (MacroAssemblerARMv7):
1011         * offlineasm/armv7.rb:
1012
1013 2012-09-21  Filip Pizlo  <fpizlo@apple.com>
1014
1015         REGRESSION (r128400): Opening Google Web Fonts page hangs or crashes
1016         https://bugs.webkit.org/show_bug.cgi?id=97328
1017
1018         Reviewed by Mark Hahnenberg.
1019
1020         It's a bad idea to emit stub code that reallocates property storage when we're in indexed
1021         storage mode. DFGRepatch.cpp knew this and had the appropriate check in one of the places,
1022         but it didn't have it in all of the places.
1023         
1024         This change also adds some more handy disassembly support, which I used to find the bug.
1025
1026         * assembler/LinkBuffer.h:
1027         (JSC):
1028         * dfg/DFGRepatch.cpp:
1029         (JSC::DFG::generateProtoChainAccessStub):
1030         (JSC::DFG::tryCacheGetByID):
1031         (JSC::DFG::tryBuildGetByIDList):
1032         (JSC::DFG::emitPutReplaceStub):
1033         (JSC::DFG::emitPutTransitionStub):
1034         (JSC::DFG::tryCachePutByID):
1035         * jit/JITStubRoutine.h:
1036         (JSC):
1037
1038 2012-09-21  Filip Pizlo  <fpizlo@apple.com>
1039
1040         DFG CSE assumes that a holy PutByVal does not interfere with GetArrayLength, when it clearly does
1041         https://bugs.webkit.org/show_bug.cgi?id=97373
1042
1043         Reviewed by Mark Hahnenberg.
1044
1045         * dfg/DFGCSEPhase.cpp:
1046         (JSC::DFG::CSEPhase::pureCSE):
1047         (JSC::DFG::CSEPhase::getArrayLengthElimination):
1048         (JSC::DFG::CSEPhase::putStructureStoreElimination):
1049         (JSC::DFG::CSEPhase::performNodeCSE):
1050         * dfg/DFGGraph.h:
1051         (Graph):
1052
1053 2012-09-21  Chris Rogers  <crogers@google.com>
1054
1055         Add Web Audio support for deprecated/legacy APIs
1056         https://bugs.webkit.org/show_bug.cgi?id=97050
1057
1058         Reviewed by Eric Carlson.
1059
1060         * Configurations/FeatureDefines.xcconfig:
1061
1062 2012-09-21  Gavin Barraclough  <barraclough@apple.com>
1063
1064         Global Math object should be configurable but isn't
1065         https://bugs.webkit.org/show_bug.cgi?id=55343
1066
1067         Reviewed by Oliver Hunt.
1068
1069         This has no performance impact.
1070
1071         * runtime/JSGlobalObject.cpp:
1072         (JSC::JSGlobalObject::reset):
1073             - Make 'Math' a regular property.
1074
1075 2012-09-21  Chao-ying Fu  <fu@mips.com>
1076
1077         Add MIPS or32 function
1078         https://bugs.webkit.org/show_bug.cgi?id=97157
1079
1080         Reviewed by Gavin Barraclough.
1081
1082         Add a missing or32 function.
1083
1084         * assembler/MacroAssemblerMIPS.h:
1085         (JSC::MacroAssemblerMIPS::or32): New function.
1086         (MacroAssemblerMIPS):
1087
1088 2012-09-20  Filip Pizlo  <fpizlo@apple.com>
1089
1090         CHECK_ARRAY_CONSISTENCY isn't being used or tested, so we should remove it
1091         https://bugs.webkit.org/show_bug.cgi?id=97260
1092
1093         Rubber stamped by Geoffrey Garen.
1094         
1095         Supporting it will become difficult as we add more indexing types. It makes more
1096         sense to kill, especially since we don't appear to use it or test it, ever.
1097
1098         * runtime/ArrayConventions.h:
1099         (JSC):
1100         * runtime/ArrayPrototype.cpp:
1101         (JSC::arrayProtoFuncSplice):
1102         * runtime/ArrayStorage.h:
1103         (JSC::ArrayStorage::copyHeaderFromDuringGC):
1104         (ArrayStorage):
1105         * runtime/FunctionPrototype.cpp:
1106         (JSC::functionProtoFuncBind):
1107         * runtime/JSArray.cpp:
1108         (JSC::createArrayButterflyInDictionaryIndexingMode):
1109         (JSC::JSArray::setLength):
1110         (JSC::JSArray::pop):
1111         (JSC::JSArray::push):
1112         (JSC::JSArray::sortNumeric):
1113         (JSC::JSArray::sort):
1114         (JSC::JSArray::compactForSorting):
1115         * runtime/JSArray.h:
1116         (JSArray):
1117         (JSC::createArrayButterfly):
1118         (JSC::JSArray::tryCreateUninitialized):
1119         (JSC::constructArray):
1120         * runtime/JSObject.cpp:
1121         (JSC::JSObject::putByIndex):
1122         (JSC::JSObject::createArrayStorage):
1123         (JSC::JSObject::deletePropertyByIndex):
1124         (JSC):
1125         * runtime/JSObject.h:
1126         (JSC::JSObject::initializeIndex):
1127         (JSObject):
1128
1129 2012-09-20  Mark Lam  <mark.lam@apple.com>
1130
1131         Fixed a missing semicolon in the C++ llint backend.
1132         https://bugs.webkit.org/show_bug.cgi?id=97252.
1133
1134         Reviewed by Geoff Garen.
1135
1136         * offlineasm/cloop.rb:
1137
1138 2012-09-20  Geoffrey Garen  <ggaren@apple.com>
1139
1140         Refactored the interpreter and JIT so they don't dictate closure layout
1141         https://bugs.webkit.org/show_bug.cgi?id=97221
1142
1143         Reviewed by Oliver Hunt.
1144
1145         Capture may change the location of an argument for space efficiency. This
1146         patch removes static assumptions about argument location from the interpreter
1147         and JIT.
1148
1149         * bytecode/CodeBlock.h:
1150         (JSC::CodeBlock::argumentIndexAfterCapture):
1151         (JSC::ExecState::argumentAfterCapture): Factored out a helper function
1152         so the compiler could share this logic.
1153
1154         * bytecompiler/NodesCodegen.cpp:
1155         (JSC::BracketAccessorNode::emitBytecode): Don't emit optimized bracket
1156         access on arguments if a parameter has been captured by name. This case is
1157         rare and, where I've seen it in the wild, the optimization mostly failed
1158         anyway due to arguments escape, so I didn't feel like writing and testing
1159         five copies of the code that would handle it in the baseline engines.
1160
1161         The DFG can still synthesize this optimization even if we don't emit the
1162         optimized bytecode for it.
1163
1164         * dfg/DFGArgumentsSimplificationPhase.cpp:
1165         (JSC::DFG::ArgumentsSimplificationPhase::run):
1166         * dfg/DFGAssemblyHelpers.h:
1167         (JSC::DFG::AssemblyHelpers::symbolTableFor):
1168         (AssemblyHelpers): Use the right helper function to account for the fact
1169         that a parameter may have been captured by name and moved.
1170
1171         * dfg/DFGByteCodeParser.cpp:
1172         (JSC::DFG::ByteCodeParser::parseBlock): ASSERT that we haven't inlined
1173         a .apply on captured arguments. Once we do start inlining such things,
1174         we'll need to do a little bit of math here to get them right.
1175
1176         * dfg/DFGSpeculativeJIT32_64.cpp:
1177         (JSC::DFG::SpeculativeJIT::compile):
1178         * dfg/DFGSpeculativeJIT64.cpp:
1179         (JSC::DFG::SpeculativeJIT::compile): Added support for bracket access on
1180         an arguments object where arguments have also been captured by name. We
1181         load the true index of the argument from a side vector. Arguments elision
1182         is very powerful in the DFG, so I wanted to keep it working, even in this
1183         rare case.
1184
1185         * interpreter/Interpreter.cpp:
1186         (JSC::loadVarargs): Use the right helper function to account for the fact
1187         that a parameter may have been captured by name and moved.
1188
1189         * jit/JITCall.cpp:
1190         (JSC::JIT::compileLoadVarargs):
1191         * jit/JITCall32_64.cpp:
1192         (JSC::JIT::compileLoadVarargs): Don't use the inline copy loop if some
1193         of our arguments have moved, since it would copy stale values. (We still
1194         optimize the actual call, and elide the arguments object.)
1195
1196 2012-09-20  Gabor Rapcsanyi  <rgabor@webkit.org>
1197
1198         [Qt] r129045 broke the ARM build
1199         https://bugs.webkit.org/show_bug.cgi?id=97195
1200
1201         Reviewed by Zoltan Herczeg.
1202
1203         Implementing missing store8 function.
1204
1205         * assembler/MacroAssemblerARM.h:
1206         (JSC::MacroAssemblerARM::store8):
1207         (MacroAssemblerARM):
1208
1209 2012-09-19  Geoffrey Garen  <ggaren@apple.com>
1210
1211         OSR exit sometimes neglects to create the arguments object
1212         https://bugs.webkit.org/show_bug.cgi?id=97162
1213
1214         Reviewed by Filip Pizlo.
1215
1216         No performance change.
1217
1218         I don't know of any case where this is a real problem in TOT, but it
1219         will become a problem if we start compiling eval, with, or catch, and/or
1220         sometimes stop doing arguments optimizations in the bytecode.
1221
1222         * dfg/DFGArgumentsSimplificationPhase.cpp:
1223         (JSC::DFG::ArgumentsSimplificationPhase::run): Account for a
1224         CreateArguments that has transformed into PhantomArguments. We used to
1225         clear our reference to the CreateArguments node, but now we hold onto it, 
1226         so we need to account for it transforming.
1227
1228         Don't replace a SetLocal(CreateArguments) with a SetLocal(JSValue())
1229         because that doesn't leave enough information behind for OSR exit to do
1230         the right thing. Instead, maintain our reference to CreateArguments, and
1231         rely on CreateArguments transforming into PhantomArguments after
1232         optimization. SetLocal(PhantomArguments) is efficient, and it's a marker
1233         for OSR exit to create the arguments object.
1234
1235         Don't ASSERT that all PhantomArguments are unreferenced because we now
1236         leave them in the graph as SetLocal(PhantomArguments), and that's harmless.
1237
1238         * dfg/DFGArgumentsSimplificationPhase.h:
1239         (NullableHashTraits):
1240         (JSC::DFG::NullableHashTraits::emptyValue): Export our special hash table
1241         for inline call frames so the OSR exit compiler can use it.
1242
1243         * dfg/DFGOSRExitCompiler32_64.cpp:
1244         (JSC::DFG::OSRExitCompiler::compileExit):
1245         * dfg/DFGOSRExitCompiler64.cpp:
1246         (JSC::DFG::OSRExitCompiler::compileExit): Don't load the 'arguments'
1247         register to decide if we need to create the arguments object. Optimization
1248         may have eliminated the initializing store to this register, in which
1249         case we'll load garbage. Instead, use the global knowledge that all call
1250         frames that optimized out 'arguments' now need to create it, and use a hash
1251         table to make sure we do so only once per call frame.
1252
1253         * dfg/DFGSpeculativeJIT64.cpp:
1254         (JSC::DFG::SpeculativeJIT::compile): SetLocal(PhantomArguments) is unique
1255         because we haven't just changed a value's format or elided a load or store;
1256         instead, we've replaced an object with JSValue(). We could try to account
1257         for this in a general way, but for now it's a special-case optimization,
1258         so we give it a specific OSR hint instead.
1259
1260 2012-09-19  Filip Pizlo  <fpizlo@apple.com>
1261
1262         REGRESSION(r128802): It made some JS tests crash
1263         https://bugs.webkit.org/show_bug.cgi?id=97001
1264
1265         Reviewed by Mark Hahnenberg.
1266
1267         * runtime/JSGlobalObject.cpp:
1268         (JSC::JSGlobalObject::visitChildren):
1269
1270 2012-09-19  Filip Pizlo  <fpizlo@apple.com>
1271
1272         DFG should not assume that a ByVal access is generic just because it was unprofiled
1273         https://bugs.webkit.org/show_bug.cgi?id=97088
1274
1275         Reviewed by Geoffrey Garen.
1276         
1277         We were not disambiguating between "Undecided" in the sense that the array profile
1278         has no useful information versus "Undecided" in the sense that the array profile
1279         knows that the access has not executed. That's an important distinction, since
1280         the former form of "Undecided" means that we should consult value profiling, while
1281         the latter means that we should force exit unless the value profiling indicates
1282         that the access must be generic (base is not cell or property is not int).
1283
1284         * dfg/DFGAbstractState.cpp:
1285         (JSC::DFG::AbstractState::execute):
1286         * dfg/DFGArrayMode.cpp:
1287         (JSC::DFG::fromObserved):
1288         (JSC::DFG::refineArrayMode):
1289         (JSC::DFG::modeAlreadyChecked):
1290         (JSC::DFG::modeToString):
1291         * dfg/DFGArrayMode.h:
1292         (JSC::DFG::canCSEStorage):
1293         (JSC::DFG::modeIsSpecific):
1294         (JSC::DFG::modeSupportsLength):
1295         (JSC::DFG::benefitsFromStructureCheck):
1296
1297 2012-09-19  Filip Pizlo  <fpizlo@apple.com>
1298
1299         DFG should not emit PutByVal hole case unless it has to
1300         https://bugs.webkit.org/show_bug.cgi?id=97080
1301
1302         Reviewed by Geoffrey Garen.
1303
1304         This causes us to generate less code for typical PutByVal's. But if profiling tells us
1305         that the hole case is being hit, we generate the same code as we would have generated
1306         before. This seems like a slight speed-up across the board.
1307
1308         * assembler/MacroAssemblerARMv7.h:
1309         (JSC::MacroAssemblerARMv7::store8):
1310         (MacroAssemblerARMv7):
1311         * assembler/MacroAssemblerX86.h:
1312         (MacroAssemblerX86):
1313         (JSC::MacroAssemblerX86::store8):
1314         * assembler/MacroAssemblerX86_64.h:
1315         (MacroAssemblerX86_64):
1316         (JSC::MacroAssemblerX86_64::store8):
1317         * assembler/X86Assembler.h:
1318         (X86Assembler):
1319         (JSC::X86Assembler::movb_i8m):
1320         * bytecode/ArrayProfile.h:
1321         (JSC::ArrayProfile::ArrayProfile):
1322         (JSC::ArrayProfile::addressOfMayStoreToHole):
1323         (JSC::ArrayProfile::mayStoreToHole):
1324         (ArrayProfile):
1325         * dfg/DFGArrayMode.cpp:
1326         (JSC::DFG::fromObserved):
1327         (JSC::DFG::modeAlreadyChecked):
1328         (JSC::DFG::modeToString):
1329         * dfg/DFGArrayMode.h:
1330         (DFG):
1331         (JSC::DFG::mayStoreToHole):
1332         * dfg/DFGSpeculativeJIT32_64.cpp:
1333         (JSC::DFG::SpeculativeJIT::compile):
1334         * dfg/DFGSpeculativeJIT64.cpp:
1335         (JSC::DFG::SpeculativeJIT::compile):
1336         * jit/JIT.h:
1337         (JIT):
1338         * jit/JITInlineMethods.h:
1339         (JSC::JIT::emitArrayProfileStoreToHoleSpecialCase):
1340         (JSC):
1341         * jit/JITPropertyAccess.cpp:
1342         (JSC::JIT::emit_op_put_by_val):
1343         * jit/JITPropertyAccess32_64.cpp:
1344         (JSC::JIT::emit_op_put_by_val):
1345         * llint/LowLevelInterpreter32_64.asm:
1346         * llint/LowLevelInterpreter64.asm:
1347
1348 2012-09-18  Filip Pizlo  <fpizlo@apple.com>
1349
1350         DFG should not call out to C++ every time that it tries to put to an object that doesn't yet have array storage
1351         https://bugs.webkit.org/show_bug.cgi?id=96983
1352
1353         Reviewed by Oliver Hunt.
1354
1355         Introduce more polymorphism into the DFG's array mode support. Use that to
1356         introduce the notion of effectul array modes, where the check for the mode
1357         will perform actions necessary to ensure that we have the mode we want, if
1358         the object is not already in that mode. Also added profiling support for
1359         checking if an object is of a type that would not allow us to create array
1360         storage (like a typed array or a string for example).
1361         
1362         This is a ~2x speed-up on loops that transform an object that did not have
1363         indexed storage into one that does.
1364
1365         * JSCTypedArrayStubs.h:
1366         (JSC):
1367         * bytecode/ArrayProfile.cpp:
1368         (JSC::ArrayProfile::computeUpdatedPrediction):
1369         * bytecode/ArrayProfile.h:
1370         (JSC::ArrayProfile::ArrayProfile):
1371         (JSC::ArrayProfile::mayInterceptIndexedAccesses):
1372         (ArrayProfile):
1373         * dfg/DFGAbstractState.cpp:
1374         (JSC::DFG::AbstractState::execute):
1375         * dfg/DFGArrayMode.cpp:
1376         (JSC::DFG::fromObserved):
1377         (DFG):
1378         (JSC::DFG::modeAlreadyChecked):
1379         (JSC::DFG::modeToString):
1380         * dfg/DFGArrayMode.h:
1381         (DFG):
1382         (JSC::DFG::modeUsesButterfly):
1383         (JSC::DFG::isSlowPutAccess):
1384         (JSC::DFG::benefitsFromStructureCheck):
1385         (JSC::DFG::isEffectful):
1386         * dfg/DFGByteCodeParser.cpp:
1387         (JSC::DFG::ByteCodeParser::getArrayMode):
1388         (JSC::DFG::ByteCodeParser::getArrayModeAndEmitChecks):
1389         (JSC::DFG::ByteCodeParser::parseBlock):
1390         * dfg/DFGCSEPhase.cpp:
1391         (JSC::DFG::CSEPhase::getPropertyStorageLoadElimination):
1392         * dfg/DFGFixupPhase.cpp:
1393         (JSC::DFG::FixupPhase::fixupNode):
1394         (JSC::DFG::FixupPhase::checkArray):
1395         * dfg/DFGGraph.h:
1396         (JSC::DFG::Graph::byValIsPure):
1397         * dfg/DFGNode.h:
1398         (JSC::DFG::Node::hasArrayMode):
1399         * dfg/DFGNodeType.h:
1400         (DFG):
1401         * dfg/DFGOperations.cpp:
1402         * dfg/DFGOperations.h:
1403         * dfg/DFGPredictionPropagationPhase.cpp:
1404         (JSC::DFG::PredictionPropagationPhase::propagate):
1405         * dfg/DFGSpeculativeJIT.cpp:
1406         (JSC::DFG::SpeculativeJIT::checkArray):
1407         (JSC::DFG::SpeculativeJIT::arrayify):
1408         (DFG):
1409         * dfg/DFGSpeculativeJIT.h:
1410         (SpeculativeJIT):
1411         * dfg/DFGSpeculativeJIT32_64.cpp:
1412         (JSC::DFG::SpeculativeJIT::compile):
1413         * dfg/DFGSpeculativeJIT64.cpp:
1414         (JSC::DFG::SpeculativeJIT::compile):
1415         * runtime/Arguments.h:
1416         (Arguments):
1417         * runtime/JSNotAnObject.h:
1418         (JSNotAnObject):
1419         * runtime/JSObject.h:
1420         (JSObject):
1421         (JSC::JSObject::ensureArrayStorage):
1422         * runtime/JSString.h:
1423         (JSC::JSString::createStructure):
1424
1425 2012-09-18  Filip Pizlo  <fpizlo@apple.com>
1426
1427         Include PhantomArguments in DFGDisassembly
1428         https://bugs.webkit.org/show_bug.cgi?id=97043
1429
1430         Reviewed by Geoffrey Garen.
1431
1432         * dfg/DFGNode.h:
1433         (JSC::DFG::Node::willHaveCodeGenOrOSR):
1434
1435 2012-09-18  Filip Pizlo  <fpizlo@apple.com>
1436
1437         REGRESSION(r128802): It made some JS tests crash
1438         https://bugs.webkit.org/show_bug.cgi?id=97001
1439
1440         Reviewed by Mark Hahnenberg.
1441
1442         IndexingHeaderInlineMethods was incorrectly assuming that if the HasArrayStorage bit is clear, then that means that indexing payload capacity is zero.
1443
1444         * runtime/IndexingHeaderInlineMethods.h:
1445         (JSC::IndexingHeader::preCapacity):
1446         (JSC::IndexingHeader::indexingPayloadSizeInBytes):
1447
1448 2012-09-18  Mark Hahnenberg  <mhahnenberg@apple.com>
1449
1450         Use WTF::HasTrivialDestructor instead of compiler-specific versions in JSC::NeedsDestructor
1451         https://bugs.webkit.org/show_bug.cgi?id=96980
1452
1453         Reviewed by Benjamin Poulain.
1454
1455         * runtime/JSCell.h:
1456         (JSC):
1457         (NeedsDestructor):
1458
1459 2012-09-18  Filip Pizlo  <fpizlo@apple.com>
1460
1461         DFGOperations doesn't use NativeCallFrameTracer in enough places
1462         https://bugs.webkit.org/show_bug.cgi?id=96987
1463
1464         Reviewed by Mark Hahnenberg.
1465
1466         Anything that can GC should use it.
1467
1468         * dfg/DFGOperations.cpp:
1469
1470 2012-09-18  Mark Lam  <mark.lam@apple.com>
1471
1472         Not reviewed. Attempt at greening the WinCairo bot. Touching
1473         LowLevelInterpreter.asm to trigger a rebuild of LLIntDesiredOffsets.
1474         https://bugs.webkit.org/show_bug.cgi?id=96992.
1475
1476         * llint/LowLevelInterpreter.asm:
1477
1478 2012-09-18  Peter Gal  <galpeter@inf.u-szeged.hu>
1479
1480         [Qt] REGRESSION(r128790): It broke the ARM build
1481         https://bugs.webkit.org/show_bug.cgi?id=96968
1482
1483         Reviewed by Filip Pizlo.
1484
1485         Implement the missing or32 method in the MacroAssemblerARM.h.
1486
1487         * assembler/MacroAssemblerARM.h:
1488         (JSC::MacroAssemblerARM::or32):
1489         (MacroAssemblerARM):
1490
1491 2012-09-18  Mark Lam  <mark.lam@apple.com>
1492
1493         Fix for WinCairo builds.
1494         https://bugs.webkit.org/show_bug.cgi?id=96992.
1495
1496         Reviewed by Filip Pizlo.
1497
1498         Adding additional vcproj build targets in LLIntDesiredOffsets.vcproj,
1499         LLIntOffsetsExtractor.vcproj, and LLIntAssembly.vcproj to match those
1500         in jsc.vcproj.
1501
1502         * JavaScriptCore.vcproj/LLIntAssembly/LLIntAssembly.vcproj:
1503         * JavaScriptCore.vcproj/LLIntDesiredOffsets/LLIntDesiredOffsets.vcproj:
1504         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractor.vcproj:
1505         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorCommon.vsprops: Added property svn:eol-style.
1506         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorDebug.vsprops: Added property svn:eol-style.
1507         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorDebugAll.vsprops: Added.
1508         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorDebugCairoCFLite.vsprops: Added.
1509         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorProduction.vsprops: Added.
1510         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorRelease.vsprops: Added property svn:eol-style.
1511         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorReleaseCairoCFLite.vsprops: Added.
1512         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorReleasePGO.vsprops: Added.
1513
1514 2012-09-18  Filip Pizlo  <fpizlo@apple.com>
1515
1516         Unreviewed, fix sloppy English in comment.
1517
1518         * runtime/JSGlobalObject.cpp:
1519         (JSC):
1520
1521 2012-09-17  Csaba Osztrogonác  <ossy@webkit.org>
1522
1523         Unreviewed, rolling out r128826 and r128813.
1524
1525         * API/JSCallbackConstructor.cpp:
1526         (JSC):
1527         (JSC::JSCallbackConstructor::JSCallbackConstructor):
1528         * API/JSCallbackConstructor.h:
1529         (JSCallbackConstructor):
1530         * API/JSCallbackObject.cpp:
1531         (JSC):
1532         (JSC::::createStructure):
1533         * API/JSCallbackObject.h:
1534         (JSC::JSCallbackObject::create):
1535         (JSCallbackObject):
1536         * API/JSClassRef.cpp:
1537         (OpaqueJSClass::prototype):
1538         * API/JSObjectRef.cpp:
1539         (JSObjectMake):
1540         (JSObjectGetPrivate):
1541         (JSObjectSetPrivate):
1542         (JSObjectGetPrivateProperty):
1543         (JSObjectSetPrivateProperty):
1544         (JSObjectDeletePrivateProperty):
1545         * API/JSValueRef.cpp:
1546         (JSValueIsObjectOfClass):
1547         * API/JSWeakObjectMapRefPrivate.cpp:
1548         * GNUmakefile.list.am:
1549         * JSCTypedArrayStubs.h:
1550         (JSC):
1551         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
1552         * JavaScriptCore.xcodeproj/project.pbxproj:
1553         * dfg/DFGSpeculativeJIT.h:
1554         (JSC::DFG::SpeculativeJIT::emitAllocateBasicJSObject):
1555         (JSC::DFG::SpeculativeJIT::emitAllocateJSFinalObject):
1556         * heap/Heap.cpp:
1557         (JSC::Heap::isSafeToSweepStructures):
1558         (JSC):
1559         * heap/Heap.h:
1560         (JSC::Heap::allocatorForObjectWithDestructor):
1561         (Heap):
1562         (JSC::Heap::allocateWithDestructor):
1563         (JSC::Heap::allocateStructure):
1564         (JSC):
1565         * heap/IncrementalSweeper.cpp:
1566         (JSC::IncrementalSweeper::IncrementalSweeper):
1567         (JSC::IncrementalSweeper::sweepNextBlock):
1568         (JSC::IncrementalSweeper::startSweeping):
1569         (JSC::IncrementalSweeper::willFinishSweeping):
1570         (JSC::IncrementalSweeper::structuresCanBeSwept):
1571         (JSC):
1572         * heap/IncrementalSweeper.h:
1573         (IncrementalSweeper):
1574         * heap/MarkedAllocator.cpp:
1575         (JSC::MarkedAllocator::tryAllocateHelper):
1576         (JSC::MarkedAllocator::allocateBlock):
1577         * heap/MarkedAllocator.h:
1578         (JSC::MarkedAllocator::cellsNeedDestruction):
1579         (JSC::MarkedAllocator::onlyContainsStructures):
1580         (MarkedAllocator):
1581         (JSC::MarkedAllocator::MarkedAllocator):
1582         (JSC::MarkedAllocator::init):
1583         * heap/MarkedBlock.cpp:
1584         (JSC::MarkedBlock::create):
1585         (JSC::MarkedBlock::MarkedBlock):
1586         (JSC):
1587         (JSC::MarkedBlock::specializedSweep):
1588         (JSC::MarkedBlock::sweep):
1589         (JSC::MarkedBlock::sweepHelper):
1590         * heap/MarkedBlock.h:
1591         (JSC):
1592         (MarkedBlock):
1593         (JSC::MarkedBlock::cellsNeedDestruction):
1594         (JSC::MarkedBlock::onlyContainsStructures):
1595         * heap/MarkedSpace.cpp:
1596         (JSC::MarkedSpace::MarkedSpace):
1597         (JSC::MarkedSpace::resetAllocators):
1598         (JSC::MarkedSpace::canonicalizeCellLivenessData):
1599         (JSC::MarkedSpace::isPagedOut):
1600         (JSC::MarkedSpace::freeBlock):
1601         * heap/MarkedSpace.h:
1602         (MarkedSpace):
1603         (Subspace):
1604         (JSC::MarkedSpace::allocatorFor):
1605         (JSC::MarkedSpace::destructorAllocatorFor):
1606         (JSC::MarkedSpace::allocateWithDestructor):
1607         (JSC::MarkedSpace::allocateStructure):
1608         (JSC::MarkedSpace::forEachBlock):
1609         * heap/SlotVisitor.cpp:
1610         * jit/JIT.h:
1611         * jit/JITInlineMethods.h:
1612         (JSC::JIT::emitAllocateBasicJSObject):
1613         (JSC::JIT::emitAllocateJSFinalObject):
1614         (JSC::JIT::emitAllocateJSArray):
1615         * jsc.cpp:
1616         (GlobalObject::create):
1617         * runtime/Arguments.cpp:
1618         (JSC):
1619         * runtime/Arguments.h:
1620         (Arguments):
1621         (JSC::Arguments::Arguments):
1622         * runtime/ErrorPrototype.cpp:
1623         (JSC):
1624         * runtime/Executable.h:
1625         * runtime/InternalFunction.cpp:
1626         (JSC):
1627         (JSC::InternalFunction::InternalFunction):
1628         * runtime/InternalFunction.h:
1629         (InternalFunction):
1630         * runtime/JSCell.h:
1631         (JSC):
1632         (JSC::allocateCell):
1633         * runtime/JSDestructibleObject.h: Removed.
1634         * runtime/JSGlobalObject.cpp:
1635         (JSC::JSGlobalObject::reset):
1636         (JSC):
1637         * runtime/JSGlobalObject.h:
1638         (JSGlobalObject):
1639         (JSC::JSGlobalObject::createRareDataIfNeeded):
1640         (JSC::JSGlobalObject::create):
1641         * runtime/JSGlobalThis.h:
1642         (JSGlobalThis):
1643         (JSC::JSGlobalThis::JSGlobalThis):
1644         * runtime/JSPropertyNameIterator.h:
1645         * runtime/JSScope.cpp:
1646         (JSC):
1647         * runtime/JSString.h:
1648         (JSC):
1649         * runtime/JSWrapperObject.h:
1650         (JSWrapperObject):
1651         (JSC::JSWrapperObject::JSWrapperObject):
1652         * runtime/MathObject.cpp:
1653         (JSC):
1654         * runtime/NameInstance.h:
1655         (NameInstance):
1656         * runtime/RegExp.h:
1657         * runtime/RegExpObject.cpp:
1658         (JSC):
1659         * runtime/SparseArrayValueMap.h:
1660         * runtime/Structure.h:
1661         (JSC::Structure):
1662         (JSC::JSCell::classInfo):
1663         (JSC):
1664         * runtime/StructureChain.h:
1665         * runtime/SymbolTable.h:
1666         * testRegExp.cpp:
1667         (GlobalObject::create):
1668
1669 2012-09-17  Geoffrey Garen  <ggaren@apple.com>
1670
1671         Refactored the arguments object so it doesn't dictate closure layout
1672         https://bugs.webkit.org/show_bug.cgi?id=96955
1673
1674         Reviewed by Oliver Hunt.
1675
1676         * bytecode/CodeBlock.h:
1677         (JSC::ExecState::argumentAfterCapture): Helper function for accessing an
1678         argument that has been moved for capture.
1679
1680         * bytecompiler/BytecodeGenerator.cpp:
1681         (JSC::BytecodeGenerator::BytecodeGenerator): Generate metadata for arguments
1682         that are captured. We don't move any arguments yet, but we do use this
1683         metadata to tell the arguments object if an argument is stored in the
1684         activation.
1685
1686         * dfg/DFGOperations.cpp:
1687         * dfg/DFGSpeculativeJIT.cpp:
1688         (JSC::DFG::SpeculativeJIT::compileGetByValOnArguments):
1689         (JSC::DFG::SpeculativeJIT::compileGetArgumentsLength):
1690         * dfg/DFGSpeculativeJIT64.cpp:
1691         (JSC::DFG::SpeculativeJIT::compile): Updated for the arguments object not
1692         malloc'ing a separate backing store, and for a rename from deletedArguments
1693         to slowArguments.
1694
1695         * interpreter/CallFrame.h:
1696         (ExecState):
1697         * interpreter/Interpreter.cpp:
1698         (JSC::Interpreter::unwindCallFrame):
1699         (JSC::Interpreter::privateExecute):
1700         * jit/JITStubs.cpp:
1701         (JSC::DEFINE_STUB_FUNCTION):
1702         * llint/LLIntSlowPaths.cpp:
1703         (JSC::LLInt::LLINT_SLOW_PATH_DECL): Updated for small interface changes.
1704
1705         * runtime/Arguments.cpp:
1706         (JSC::Arguments::visitChildren):
1707         (JSC::Arguments::copyToArguments):
1708         (JSC::Arguments::fillArgList):
1709         (JSC::Arguments::getOwnPropertySlotByIndex):
1710         (JSC::Arguments::createStrictModeCallerIfNecessary):
1711         (JSC::Arguments::createStrictModeCalleeIfNecessary):
1712         (JSC::Arguments::getOwnPropertySlot):
1713         (JSC::Arguments::getOwnPropertyDescriptor):
1714         (JSC::Arguments::getOwnPropertyNames):
1715         (JSC::Arguments::putByIndex):
1716         (JSC::Arguments::put):
1717         (JSC::Arguments::deletePropertyByIndex):
1718         (JSC::Arguments::deleteProperty):
1719         (JSC::Arguments::defineOwnProperty):
1720         (JSC::Arguments::tearOff): Moved all data inline into the object, for speed,
1721         and refactored all internal argument accesses to use helper functions, so
1722         we can change the implementation without changing lots of code.
1723
1724         (JSC::Arguments::didTearOffActivation): This function needs to account
1725         for arguments that were moved by the activation object. We do this accounting
1726         through a side vector that tells us where our arguments will be in the
1727         activation.
1728
1729         (JSC::Arguments::tearOffForInlineCallFrame):
1730         * runtime/Arguments.h:
1731         (Arguments):
1732         (JSC::Arguments::length):
1733         (JSC::Arguments::isTornOff):
1734         (JSC::Arguments::Arguments):
1735         (JSC::Arguments::allocateSlowArguments):
1736         (JSC::Arguments::tryDeleteArgument):
1737         (JSC::Arguments::trySetArgument):
1738         (JSC::Arguments::tryGetArgument):
1739         (JSC::Arguments::isDeletedArgument):
1740         (JSC::Arguments::isArgument):
1741         (JSC::Arguments::argument):
1742         (JSC::Arguments::finishCreation):
1743
1744         * runtime/JSActivation.h:
1745         (JSC::JSActivation::create):
1746         (JSActivation):
1747         (JSC::JSActivation::captureStart):
1748         (JSC::JSActivation::storageSize):
1749         (JSC::JSActivation::registerOffset):
1750         (JSC::JSActivation::isValid): The activation object is no longer responsible
1751         for copying extra arguments provided by the caller. The argumnents object
1752         does this instead. This means we can allocate and initialize an activation
1753         without worrying about the call frame's argument count.
1754
1755         * runtime/SymbolTable.h:
1756         (JSC::SlowArgument::SlowArgument):
1757         (SlowArgument):
1758         (JSC):
1759         (JSC::SharedSymbolTable::parameterCount):
1760         (SharedSymbolTable):
1761         (JSC::SharedSymbolTable::slowArguments):
1762         (JSC::SharedSymbolTable::setSlowArguments): Added data structures to back
1763         the algorithms above.
1764
1765 2012-09-17  Filip Pizlo  <fpizlo@apple.com>
1766
1767         32-bit LLInt get_by_val does vector length checks incorrectly
1768         https://bugs.webkit.org/show_bug.cgi?id=96893
1769         <rdar://problem/12311678>
1770
1771         Reviewed by Mark Hahnenberg.
1772
1773         * llint/LowLevelInterpreter32_64.asm:
1774
1775 2012-09-17  Filip Pizlo  <fpizlo@apple.com>
1776
1777         We don't have a bad enough time if an object's prototype chain crosses global objects
1778         https://bugs.webkit.org/show_bug.cgi?id=96962
1779
1780         Reviewed by Geoffrey Garen.
1781
1782         * runtime/JSGlobalObject.cpp:
1783         (JSC):
1784
1785 2012-09-17  Filip Pizlo  <fpizlo@apple.com>
1786
1787         Unreviewed, fix a broken assertion in offlineasm.
1788
1789         * offlineasm/armv7.rb:
1790         * offlineasm/backends.rb:
1791
1792 2012-09-16  Mark Hahnenberg  <mhahnenberg@apple.com>
1793
1794         Delayed structure sweep can leak structures without bound
1795         https://bugs.webkit.org/show_bug.cgi?id=96546
1796
1797         Reviewed by Gavin Barraclough.
1798
1799         This patch gets rid of the separate Structure allocator in the MarkedSpace and adds two new destructor-only
1800         allocators. We now have separate allocators for our three types of objects: those objects with no destructors,
1801         those objects with destructors and with immortal structures, and those objects with destructors that don't have 
1802         immortal structures. All of the objects of the third type (destructors without immortal structures) now 
1803         inherit from a new class named JSDestructibleObject (which in turn is a subclass of JSNonFinalObject), which stores 
1804         the ClassInfo for these classes at a fixed offset for safe retrieval during sweeping/destruction.
1805
1806         * API/JSCallbackConstructor.cpp: Use JSDestructibleObject for JSCallbackConstructor.
1807         (JSC):
1808         (JSC::JSCallbackConstructor::JSCallbackConstructor):
1809         * API/JSCallbackConstructor.h:
1810         (JSCallbackConstructor):
1811         * API/JSCallbackObject.cpp: Inherit from JSDestructibleObject for normal JSCallbackObjects and use a finalizer for 
1812         JSCallbackObject<JSGlobalObject>, since JSGlobalObject also uses a finalizer.
1813         (JSC):
1814         (JSC::::create): We need to move the create function for JSCallbackObject<JSGlobalObject> out of line so we can add 
1815         the finalizer for it. We don't want to add the finalizer is something like finishCreation in case somebody decides 
1816         to subclass this. We use this same technique for many other subclasses of JSGlobalObject.
1817         (JSC::::createStructure):
1818         * API/JSCallbackObject.h:
1819         (JSCallbackObject):
1820         (JSC):
1821         * API/JSClassRef.cpp: Change all the JSCallbackObject<JSNonFinalObject> to use JSDestructibleObject instead.
1822         (OpaqueJSClass::prototype):
1823         * API/JSObjectRef.cpp: Ditto.
1824         (JSObjectMake):
1825         (JSObjectGetPrivate):
1826         (JSObjectSetPrivate):
1827         (JSObjectGetPrivateProperty):
1828         (JSObjectSetPrivateProperty):
1829         (JSObjectDeletePrivateProperty):
1830         * API/JSValueRef.cpp: Ditto.
1831         (JSValueIsObjectOfClass):
1832         * API/JSWeakObjectMapRefPrivate.cpp: Ditto.
1833         * JSCTypedArrayStubs.h:
1834         (JSC):
1835         * JavaScriptCore.xcodeproj/project.pbxproj:
1836         * dfg/DFGSpeculativeJIT.h: Use the proper allocator type when doing inline allocation in the DFG.
1837         (JSC::DFG::SpeculativeJIT::emitAllocateBasicJSObject):
1838         (JSC::DFG::SpeculativeJIT::emitAllocateJSFinalObject):
1839         * heap/Heap.cpp:
1840         (JSC):
1841         * heap/Heap.h: Add accessors for the various types of allocators now. Also remove the isSafeToSweepStructures function 
1842         since it's always safe to sweep Structures now.
1843         (JSC::Heap::allocatorForObjectWithNormalDestructor): 
1844         (JSC::Heap::allocatorForObjectWithImmortalStructureDestructor):
1845         (Heap):
1846         (JSC::Heap::allocateWithNormalDestructor):
1847         (JSC):
1848         (JSC::Heap::allocateWithImmortalStructureDestructor):
1849         * heap/IncrementalSweeper.cpp: Remove all the logic to detect when it's safe to sweep Structures from the 
1850         IncrementalSweeper since it's always safe to sweep Structures now.
1851         (JSC::IncrementalSweeper::IncrementalSweeper):
1852         (JSC::IncrementalSweeper::sweepNextBlock):
1853         (JSC::IncrementalSweeper::startSweeping):
1854         (JSC::IncrementalSweeper::willFinishSweeping):
1855         (JSC):
1856         * heap/IncrementalSweeper.h:
1857         (IncrementalSweeper):
1858         * heap/MarkedAllocator.cpp: Remove the logic that was preventing us from sweeping Structures if it wasn't safe. Add 
1859         tracking of the specific destructor type of allocator. 
1860         (JSC::MarkedAllocator::tryAllocateHelper):
1861         (JSC::MarkedAllocator::allocateBlock):
1862         * heap/MarkedAllocator.h:
1863         (JSC::MarkedAllocator::destructorType):
1864         (MarkedAllocator):
1865         (JSC::MarkedAllocator::MarkedAllocator):
1866         (JSC::MarkedAllocator::init):
1867         * heap/MarkedBlock.cpp: Add all the destructor type stuff to MarkedBlocks so that we do the right thing when sweeping. 
1868         We also use the stored destructor type to determine the right thing to do in all JSCell::classInfo() calls.
1869         (JSC::MarkedBlock::create):
1870         (JSC::MarkedBlock::MarkedBlock):
1871         (JSC):
1872         (JSC::MarkedBlock::specializedSweep):
1873         (JSC::MarkedBlock::sweep):
1874         (JSC::MarkedBlock::sweepHelper):
1875         * heap/MarkedBlock.h:
1876         (JSC):
1877         (JSC::MarkedBlock::allocator):
1878         (JSC::MarkedBlock::destructorType):
1879         * heap/MarkedSpace.cpp: Add the new destructor allocators to MarkedSpace.
1880         (JSC::MarkedSpace::MarkedSpace):
1881         (JSC::MarkedSpace::resetAllocators):
1882         (JSC::MarkedSpace::canonicalizeCellLivenessData):
1883         (JSC::MarkedSpace::isPagedOut):
1884         (JSC::MarkedSpace::freeBlock):
1885         * heap/MarkedSpace.h:
1886         (MarkedSpace):
1887         (JSC::MarkedSpace::immortalStructureDestructorAllocatorFor):
1888         (JSC::MarkedSpace::normalDestructorAllocatorFor):
1889         (JSC::MarkedSpace::allocateWithImmortalStructureDestructor):
1890         (JSC::MarkedSpace::allocateWithNormalDestructor):
1891         (JSC::MarkedSpace::forEachBlock):
1892         * heap/SlotVisitor.cpp: Add include because the symbol was needed in an inlined function.
1893         * jit/JIT.h: Make sure we use the correct allocator when doing inline allocations in the baseline JIT.
1894         * jit/JITInlineMethods.h:
1895         (JSC::JIT::emitAllocateBasicJSObject):
1896         (JSC::JIT::emitAllocateJSFinalObject):
1897         (JSC::JIT::emitAllocateJSArray):
1898         * jsc.cpp: 
1899         (GlobalObject::create): Add finalizer here since JSGlobalObject needs to use a finalizer instead of inheriting from 
1900         JSDestructibleObject.
1901         * runtime/Arguments.cpp: Inherit from JSDestructibleObject.
1902         (JSC):
1903         * runtime/Arguments.h:
1904         (Arguments):
1905         (JSC::Arguments::Arguments):
1906         * runtime/ErrorPrototype.cpp: Added an assert to make sure we have a trivial destructor.
1907         (JSC):
1908         * runtime/Executable.h: Indicate that all of the Executable* classes have immortal Structures.
1909         (JSC):
1910         * runtime/InternalFunction.cpp: Inherit from JSDestructibleObject.
1911         (JSC):
1912         (JSC::InternalFunction::InternalFunction):
1913         * runtime/InternalFunction.h:
1914         (InternalFunction):
1915         * runtime/JSCell.h: Added the NEEDS_DESTRUCTOR  macro to make it easier for classes to indicate that instead of being 
1916         allocated in a destructor MarkedAllocator that they will handle their destruction themselves through the 
1917         use of a finalizer.
1918         (JSC):
1919         (HasImmortalStructure): New template to help us determine at compile-time if a particular class 
1920         should be allocated in the immortal structure MarkedAllocator. The default value is false. In order 
1921         to be allocated in the immortal structure allocator, classes must specialize this template. Also added 
1922         a macro to make it easier for classes to specialize the template.
1923         (JSC::allocateCell): Use the appropriate allocator depending on the destructor type.
1924         * runtime/JSDestructibleObject.h: Added. New class that stores the ClassInfo of any subclass so that it can be 
1925         accessed safely when the object is being destroyed.
1926         (JSC):
1927         (JSDestructibleObject):
1928         (JSC::JSDestructibleObject::classInfo):
1929         (JSC::JSDestructibleObject::JSDestructibleObject):
1930         (JSC::JSCell::classInfo): Checks the current MarkedBlock to see where it should get the ClassInfo from so that it's always safe.
1931         * runtime/JSGlobalObject.cpp: JSGlobalObject now uses a finalizer instead of a destructor so that it can avoid forcing all 
1932         of its relatives in the inheritance hierarchy (e.g. JSScope) to use destructors as well.
1933         (JSC::JSGlobalObject::reset):
1934         * runtime/JSGlobalObject.h:
1935         (JSGlobalObject):
1936         (JSC::JSGlobalObject::createRareDataIfNeeded): Since we always create a finalizer now, we don't have to worry about adding one 
1937         for the m_rareData field when it's created.
1938         (JSC::JSGlobalObject::create):
1939         (JSC):
1940         * runtime/JSGlobalThis.h: Inherit from JSDestructibleObject.
1941         (JSGlobalThis):
1942         (JSC::JSGlobalThis::JSGlobalThis):
1943         * runtime/JSPropertyNameIterator.h: Has an immortal Structure.
1944         (JSC):
1945         * runtime/JSScope.cpp:
1946         (JSC):
1947         * runtime/JSString.h: Has an immortal Structure.
1948         (JSC):
1949         * runtime/JSWrapperObject.h: Inherit from JSDestructibleObject.
1950         (JSWrapperObject):
1951         (JSC::JSWrapperObject::JSWrapperObject):
1952         * runtime/MathObject.cpp: Cleaning up some of the inheritance stuff.
1953         (JSC):
1954         * runtime/NameInstance.h: Inherit from JSDestructibleObject.
1955         (NameInstance):
1956         * runtime/RegExp.h: Has immortal Structure.
1957         (JSC):
1958         * runtime/RegExpObject.cpp: Inheritance cleanup.
1959         (JSC):
1960         * runtime/SparseArrayValueMap.h: Has immortal Structure.
1961         (JSC):
1962         * runtime/Structure.h: Has immortal Structure.
1963         (JSC):
1964         * runtime/StructureChain.h: Ditto.
1965         (JSC):
1966         * runtime/SymbolTable.h: Ditto.
1967         (SharedSymbolTable):
1968         (JSC):
1969
1970 2012-09-17  Filip Pizlo  <fpizlo@apple.com>
1971
1972         If a prototype has indexed setters and its instances have indexed storage, then all put_by_val's should have a bad time
1973         https://bugs.webkit.org/show_bug.cgi?id=96596
1974
1975         Reviewed by Gavin Barraclough.
1976
1977         Added comprehensive support for accessors and read-only indexed properties on the
1978         prototype chain. This is done without any performance regression on benchmarks that
1979         we're aware of, by having the entire VM's strategy with respect to arrays tilted
1980         heavily in favor of:
1981         
1982         - The prototype chain of JSArrays never having any accessors or read-only indexed
1983           properties. If that changes, you're going to have a bad time.
1984         
1985         - Prototypes of non-JSArray objects either having no indexed accessors or read-only
1986           indexed properties, or, having those indexed accessor thingies inserted before
1987           any instance object (i.e. object with that prototype as its prototype) is created.
1988           If you add indexed accessors or read-only indexed properties to an object that is
1989           already used as a prototype, you're going to have a bad time.
1990         
1991         See below for the exact definition of having a bad time.
1992         
1993         Put another way, "fair" uses of indexed accessors and read-only indexed properties
1994         are:
1995         
1996         - Put indexed accessors and read-only indexed properties on an object that is never
1997           used as a prototype. This will slow down accesses to that object, but will not
1998           have any effect on any other object.
1999         
2000         - Put those indexed accessor thingies on an object before it is used as a prototype
2001           and then start instantiating objects that claim that object as their prototype.
2002           This will slightly slow down indexed stores to the instance objects, and greatly
2003           slow down all indexed accesses to the prototype, but will have no other effect.
2004         
2005         In short, "fair" uses only affect the object itself and any instance objects. But
2006         if you start using indexed accessors in more eclectic ways, you're going to have
2007         a bad time.
2008         
2009         Specifically, if an object that may be used as a prototype has an indexed accessor
2010         added, the VM performs a whole-heap scan to find all objects that belong to the
2011         same global object as the prototype you modified. If any of those objects has
2012         indexed storage, their indexed storage is put into slow-put mode, just as if their
2013         prototype chain had indexed accessors. This will happen even for objects that do
2014         not currently have indexed accessors in their prototype chain. As well, all JSArray
2015         allocations are caused to create arrays with slow-put storage, and all future
2016         allocations of indexed storage for non-JSArray objects are also flipped to slow-put
2017         mode. Note there are two aspects to having a bad time: (i) the whole-heap scan and
2018         (ii) the poisoning of all indexed storage in the entire global object. (i) is
2019         necessary for correctness. If we detect that an object that may be used as a
2020         prototype has had an indexed accessor or indexed read-only property inserted into
2021         it, then we need to ensure that henceforth all instances of that object inspect
2022         the prototype chain whenever an indexed hole is stored to. But by default, indexed
2023         stores do no such checking because doing so would be unnecessarily slow. So, we must
2024         find all instances of the affected object and flip them into a different array
2025         storage mode that omits all hole optimizations. Since prototypes never keep a list
2026         of instance objects, the only way to find those objects is a whole-heap scan. But
2027         (i) alone would be a potential disaster, if a program frequently allocated an
2028         object without indexed accessors, then allocated a bunch of objects that used that
2029         one as their prototype, and then added indexed accessors to the prototype. So, to
2030         prevent massive heap scan storms in such awkward programs, having a bad time also
2031         implies (ii): henceforth *all* objects belonging to that global object will use
2032         slow put indexed storage, so that we don't ever have to scan the heap again. Note
2033         that here we are using the global object as just an approximation of a program
2034         module; it may be worth investigating in the future if other approximations can be
2035         used instead.
2036
2037         * bytecode/ArrayProfile.h:
2038         (JSC):
2039         (JSC::arrayModeFromStructure):
2040         * dfg/DFGAbstractState.cpp:
2041         (JSC::DFG::AbstractState::execute):
2042         * dfg/DFGArrayMode.cpp:
2043         (JSC::DFG::fromObserved):
2044         (JSC::DFG::modeAlreadyChecked):
2045         (JSC::DFG::modeToString):
2046         * dfg/DFGArrayMode.h:
2047         (DFG):
2048         (JSC::DFG::isSlowPutAccess):
2049         * dfg/DFGSpeculativeJIT.cpp:
2050         (JSC::DFG::SpeculativeJIT::checkArray):
2051         * dfg/DFGSpeculativeJIT32_64.cpp:
2052         (JSC::DFG::SpeculativeJIT::compile):
2053         * dfg/DFGSpeculativeJIT64.cpp:
2054         (JSC::DFG::SpeculativeJIT::compile):
2055         * jit/JIT.h:
2056         * jit/JITInlineMethods.h:
2057         (JSC::JIT::emitAllocateJSArray):
2058         * jit/JITOpcodes.cpp:
2059         (JSC::JIT::emit_op_new_array):
2060         * runtime/ArrayPrototype.cpp:
2061         (JSC::ArrayPrototype::finishCreation):
2062         (JSC::arrayProtoFuncSort):
2063         * runtime/IndexingType.h:
2064         (JSC):
2065         (JSC::hasIndexedProperties):
2066         (JSC::hasIndexingHeader):
2067         (JSC::hasArrayStorage):
2068         (JSC::shouldUseSlowPut):
2069         * runtime/JSArray.cpp:
2070         (JSC::JSArray::pop):
2071         (JSC::JSArray::push):
2072         (JSC::JSArray::fillArgList):
2073         (JSC::JSArray::copyToArguments):
2074         * runtime/JSArray.h:
2075         (JSC::JSArray::createStructure):
2076         * runtime/JSGlobalObject.cpp:
2077         (JSC::JSGlobalObject::JSGlobalObject):
2078         (JSC::JSGlobalObject::reset):
2079         (JSC):
2080         (JSC::JSGlobalObject::haveABadTime):
2081         * runtime/JSGlobalObject.h:
2082         (JSGlobalObject):
2083         (JSC::JSGlobalObject::addressOfArrayStructure):
2084         (JSC::JSGlobalObject::havingABadTimeWatchpoint):
2085         (JSC::JSGlobalObject::isHavingABadTime):
2086         * runtime/JSObject.cpp:
2087         (JSC::JSObject::visitButterfly):
2088         (JSC::JSObject::getOwnPropertySlotByIndex):
2089         (JSC::JSObject::put):
2090         (JSC::JSObject::putByIndex):
2091         (JSC::JSObject::enterDictionaryIndexingMode):
2092         (JSC::JSObject::notifyPresenceOfIndexedAccessors):
2093         (JSC):
2094         (JSC::JSObject::createArrayStorage):
2095         (JSC::JSObject::ensureArrayStorageExistsAndEnterDictionaryIndexingMode):
2096         (JSC::JSObject::switchToSlowPutArrayStorage):
2097         (JSC::JSObject::setPrototype):
2098         (JSC::JSObject::resetInheritorID):
2099         (JSC::JSObject::inheritorID):
2100         (JSC::JSObject::allowsAccessFrom):
2101         (JSC::JSObject::deletePropertyByIndex):
2102         (JSC::JSObject::getOwnPropertyNames):
2103         (JSC::JSObject::unwrappedGlobalObject):
2104         (JSC::JSObject::notifyUsedAsPrototype):
2105         (JSC::JSObject::createInheritorID):
2106         (JSC::JSObject::defineOwnIndexedProperty):
2107         (JSC::JSObject::attemptToInterceptPutByIndexOnHoleForPrototype):
2108         (JSC::JSObject::attemptToInterceptPutByIndexOnHole):
2109         (JSC::JSObject::putByIndexBeyondVectorLength):
2110         (JSC::JSObject::putDirectIndexBeyondVectorLength):
2111         (JSC::JSObject::getNewVectorLength):
2112         (JSC::JSObject::getOwnPropertyDescriptor):
2113         * runtime/JSObject.h:
2114         (JSC::JSObject::mayBeUsedAsPrototype):
2115         (JSObject):
2116         (JSC::JSObject::mayInterceptIndexedAccesses):
2117         (JSC::JSObject::getArrayLength):
2118         (JSC::JSObject::getVectorLength):
2119         (JSC::JSObject::canGetIndexQuickly):
2120         (JSC::JSObject::getIndexQuickly):
2121         (JSC::JSObject::canSetIndexQuickly):
2122         (JSC::JSObject::setIndexQuickly):
2123         (JSC::JSObject::initializeIndex):
2124         (JSC::JSObject::completeInitialization):
2125         (JSC::JSObject::inSparseIndexingMode):
2126         (JSC::JSObject::arrayStorage):
2127         (JSC::JSObject::arrayStorageOrNull):
2128         (JSC::JSObject::ensureArrayStorage):
2129         (JSC):
2130         (JSC::JSValue::putByIndex):
2131         * runtime/JSValue.cpp:
2132         (JSC::JSValue::putToPrimitive):
2133         (JSC::JSValue::putToPrimitiveByIndex):
2134         (JSC):
2135         * runtime/JSValue.h:
2136         (JSValue):
2137         * runtime/ObjectPrototype.cpp:
2138         (JSC::ObjectPrototype::finishCreation):
2139         * runtime/SparseArrayValueMap.cpp:
2140         (JSC::SparseArrayValueMap::putEntry):
2141         (JSC::SparseArrayEntry::put):
2142         (JSC):
2143         * runtime/SparseArrayValueMap.h:
2144         (JSC):
2145         (SparseArrayEntry):
2146         * runtime/Structure.cpp:
2147         (JSC::Structure::anyObjectInChainMayInterceptIndexedAccesses):
2148         (JSC):
2149         (JSC::Structure::suggestedIndexingTransition):
2150         * runtime/Structure.h:
2151         (Structure):
2152         (JSC::Structure::mayInterceptIndexedAccesses):
2153         * runtime/StructureTransitionTable.h:
2154         (JSC::newIndexingType):
2155
2156 2012-09-17  Filip Pizlo  <fpizlo@apple.com>
2157
2158         Array profiling has convergence issues
2159         https://bugs.webkit.org/show_bug.cgi?id=96891
2160
2161         Reviewed by Gavin Barraclough.
2162
2163         Now each array profiling site merges in the indexing type it observed into
2164         the m_observedArrayModes bitset. The ArrayProfile also uses this to detect
2165         cases where the structure must have gone polymorphic (if the bitset is
2166         polymorphic then the structure must be). This achieves something like the
2167         best of both worlds: on the one hand, we get a probabilistic structure that
2168         we can use to optimize the monomorphic structure case, but on the other hand,
2169         we get an accurate view of the set of types that were encountered.
2170
2171         * assembler/MacroAssemblerARMv7.h:
2172         (JSC::MacroAssemblerARMv7::or32):
2173         (MacroAssemblerARMv7):
2174         * assembler/MacroAssemblerX86.h:
2175         (JSC::MacroAssemblerX86::or32):
2176         (MacroAssemblerX86):
2177         * assembler/MacroAssemblerX86_64.h:
2178         (JSC::MacroAssemblerX86_64::or32):
2179         (MacroAssemblerX86_64):
2180         * assembler/X86Assembler.h:
2181         (X86Assembler):
2182         (JSC::X86Assembler::orl_rm):
2183         * bytecode/ArrayProfile.cpp:
2184         (JSC::ArrayProfile::computeUpdatedPrediction):
2185         * bytecode/ArrayProfile.h:
2186         (JSC::ArrayProfile::addressOfArrayModes):
2187         (JSC::ArrayProfile::structureIsPolymorphic):
2188         * jit/JIT.h:
2189         (JIT):
2190         * jit/JITInlineMethods.h:
2191         (JSC):
2192         (JSC::JIT::emitArrayProfilingSite):
2193         * jit/JITPropertyAccess.cpp:
2194         (JSC::JIT::emit_op_get_by_val):
2195         (JSC::JIT::emit_op_put_by_val):
2196         (JSC::JIT::privateCompilePatchGetArrayLength):
2197         * jit/JITPropertyAccess32_64.cpp:
2198         (JSC::JIT::emit_op_get_by_val):
2199         (JSC::JIT::emit_op_put_by_val):
2200         (JSC::JIT::privateCompilePatchGetArrayLength):
2201         * llint/LowLevelInterpreter.asm:
2202         * llint/LowLevelInterpreter32_64.asm:
2203         * llint/LowLevelInterpreter64.asm:
2204
2205 2012-09-17  Mark Lam  <mark.lam@apple.com>
2206
2207         Not reviewed. Added svn:eol-style native to unbreak some build bots.
2208         https://bugs.webkit.org/show_bug.cgi?id=96175.
2209
2210         * JavaScriptCore.vcproj/LLIntAssembly/LLIntAssembly.vcproj: Added property svn:eol-style.
2211         * JavaScriptCore.vcproj/LLIntDesiredOffsets/LLIntDesiredOffsets.vcproj: Added property svn:eol-style.
2212         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractor.vcproj: Added property svn:eol-style.
2213
2214 2012-09-16  Mark Lam  <mark.lam@apple.com>
2215
2216         Added MSVC project changes to enable building the llint.
2217         https://bugs.webkit.org/show_bug.cgi?id=96175.
2218
2219         Reviewed by Geoff Garen.
2220
2221         This only adds the ability to build the llint, but currently, only the
2222         C++ backend is supported. By default, the Windows port will remain
2223         running with the baseline JIT.  The llint will not be enabled.
2224
2225         * JavaScriptCore.vcproj/JavaScriptCore.sln:
2226         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
2227         * JavaScriptCore.vcproj/LLIntAssembly: Added.
2228         * JavaScriptCore.vcproj/LLIntAssembly/LLIntAssembly.make: Added.
2229         * JavaScriptCore.vcproj/LLIntAssembly/LLIntAssembly.vcproj: Added.
2230         * JavaScriptCore.vcproj/LLIntAssembly/build-LLIntAssembly.sh: Added.
2231         * JavaScriptCore.vcproj/LLIntDesiredOffsets: Added.
2232         * JavaScriptCore.vcproj/LLIntDesiredOffsets/LLIntDesiredOffsets.make: Added.
2233         * JavaScriptCore.vcproj/LLIntDesiredOffsets/LLIntDesiredOffsets.vcproj: Added.
2234         * JavaScriptCore.vcproj/LLIntDesiredOffsets/build-LLIntDesiredOffsets.sh: Added.
2235         * JavaScriptCore.vcproj/LLIntOffsetsExtractor: Added.
2236         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractor.vcproj: Added.
2237         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorCommon.vsprops: Added.
2238         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorDebug.vsprops: Added.
2239         * JavaScriptCore.vcproj/LLIntOffsetsExtractor/LLIntOffsetsExtractorRelease.vsprops: Added.
2240
2241 2012-09-16  Filip Pizlo  <fpizlo@apple.com>
2242
2243         JSObject.cpp and JSArray.cpp have inconsistent tests for the invalid array index case
2244         https://bugs.webkit.org/show_bug.cgi?id=96878
2245
2246         Reviewed by Sam Weinig.
2247
2248         Removed the uses of UNLIKELY() because I don't believe they are buying us anything,
2249         since we're already on the slow path. Also found other places where we're testing for
2250         the invalid array index case using unusual predicates rather than just using
2251         MAX_ARRAY_INDEX. With this change, I believe that all of our tests for invalid
2252         array indices (i.e. indices that should be treated as non-indexed properties)
2253         uniformly use MAX_ARRAY_INDEX and PropertyName::NotAnIndex.
2254
2255         * runtime/JSArray.cpp:
2256         (JSC::JSArray::push):
2257         * runtime/JSObject.cpp:
2258         (JSC::JSObject::putByIndex):
2259         (JSC::JSObject::defineOwnIndexedProperty):
2260
2261 2012-09-15  Filip Pizlo  <fpizlo@apple.com>
2262
2263         Following the Butterfly refactoring, the comment for lastArraySize was not updated
2264         https://bugs.webkit.org/show_bug.cgi?id=96877
2265
2266         Reviewed by Sam Weinig.
2267
2268         * runtime/JSObject.cpp:
2269         (JSC):
2270
2271 2012-09-15  Mark Lam  <mark.lam@apple.com>
2272
2273         Fixed JSLock to use the platform abstraction for Mutex instead of
2274         depending on pthreads.
2275         https://bugs.webkit.org/show_bug.cgi?id=96858.
2276
2277         Reviewed by Filip Pizlo.
2278
2279         This fixes a synchronization problem on the Windows port and makes
2280         it more reliable when running the layout tests.
2281
2282         * runtime/InitializeThreading.cpp:
2283         (JSC::initializeThreadingOnce):
2284         * runtime/JSLock.cpp:
2285         (JSC):
2286         (JSC::GlobalJSLock::GlobalJSLock):
2287         (JSC::GlobalJSLock::~GlobalJSLock):
2288         (JSC::GlobalJSLock::initialize):
2289         * runtime/JSLock.h:
2290         (GlobalJSLock):
2291         (JSLock):
2292
2293 2012-09-15  Filip Pizlo  <fpizlo@apple.com>
2294
2295         Structure check hoisting fails to consider the possibility of conflicting checks on the source of the first assignment to the hoisted variable
2296         https://bugs.webkit.org/show_bug.cgi?id=96872
2297
2298         Reviewed by Oliver Hunt.
2299
2300         This does a few related things:
2301         
2302         - It turns off the use of ForceOSRExit for sure-to-fail CheckStructures, because
2303           I noticed that this would sometimes happen for a ForwardCheckStructure. The
2304           problem is that ForceOSRExit exits backwards, not forwards. Since the code that
2305           led to those ForceOSRExit's being inserted was written out of paranoia rather
2306           than need, I removed it. Specifically, I removed the m_isValid = false code
2307           for CheckStructure/StructureTransitionWatchpoint in AbstractState.
2308         
2309         - If a structure check causes a structure set to go empty, we don't want a
2310           PutStructure to revive the set. It should instead be smart enough to realize 
2311           that an empty set implies that the code can't execute. This was the only "bug"
2312           that the use of m_isValid = false was preventing.
2313         
2314         - Finally, the main change: structure check hoisting looks at the source of the
2315           SetLocals on structure-check-hoistable variables and ensures that the source
2316           is not checked with a conflicting structure. This is O(n^2) but it does not
2317           show up at all in performance tests.
2318         
2319         The first two parts of this change were auxiliary bugs that were revealed by
2320         the structure check hoister doing bad things.
2321
2322         * dfg/DFGAbstractState.cpp:
2323         (JSC::DFG::AbstractState::initialize):
2324         (JSC::DFG::AbstractState::execute):
2325         * dfg/DFGStructureCheckHoistingPhase.cpp:
2326         (JSC::DFG::StructureCheckHoistingPhase::run):
2327
2328 2012-09-14  Filip Pizlo  <fpizlo@apple.com>
2329
2330         All of the things in SparseArrayValueMap should be out-of-line
2331         https://bugs.webkit.org/show_bug.cgi?id=96854
2332
2333         Reviewed by Andy Estes.
2334
2335         Those inline methods were buying us nothing.
2336
2337         * GNUmakefile.list.am:
2338         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
2339         * JavaScriptCore.xcodeproj/project.pbxproj:
2340         * runtime/JSArray.cpp:
2341         * runtime/JSGlobalData.cpp:
2342         * runtime/JSObject.cpp:
2343         * runtime/RegExpMatchesArray.cpp:
2344         * runtime/SparseArrayValueMap.cpp:
2345         (JSC::SparseArrayValueMap::SparseArrayValueMap):
2346         (JSC):
2347         (JSC::SparseArrayValueMap::~SparseArrayValueMap):
2348         (JSC::SparseArrayValueMap::finishCreation):
2349         (JSC::SparseArrayValueMap::create):
2350         (JSC::SparseArrayValueMap::destroy):
2351         (JSC::SparseArrayValueMap::createStructure):
2352         (JSC::SparseArrayValueMap::add):
2353         (JSC::SparseArrayValueMap::putEntry):
2354         (JSC::SparseArrayValueMap::putDirect):
2355         (JSC::SparseArrayEntry::get):
2356         (JSC::SparseArrayEntry::getNonSparseMode):
2357         (JSC::SparseArrayValueMap::visitChildren):
2358         * runtime/SparseArrayValueMapInlineMethods.h: Removed.
2359
2360 2012-09-14  Mike West  <mkwst@chromium.org>
2361
2362         JSC should throw a more descriptive exception when blocking 'eval' via CSP.
2363         https://bugs.webkit.org/show_bug.cgi?id=94331
2364
2365         Reviewed by Geoffrey Garen.
2366
2367         Unless explicitly whitelisted, the 'script-src' Content Security Policy
2368         directive blocks 'eval' and 'eval'-like constructs such as
2369         'new Function()'. When 'eval' is encountered in code, an 'EvalError' is
2370         thrown, but the associated message is poor: "Eval is disabled" doesn't
2371         give developers enough information about why their code isn't behaving
2372         as expected.
2373
2374         This patch adds an 'errorMessage' parameter to the JavaScriptCore method
2375         used to disable 'eval'; ContentSecurityPolicy has the opportunity to
2376         pass in a more detailed and descriptive error that contains more context
2377         for the developer.
2378
2379         * runtime/Executable.cpp:
2380         (JSC::EvalExecutable::compileInternal):
2381             Drop the hard-coded "Eval is disabled" error message in favor of
2382             reading the error message off the global object.
2383         * runtime/FunctionConstructor.cpp:
2384         (JSC::FunctionConstructor::getCallData):
2385             Drop the hard-coded "Function constructor is disabled" error message
2386             in favor of reading the error message off the global object.
2387         * runtime/JSGlobalObject.h:
2388         (JSGlobalObject):
2389         (JSC::JSGlobalObject::evalEnabled):
2390             Making this accessor method const.
2391         (JSC::JSGlobalObject::evalDisabledErrorMessage):
2392             Accessor for the error message set via 'setEvalDisabled'.
2393         (JSC::JSGlobalObject::setEvalEnabled):
2394             Adding an 'errorMessage' parameter which is stored on the global
2395             object, and used when exceptions are thrown.
2396
2397 2012-09-14  Filip Pizlo  <fpizlo@apple.com>
2398
2399         bbc homepage crashes immediately
2400         https://bugs.webkit.org/show_bug.cgi?id=96812
2401         <rdar://problem/12081386>
2402
2403         Reviewed by Oliver Hunt.
2404
2405         If you use the old storage pointer to write to space you thought was newly allocated,
2406         you're going to have a bad time.
2407
2408         * runtime/JSArray.cpp:
2409         (JSC::JSArray::unshiftCount):
2410
2411 2012-09-14  Adam Barth  <abarth@webkit.org>
2412
2413         Remove webkitPostMessage
2414         https://bugs.webkit.org/show_bug.cgi?id=96577
2415
2416         Reviewed by Ojan Vafai.
2417
2418         Add ENABLE_LEGACY_VENDOR_PREFIXES flag.
2419
2420         * Configurations/FeatureDefines.xcconfig:
2421
2422 2012-09-14  Tor Arne Vestbø  <tor.arne.vestbo@nokia.com>
2423
2424         [Qt] Make force_static_libs_as_shared work on Mac OS
2425
2426         We had to move a few LIBS += around that were in the wrong place,
2427         and not caught when everything was just linked into the final
2428         QtWebKit library.
2429
2430         Reviewed by Simon Hausmann.
2431
2432         * jsc.pro: No need for AppKit, we get it from WTF.pri
2433
2434 2012-09-14  Kevin Funk  <kevin.funk@kdab.com>
2435
2436         Fix interpreter build
2437         https://bugs.webkit.org/show_bug.cgi?id=96617
2438
2439         Reviewed by Simon Hausmann.
2440
2441         Make compile.
2442
2443         * interpreter/Interpreter.cpp:
2444
2445 2012-09-14  Parth Patel  <parpatel@rim.com>
2446
2447         [BlackBerry] Switching from Slogger to Slogger2 requires changes in CMakeList of 
2448         webkit in order to include libraries of slog2
2449         https://bugs.webkit.org/show_bug.cgi?id=96391
2450
2451         Reviewed by Yong Li.
2452
2453         Changes in Cmake files of JavaScriptCore of webkit to include slog2 libs in build 
2454         files of webkit in response to switching from Slogger to Slogger2.
2455
2456         * shell/PlatformBlackBerry.cmake:
2457
2458 2012-09-14  Mark Hahnenberg  <mhahnenberg@apple.com>
2459
2460         Remove the Zapped BlockState
2461         https://bugs.webkit.org/show_bug.cgi?id=96708
2462
2463         Reviewed by Geoffrey Garen.
2464
2465         The Zapped block state is rather confusing. It indicates that a block is in one of two different states that we 
2466         can't tell the difference between:
2467
2468         1) I have run all destructors of things that are zapped, and I have not allocated any more objects. This block 
2469            is ready for reclaiming if you so choose.
2470         2) I have run all the destructors of things that are zapped, but I have allocated more stuff since then, so it 
2471            is not safe to reclaim this block.
2472
2473         This state adds a lot of complexity to our state transition model for MarkedBlocks. We should get rid of it. 
2474         We can replace this state by making sure mark bits represent all of the liveness information we need when running 
2475         our conservative stack scan. Instead of zapping the free list when canonicalizing cell liveness data prior to 
2476         a conservative scan, we can instead mark all objects in the block except for those in the free list. This should 
2477         incur no performance penalty since we're doing it on a very small O(1) number of blocks at the beginning of the collection. 
2478
2479         For the time being we still need to use zapping to determine whether we have run an object's destructor or not.
2480
2481         * heap/MarkedAllocator.cpp:
2482         (JSC::MarkedAllocator::tryAllocateHelper): Renaming stuff.
2483         * heap/MarkedAllocator.h: Renamed zapFreeList to canonicalizeCellLivenessData to match.
2484         (MarkedAllocator):
2485         (JSC::MarkedAllocator::canonicalizeCellLivenessData): Same as old zapFreeList, but just call canonicalize instead.
2486         * heap/MarkedBlock.cpp:
2487         (JSC::MarkedBlock::specializedSweep): Remove the check for Zapped block stuff. Also change the block state to Marked 
2488         instead of Zapped if we're not producing a FreeList since that's the only other state that really makes any sense.
2489         (JSC::MarkedBlock::sweepHelper): Remove Zapped related code.
2490         (SetAllMarksFunctor): Functor to set all the mark bits in the block since there's not a simple function to call on 
2491         the Bitmap itself.
2492         (JSC::SetAllMarksFunctor::operator()):
2493         (JSC):
2494         (JSC::MarkedBlock::canonicalizeCellLivenessData): Remove all the stuff for Zapped. For FreeListed, set all the mark bits
2495         and then clear the ones for the objects in the FreeList. This ensures that only the things that were in the FreeList 
2496         are considered to be dead by the conservative scan, just like if we were to have zapped the FreeList like before. 
2497         * heap/MarkedBlock.h:
2498         (MarkedBlock):
2499         (JSC::MarkedBlock::clearMarked): Add function to clear individual mark bits, since we need that functionality now.
2500         (JSC):
2501         (JSC::MarkedBlock::isLive): Remove code for Zapped stuff. Marked handles all interesting cases now.
2502         (JSC::MarkedBlock::forEachCell): Add new iterator function that iterates over all cells in the block, regardless of 
2503         whether they're live or a dead.
2504         * heap/MarkedSpace.cpp:
2505         (JSC::MarkedSpace::canonicalizeCellLivenessData): Change to call the renamed canonicalize function. 
2506
2507 2012-09-13  Kevin Funk  <kevin.funk@kdab.com>
2508
2509         Make compile with both OS(WINCE) and PLATFORM(QT) support
2510         https://bugs.webkit.org/show_bug.cgi?id=95536
2511
2512         Reviewed by Simon Hausmann.
2513
2514         Do not link against advapi32 on wince
2515
2516         * jsc.pro:
2517
2518 2012-09-13  Geoffrey Garen  <ggaren@apple.com>
2519
2520         Refactored the DFG to make fewer assumptions about variable capture
2521         https://bugs.webkit.org/show_bug.cgi?id=96680
2522
2523         Reviewed by Gavin Barraclough.
2524
2525         A variable capture optimization patch I'm working on broke DFG
2526         correctness and the arguments simplification optimization phase, so I've
2527         refactored both to make fewer assumptions about variable capture.
2528
2529         * bytecode/CodeBlock.h:
2530         (JSC::CodeBlock::isCaptured): This is the new One True Way to find out
2531         if a variable was captured. This gives us a single point of maintenance
2532         as we chagne capture behavior.
2533
2534         * dfg/DFGAbstractState.cpp:
2535         (JSC::DFG::AbstractState::clobberCapturedVars): Don't assume that captured
2536         variables have any particular location. Instead, ask the One True Function.
2537
2538         * dfg/DFGArgumentsSimplificationPhase.cpp:
2539         (JSC::DFG::ArgumentsSimplificationPhase::run):
2540         (JSC::DFG::ArgumentsSimplificationPhase::observeProperArgumentsUse):
2541         (JSC::DFG::ArgumentsSimplificationPhase::isOKToOptimize): Mechanical
2542         changes to separate being captured from being 'arguments'. What used
2543         to be
2544                 if (captured)
2545                         if (arguments)
2546                                 x
2547                         y
2548         is now
2549                 if (arguments)
2550                         x
2551                         y
2552                 else if (captured)
2553                         y
2554
2555         * dfg/DFGByteCodeParser.cpp:
2556         (JSC::DFG::ByteCodeParser::getLocal):
2557         (JSC::DFG::ByteCodeParser::setLocal):
2558         (JSC::DFG::ByteCodeParser::getArgument):
2559         (JSC::DFG::ByteCodeParser::setArgument):
2560         (JSC::DFG::ByteCodeParser::flushDirect):
2561         (JSC::DFG::ByteCodeParser::parseBlock):
2562         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2563         * dfg/DFGSpeculativeJIT.cpp:
2564         (JSC::DFG::SpeculativeJIT::compile): Use the One True Function.
2565
2566 2012-09-13  Benjamin Poulain  <bpoulain@apple.com>
2567
2568         Improve the SourceProvider hierarchy
2569         https://bugs.webkit.org/show_bug.cgi?id=95635
2570
2571         Reviewed by Geoffrey Garen.
2572
2573         SourceProvider was designed to have subclasses magically handling the data without
2574         decoding all of it. The virtual methods length() and getRange() were based
2575         on these assumptions.
2576
2577         In practice, the magic was in our head, there is no implementation that takes
2578         advantage of that.
2579
2580         SourceProvider is modified to adopt WebCore's ScriptSourceProvider::source() and base
2581         everything on it.
2582         The code using SourceProvider is also simplified.
2583
2584         * interpreter/Interpreter.cpp:
2585         (JSC::appendSourceToError): Keep a reference to the string instead of querying it for
2586         each time it is used.
2587         * parser/Lexer.cpp:
2588         (JSC::::setCode):
2589         (JSC::::sourceCode):
2590         * parser/Parser.h:
2591         (JSC::parse):
2592         * parser/SourceCode.h:
2593         (JSC::SourceCode::SourceCode):
2594         (JSC::SourceCode::subExpression):
2595         * parser/SourceProvider.h:
2596         (SourceProvider):
2597         (JSC::SourceProvider::getRange):
2598
2599 2012-09-13  Filip Pizlo  <fpizlo@apple.com>
2600
2601         DFG: Dead GetButterfly's shouldn't be subject to CSE
2602         https://bugs.webkit.org/show_bug.cgi?id=96707
2603         <rdar://problem/12296311>
2604
2605         Reviewed by Oliver Hunt.
2606         
2607         There were a number of cases of this that creeped into the CSE: it would
2608         match something even though it was dead.
2609
2610         * dfg/DFGCSEPhase.cpp:
2611         (JSC::DFG::CSEPhase::getPropertyStorageLoadElimination):
2612         (JSC::DFG::CSEPhase::checkArrayElimination):
2613         (JSC::DFG::CSEPhase::getIndexedPropertyStorageLoadElimination):
2614         (JSC::DFG::CSEPhase::getScopeChainLoadElimination):
2615         (JSC::DFG::CSEPhase::getLocalLoadElimination):
2616
2617 2012-09-13  Oliver Hunt  <oliver@apple.com>
2618
2619         Make global const initialisation explicit in the bytecode
2620         https://bugs.webkit.org/show_bug.cgi?id=96711
2621
2622         Reviewed by Gavin Barraclough.
2623
2624         Added op_init_global_const to make initialisation of global const
2625         fields explicit.  This will help us keep correct semantics in the
2626         upcoming variable resolution refactoring.
2627
2628         * bytecode/CodeBlock.cpp:
2629         (JSC::CodeBlock::dump):
2630         * bytecode/Opcode.h:
2631         (JSC):
2632         (JSC::padOpcodeName):
2633         * bytecompiler/BytecodeGenerator.cpp:
2634         (JSC::BytecodeGenerator::emitInitGlobalConst):
2635         (JSC):
2636         * bytecompiler/BytecodeGenerator.h:
2637         (BytecodeGenerator):
2638         * bytecompiler/NodesCodegen.cpp:
2639         (JSC::ConstDeclNode::emitCodeSingle):
2640         * dfg/DFGByteCodeParser.cpp:
2641         (JSC::DFG::ByteCodeParser::parseBlock):
2642         * dfg/DFGCapabilities.h:
2643         (JSC::DFG::canCompileOpcode):
2644         * interpreter/Interpreter.cpp:
2645         (JSC::Interpreter::privateExecute):
2646         * jit/JIT.cpp:
2647         (JSC::JIT::privateCompileMainPass):
2648         (JSC::JIT::privateCompileSlowCases):
2649         * llint/LowLevelInterpreter32_64.asm:
2650         * llint/LowLevelInterpreter64.asm:
2651
2652 2012-09-13  Mark Hahnenberg  <mhahnenberg@apple.com>
2653
2654         Rename forEachCell to forEachLiveCell
2655         https://bugs.webkit.org/show_bug.cgi?id=96685
2656
2657         Reviewed by Oliver Hunt.
2658
2659         forEachCell actually only iterates over live cells. We should rename it to 
2660         reflect what it actually does. This is also helpful because we want to add a new 
2661         forEachCell that actually does iterate each and every cell in a MarkedBlock 
2662         regardless of whether or not it is live.
2663
2664         * debugger/Debugger.cpp:
2665         (JSC::Debugger::recompileAllJSFunctions):
2666         * heap/Heap.cpp:
2667         (JSC::Heap::globalObjectCount):
2668         (JSC::Heap::objectTypeCounts):
2669         * heap/MarkedBlock.h:
2670         (MarkedBlock):
2671         (JSC::MarkedBlock::forEachLiveCell):
2672         * heap/MarkedSpace.h:
2673         (MarkedSpace):
2674         (JSC::MarkedSpace::forEachLiveCell):
2675         * runtime/JSGlobalData.cpp:
2676         (JSC::JSGlobalData::releaseExecutableMemory):
2677
2678 2012-09-13  Filip Pizlo  <fpizlo@apple.com>
2679
2680         [Qt][Win] REGRESSION(r128400): It broke the build
2681         https://bugs.webkit.org/show_bug.cgi?id=96617
2682
2683         Reviewed by Simon Hausmann.
2684
2685         Changed "JSC::Array" to "JSC::ArrayClass" because it's not used often enough
2686         for the brevity to be beneficial, and because "Array" causes too much namespace
2687         pollution.
2688
2689         * runtime/IndexingType.h:
2690         (JSC):
2691         * runtime/JSArray.cpp:
2692         (JSC::JSArray::pop):
2693         (JSC::JSArray::push):
2694         (JSC::JSArray::sortNumeric):
2695         (JSC::JSArray::sort):
2696         (JSC::JSArray::fillArgList):
2697         (JSC::JSArray::copyToArguments):
2698         (JSC::JSArray::compactForSorting):
2699         * runtime/JSObject.cpp:
2700         (JSC::JSObject::getOwnPropertySlotByIndex):
2701         (JSC::JSObject::putByIndex):
2702         (JSC::JSObject::ensureArrayStorageExistsAndEnterDictionaryIndexingMode):
2703         (JSC::JSObject::deletePropertyByIndex):
2704         (JSC::JSObject::getOwnPropertyNames):
2705         (JSC::JSObject::putByIndexBeyondVectorLength):
2706         (JSC::JSObject::putDirectIndexBeyondVectorLength):
2707         (JSC::JSObject::getNewVectorLength):
2708         (JSC::JSObject::getOwnPropertyDescriptor):
2709         * runtime/JSObject.h:
2710         (JSC::JSObject::getArrayLength):
2711         (JSC::JSObject::getVectorLength):
2712         (JSC::JSObject::canGetIndexQuickly):
2713         (JSC::JSObject::canSetIndexQuickly):
2714         (JSC::JSObject::inSparseIndexingMode):
2715         (JSC::JSObject::ensureArrayStorage):
2716
2717 2012-09-13  Filip Pizlo  <fpizlo@apple.com>
2718
2719         Testing whether indexing type is ArrayWithArrayStorage should not compare against ArrayWithArrayStorage
2720         https://bugs.webkit.org/show_bug.cgi?id=96611
2721
2722         Reviewed by Gavin Barraclough.
2723
2724         * dfg/DFGRepatch.cpp:
2725         (JSC::DFG::tryCacheGetByID):
2726         * dfg/DFGSpeculativeJIT.cpp:
2727         (JSC::DFG::SpeculativeJIT::checkArray):
2728         * jit/JITPropertyAccess.cpp:
2729         (JSC::JIT::privateCompilePatchGetArrayLength):
2730         * jit/JITPropertyAccess32_64.cpp:
2731         (JSC::JIT::privateCompilePatchGetArrayLength):
2732         * llint/LowLevelInterpreter32_64.asm:
2733         * llint/LowLevelInterpreter64.asm:
2734
2735 2012-09-09  Filip Pizlo  <fpizlo@apple.com>
2736
2737         JSC should have property butterflies
2738         https://bugs.webkit.org/show_bug.cgi?id=91933
2739
2740         Reviewed by Geoffrey Garen.
2741
2742         This changes the JSC object model. Previously, all objects had fast lookup for
2743         named properties. Integer indexed properties were only fast if you used a
2744         JSArray. With this change, all objects have fast indexed properties. This is
2745         accomplished without any space overhead by using a bidirectional object layout,
2746         aka butterflies. Each JSObject has a m_butterfly pointer where previously it
2747         had a m_outOfLineStorage pointer. To the left of the location pointed to by
2748         m_butterfly, we place all named out-of-line properties. To the right, we place
2749         all indexed properties along with indexing meta-data. Though, some indexing
2750         meta-data is placed in the 8-byte word immediately left of the pointed-to
2751         location; this is in anticipation of the indexing meta-data being small enough
2752         in the common case that m_butterfly always points to the first indexed
2753         property.
2754         
2755         This is performance neutral, except on tests that use indexed properties on
2756         plain objects, where the speed-up is in excess of an order of magnitude.
2757         
2758         One notable aspect of what this change brings is that it allows indexing
2759         storage to morph over time. Currently this is only used to allow all non-array
2760         objects to start out without any indexed storage. But it could be used for
2761         some kinds of array type inference in the future.
2762
2763         * API/JSCallbackObject.h:
2764         (JSCallbackObject):
2765         * API/JSCallbackObjectFunctions.h:
2766         (JSC::::getOwnPropertySlotByIndex):
2767         (JSC):
2768         (JSC::::getOwnNonIndexPropertyNames):
2769         * API/JSObjectRef.cpp:
2770         * CMakeLists.txt:
2771         * GNUmakefile.list.am:
2772         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
2773         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
2774         * JavaScriptCore.xcodeproj/project.pbxproj:
2775         * Target.pri:
2776         * bytecode/ArrayProfile.h:
2777         (JSC):
2778         (JSC::arrayModeFromStructure):
2779         * bytecompiler/BytecodeGenerator.cpp:
2780         (JSC::BytecodeGenerator::emitDirectPutById):
2781         * dfg/DFGAbstractState.cpp:
2782         (JSC::DFG::AbstractState::execute):
2783         * dfg/DFGAdjacencyList.h:
2784         (JSC::DFG::AdjacencyList::AdjacencyList):
2785         (AdjacencyList):
2786         * dfg/DFGArrayMode.cpp:
2787         (JSC::DFG::fromObserved):
2788         (JSC::DFG::modeAlreadyChecked):
2789         (JSC::DFG::modeToString):
2790         * dfg/DFGArrayMode.h:
2791         (DFG):
2792         (JSC::DFG::modeUsesButterfly):
2793         (JSC::DFG::modeIsJSArray):
2794         (JSC::DFG::isInBoundsAccess):
2795         (JSC::DFG::modeSupportsLength):
2796         * dfg/DFGByteCodeParser.cpp:
2797         (JSC::DFG::ByteCodeParser::handleGetByOffset):
2798         (JSC::DFG::ByteCodeParser::parseBlock):
2799         * dfg/DFGCSEPhase.cpp:
2800         (JSC::DFG::CSEPhase::getPropertyStorageLoadElimination):
2801         (JSC::DFG::CSEPhase::performNodeCSE):
2802         * dfg/DFGFixupPhase.cpp:
2803         (JSC::DFG::FixupPhase::fixupNode):
2804         (JSC::DFG::FixupPhase::addNode):
2805         (FixupPhase):
2806         (JSC::DFG::FixupPhase::checkArray):
2807         * dfg/DFGGraph.h:
2808         (JSC::DFG::Graph::byValIsPure):
2809         * dfg/DFGNode.h:
2810         (JSC::DFG::Node::Node):
2811         (Node):
2812         * dfg/DFGNodeType.h:
2813         (DFG):
2814         * dfg/DFGOperations.cpp:
2815         (JSC::DFG::putByVal):
2816         * dfg/DFGOperations.h:
2817         * dfg/DFGPredictionPropagationPhase.cpp:
2818         (JSC::DFG::PredictionPropagationPhase::propagate):
2819         * dfg/DFGRepatch.cpp:
2820         (JSC::DFG::generateProtoChainAccessStub):
2821         (JSC::DFG::tryCacheGetByID):
2822         (JSC::DFG::tryBuildGetByIDList):
2823         (JSC::DFG::emitPutReplaceStub):
2824         (JSC::DFG::emitPutTransitionStub):
2825         (JSC::DFG::tryBuildPutByIdList):
2826         * dfg/DFGSpeculativeJIT.cpp:
2827         (JSC::DFG::SpeculativeJIT::checkArray):
2828         (JSC::DFG::SpeculativeJIT::compileGetIndexedPropertyStorage):
2829         (JSC::DFG::SpeculativeJIT::compileGetArrayLength):
2830         (JSC::DFG::SpeculativeJIT::compileAllocatePropertyStorage):
2831         (JSC::DFG::SpeculativeJIT::compileReallocatePropertyStorage):
2832         * dfg/DFGSpeculativeJIT.h:
2833         (JSC::DFG::SpeculativeJIT::callOperation):
2834         (JSC::DFG::SpeculativeJIT::emitAllocateBasicJSObject):
2835         * dfg/DFGSpeculativeJIT32_64.cpp:
2836         (JSC::DFG::SpeculativeJIT::cachedGetById):
2837         (JSC::DFG::SpeculativeJIT::cachedPutById):
2838         (JSC::DFG::SpeculativeJIT::compile):
2839         * dfg/DFGSpeculativeJIT64.cpp:
2840         (JSC::DFG::SpeculativeJIT::cachedGetById):
2841         (JSC::DFG::SpeculativeJIT::cachedPutById):
2842         (JSC::DFG::SpeculativeJIT::compile):
2843         * dfg/DFGStructureCheckHoistingPhase.cpp:
2844         (JSC::DFG::StructureCheckHoistingPhase::run):
2845         * heap/CopiedSpace.h:
2846         (CopiedSpace):
2847         * jit/JIT.h:
2848         * jit/JITInlineMethods.h:
2849         (JSC::JIT::emitAllocateBasicJSObject):
2850         (JSC::JIT::emitAllocateBasicStorage):
2851         (JSC::JIT::emitAllocateJSArray):
2852         * jit/JITOpcodes.cpp:
2853         (JSC::JIT::emit_op_new_array):
2854         (JSC::JIT::emitSlow_op_new_array):
2855         * jit/JITPropertyAccess.cpp:
2856         (JSC::JIT::emit_op_get_by_val):
2857         (JSC::JIT::compileGetDirectOffset):
2858         (JSC::JIT::emit_op_put_by_val):
2859         (JSC::JIT::compileGetByIdHotPath):
2860         (JSC::JIT::emit_op_put_by_id):
2861         (JSC::JIT::compilePutDirectOffset):
2862         (JSC::JIT::privateCompilePatchGetArrayLength):
2863         * jit/JITPropertyAccess32_64.cpp:
2864         (JSC::JIT::emit_op_get_by_val):
2865         (JSC::JIT::emit_op_put_by_val):
2866         (JSC::JIT::compileGetByIdHotPath):
2867         (JSC::JIT::emit_op_put_by_id):
2868         (JSC::JIT::compilePutDirectOffset):
2869         (JSC::JIT::compileGetDirectOffset):
2870         (JSC::JIT::privateCompilePatchGetArrayLength):
2871         * jit/JITStubs.cpp:
2872         (JSC::DEFINE_STUB_FUNCTION):
2873         * jsc.cpp:
2874         * llint/LLIntSlowPaths.cpp:
2875         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
2876         * llint/LowLevelInterpreter.asm:
2877         * llint/LowLevelInterpreter32_64.asm:
2878         * llint/LowLevelInterpreter64.asm:
2879         * runtime/Arguments.cpp:
2880         (JSC::Arguments::deletePropertyByIndex):
2881         (JSC::Arguments::defineOwnProperty):
2882         * runtime/ArrayConstructor.cpp:
2883         * runtime/ArrayConventions.h: Added.
2884         (JSC):
2885         (JSC::isDenseEnoughForVector):
2886         (JSC::indexingHeaderForArray):
2887         (JSC::baseIndexingHeaderForArray):
2888         * runtime/ArrayPrototype.cpp:
2889         (JSC::ArrayPrototype::create):
2890         (JSC):
2891         (JSC::ArrayPrototype::ArrayPrototype):
2892         (JSC::arrayProtoFuncToString):
2893         (JSC::arrayProtoFuncJoin):
2894         (JSC::arrayProtoFuncSort):
2895         (JSC::arrayProtoFuncFilter):
2896         (JSC::arrayProtoFuncMap):
2897         (JSC::arrayProtoFuncEvery):
2898         (JSC::arrayProtoFuncForEach):
2899         (JSC::arrayProtoFuncSome):
2900         (JSC::arrayProtoFuncReduce):
2901         (JSC::arrayProtoFuncReduceRight):
2902         * runtime/ArrayPrototype.h:
2903         (ArrayPrototype):
2904         (JSC::ArrayPrototype::createStructure):
2905         * runtime/ArrayStorage.h: Added.
2906         (JSC):
2907         (ArrayStorage):
2908         (JSC::ArrayStorage::ArrayStorage):
2909         (JSC::ArrayStorage::from):
2910         (JSC::ArrayStorage::butterfly):
2911         (JSC::ArrayStorage::indexingHeader):
2912         (JSC::ArrayStorage::length):
2913         (JSC::ArrayStorage::setLength):
2914         (JSC::ArrayStorage::vectorLength):
2915         (JSC::ArrayStorage::setVectorLength):
2916         (JSC::ArrayStorage::copyHeaderFromDuringGC):
2917         (JSC::ArrayStorage::inSparseMode):
2918         (JSC::ArrayStorage::lengthOffset):
2919         (JSC::ArrayStorage::vectorLengthOffset):
2920         (JSC::ArrayStorage::numValuesInVectorOffset):
2921         (JSC::ArrayStorage::vectorOffset):
2922         (JSC::ArrayStorage::indexBiasOffset):
2923         (JSC::ArrayStorage::sparseMapOffset):
2924         (JSC::ArrayStorage::sizeFor):
2925         * runtime/Butterfly.h: Added.
2926         (JSC):
2927         (Butterfly):
2928         (JSC::Butterfly::Butterfly):
2929         (JSC::Butterfly::totalSize):
2930         (JSC::Butterfly::fromBase):
2931         (JSC::Butterfly::offsetOfIndexingHeader):
2932         (JSC::Butterfly::offsetOfPublicLength):
2933         (JSC::Butterfly::offsetOfVectorLength):
2934         (JSC::Butterfly::indexingHeader):
2935         (JSC::Butterfly::propertyStorage):
2936         (JSC::Butterfly::indexingPayload):
2937         (JSC::Butterfly::arrayStorage):
2938         (JSC::Butterfly::offsetOfPropertyStorage):
2939         (JSC::Butterfly::indexOfPropertyStorage):
2940         (JSC::Butterfly::base):
2941         * runtime/ButterflyInlineMethods.h: Added.
2942         (JSC):
2943         (JSC::Butterfly::createUninitialized):
2944         (JSC::Butterfly::create):
2945         (JSC::Butterfly::createUninitializedDuringCollection):
2946         (JSC::Butterfly::base):
2947         (JSC::Butterfly::growPropertyStorage):
2948         (JSC::Butterfly::growArrayRight):
2949         (JSC::Butterfly::resizeArray):
2950         (JSC::Butterfly::unshift):
2951         (JSC::Butterfly::shift):
2952         * runtime/ClassInfo.h:
2953         (MethodTable):
2954         (JSC):
2955         * runtime/IndexingHeader.h: Added.
2956         (JSC):
2957         (IndexingHeader):
2958         (JSC::IndexingHeader::offsetOfIndexingHeader):
2959         (JSC::IndexingHeader::offsetOfPublicLength):
2960         (JSC::IndexingHeader::offsetOfVectorLength):
2961         (JSC::IndexingHeader::IndexingHeader):
2962         (JSC::IndexingHeader::vectorLength):
2963         (JSC::IndexingHeader::setVectorLength):
2964         (JSC::IndexingHeader::publicLength):
2965         (JSC::IndexingHeader::setPublicLength):
2966         (JSC::IndexingHeader::from):
2967         (JSC::IndexingHeader::fromEndOf):
2968         (JSC::IndexingHeader::propertyStorage):
2969         (JSC::IndexingHeader::arrayStorage):
2970         (JSC::IndexingHeader::butterfly):
2971         * runtime/IndexingHeaderInlineMethods.h: Added.
2972         (JSC):
2973         (JSC::IndexingHeader::preCapacity):
2974         (JSC::IndexingHeader::indexingPayloadSizeInBytes):
2975         * runtime/IndexingType.h: Added.
2976         (JSC):
2977         (JSC::hasIndexingHeader):
2978         * runtime/JSActivation.cpp:
2979         (JSC::JSActivation::JSActivation):
2980         (JSC::JSActivation::visitChildren):
2981         (JSC::JSActivation::getOwnNonIndexPropertyNames):
2982         * runtime/JSActivation.h:
2983         (JSActivation):
2984         (JSC::JSActivation::tearOff):
2985         * runtime/JSArray.cpp:
2986         (JSC):
2987         (JSC::createArrayButterflyInDictionaryIndexingMode):
2988         (JSC::JSArray::setLengthWritable):
2989         (JSC::JSArray::defineOwnProperty):
2990         (JSC::JSArray::getOwnPropertySlot):
2991         (JSC::JSArray::getOwnPropertyDescriptor):
2992         (JSC::JSArray::put):
2993         (JSC::JSArray::deleteProperty):
2994         (JSC::JSArray::getOwnNonIndexPropertyNames):
2995         (JSC::JSArray::unshiftCountSlowCase):
2996         (JSC::JSArray::setLength):
2997         (JSC::JSArray::pop):
2998         (JSC::JSArray::push):
2999         (JSC::JSArray::shiftCount):
3000         (JSC::JSArray::unshiftCount):
3001         (JSC::JSArray::sortNumeric):
3002         (JSC::JSArray::sort):
3003         (JSC::JSArray::fillArgList):
3004         (JSC::JSArray::copyToArguments):
3005         (JSC::JSArray::compactForSorting):
3006         * runtime/JSArray.h:
3007         (JSC):
3008         (JSArray):
3009         (JSC::JSArray::JSArray):
3010         (JSC::JSArray::length):
3011         (JSC::JSArray::createStructure):
3012         (JSC::JSArray::isLengthWritable):
3013         (JSC::createArrayButterfly):
3014         (JSC::JSArray::create):
3015         (JSC::JSArray::tryCreateUninitialized):
3016         * runtime/JSBoundFunction.cpp:
3017         (JSC::boundFunctionCall):
3018         (JSC::boundFunctionConstruct):
3019         (JSC::JSBoundFunction::finishCreation):
3020         * runtime/JSCell.cpp:
3021         (JSC::JSCell::getOwnNonIndexPropertyNames):
3022         (JSC):
3023         * runtime/JSCell.h:
3024         (JSCell):
3025         * runtime/JSFunction.cpp:
3026         (JSC::JSFunction::getOwnPropertySlot):
3027         (JSC::JSFunction::getOwnPropertyDescriptor):
3028         (JSC::JSFunction::getOwnNonIndexPropertyNames):
3029         (JSC::JSFunction::defineOwnProperty):
3030         * runtime/JSFunction.h:
3031         (JSFunction):
3032         * runtime/JSGlobalData.cpp:
3033         (JSC::JSGlobalData::JSGlobalData):
3034         * runtime/JSGlobalData.h:
3035         (JSGlobalData):
3036         * runtime/JSGlobalObject.cpp:
3037         (JSC::JSGlobalObject::reset):
3038         * runtime/JSONObject.cpp:
3039         (JSC::Stringifier::Holder::appendNextProperty):
3040         (JSC::Walker::walk):
3041         * runtime/JSObject.cpp:
3042         (JSC):
3043         (JSC::JSObject::visitButterfly):
3044         (JSC::JSObject::visitChildren):
3045         (JSC::JSFinalObject::visitChildren):
3046         (JSC::JSObject::getOwnPropertySlotByIndex):
3047         (JSC::JSObject::put):
3048         (JSC::JSObject::putByIndex):
3049         (JSC::JSObject::enterDictionaryIndexingModeWhenArrayStorageAlreadyExists):
3050         (JSC::JSObject::enterDictionaryIndexingMode):
3051         (JSC::JSObject::createArrayStorage):
3052         (JSC::JSObject::createInitialArrayStorage):
3053         (JSC::JSObject::ensureArrayStorageExistsAndEnterDictionaryIndexingMode):
3054         (JSC::JSObject::putDirectAccessor):
3055         (JSC::JSObject::deleteProperty):
3056         (JSC::JSObject::deletePropertyByIndex):
3057         (JSC::JSObject::getOwnPropertyNames):
3058         (JSC::JSObject::getOwnNonIndexPropertyNames):
3059         (JSC::JSObject::preventExtensions):
3060         (JSC::JSObject::fillGetterPropertySlot):
3061         (JSC::JSObject::putIndexedDescriptor):
3062         (JSC::JSObject::defineOwnIndexedProperty):
3063         (JSC::JSObject::allocateSparseIndexMap):
3064         (JSC::JSObject::deallocateSparseIndexMap):
3065         (JSC::JSObject::putByIndexBeyondVectorLengthWithArrayStorage):
3066         (JSC::JSObject::putByIndexBeyondVectorLength):
3067         (JSC::JSObject::putDirectIndexBeyondVectorLengthWithArrayStorage):
3068         (JSC::JSObject::putDirectIndexBeyondVectorLength):
3069         (JSC::JSObject::getNewVectorLength):
3070         (JSC::JSObject::increaseVectorLength):
3071         (JSC::JSObject::checkIndexingConsistency):
3072         (JSC::JSObject::growOutOfLineStorage):
3073         (JSC::JSObject::getOwnPropertyDescriptor):
3074         (JSC::putDescriptor):
3075         (JSC::JSObject::putDirectMayBeIndex):
3076         (JSC::JSObject::defineOwnNonIndexProperty):
3077         (JSC::JSObject::defineOwnProperty):
3078         (JSC::JSObject::getOwnPropertySlotSlow):
3079         * runtime/JSObject.h:
3080         (JSC::JSObject::getArrayLength):
3081         (JSObject):
3082         (JSC::JSObject::getVectorLength):
3083         (JSC::JSObject::putDirectIndex):
3084         (JSC::JSObject::canGetIndexQuickly):
3085         (JSC::JSObject::getIndexQuickly):
3086         (JSC::JSObject::canSetIndexQuickly):
3087         (JSC::JSObject::setIndexQuickly):
3088         (JSC::JSObject::initializeIndex):
3089         (JSC::JSObject::completeInitialization):
3090         (JSC::JSObject::inSparseIndexingMode):
3091         (JSC::JSObject::butterfly):
3092         (JSC::JSObject::outOfLineStorage):
3093         (JSC::JSObject::offsetForLocation):
3094         (JSC::JSObject::indexingShouldBeSparse):
3095         (JSC::JSObject::butterflyOffset):
3096         (JSC::JSObject::butterflyAddress):
3097         (JSC::JSObject::arrayStorage):
3098         (JSC::JSObject::arrayStorageOrZero):
3099         (JSC::JSObject::ensureArrayStorage):
3100         (JSC::JSObject::checkIndexingConsistency):
3101         (JSC::JSNonFinalObject::JSNonFinalObject):
3102         (JSC):
3103         (JSC::JSObject::setButterfly):
3104         (JSC::JSObject::setButterflyWithoutChangingStructure):
3105         (JSC::JSObject::JSObject):
3106         (JSC::JSObject::inlineGetOwnPropertySlot):
3107         (JSC::JSObject::putDirectInternal):
3108         (JSC::JSObject::setStructureAndReallocateStorageIfNecessary):
3109         (JSC::JSObject::putDirectWithoutTransition):
3110         (JSC::offsetInButterfly):
3111         (JSC::offsetRelativeToPatchedStorage):
3112         (JSC::indexRelativeToBase):
3113         (JSC::offsetRelativeToBase):
3114         * runtime/JSPropertyNameIterator.cpp:
3115         (JSC::JSPropertyNameIterator::create):
3116         * runtime/JSSymbolTableObject.cpp:
3117         (JSC::JSSymbolTableObject::getOwnNonIndexPropertyNames):
3118         * runtime/JSSymbolTableObject.h:
3119         (JSSymbolTableObject):
3120         * runtime/JSTypeInfo.h:
3121         (JSC):
3122         (JSC::TypeInfo::interceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero):
3123         (JSC::TypeInfo::overridesGetPropertyNames):
3124         * runtime/LiteralParser.cpp:
3125         (JSC::::parse):
3126         * runtime/ObjectConstructor.cpp:
3127         * runtime/ObjectPrototype.cpp:
3128         (JSC::ObjectPrototype::ObjectPrototype):
3129         (JSC):
3130         * runtime/ObjectPrototype.h:
3131         (ObjectPrototype):
3132         * runtime/PropertyOffset.h:
3133         (JSC::offsetInOutOfLineStorage):
3134         * runtime/PropertyStorage.h: Added.
3135         (JSC):
3136         * runtime/PutDirectIndexMode.h: Added.
3137         (JSC):
3138         * runtime/RegExpMatchesArray.cpp:
3139         (JSC::RegExpMatchesArray::RegExpMatchesArray):
3140         (JSC):
3141         (JSC::RegExpMatchesArray::create):
3142         (JSC::RegExpMatchesArray::finishCreation):
3143         * runtime/RegExpMatchesArray.h:
3144         (RegExpMatchesArray):
3145         (JSC::RegExpMatchesArray::createStructure):
3146         * runtime/RegExpObject.cpp:
3147         (JSC::RegExpObject::getOwnNonIndexPropertyNames):
3148         * runtime/RegExpObject.h:
3149         (RegExpObject):
3150         * runtime/Reject.h: Added.
3151         (JSC):
3152         (JSC::reject):
3153         * runtime/SparseArrayValueMap.cpp: Added.
3154         (JSC):
3155         * runtime/SparseArrayValueMap.h: Added.
3156         (JSC):
3157         (SparseArrayEntry):
3158         (JSC::SparseArrayEntry::SparseArrayEntry):
3159         (SparseArrayValueMap):
3160         (JSC::SparseArrayValueMap::sparseMode):
3161         (JSC::SparseArrayValueMap::setSparseMode):
3162         (JSC::SparseArrayValueMap::lengthIsReadOnly):
3163         (JSC::SparseArrayValueMap::setLengthIsReadOnly):
3164         (JSC::SparseArrayValueMap::find):
3165         (JSC::SparseArrayValueMap::remove):
3166         (JSC::SparseArrayValueMap::notFound):
3167         (JSC::SparseArrayValueMap::isEmpty):
3168         (JSC::SparseArrayValueMap::contains):
3169         (JSC::SparseArrayValueMap::size):
3170         (JSC::SparseArrayValueMap::begin):
3171         (JSC::SparseArrayValueMap::end):
3172         * runtime/SparseArrayValueMapInlineMethods.h: Added.
3173         (JSC):
3174         (JSC::SparseArrayValueMap::SparseArrayValueMap):
3175         (JSC::SparseArrayValueMap::~SparseArrayValueMap):
3176         (JSC::SparseArrayValueMap::finishCreation):
3177         (JSC::SparseArrayValueMap::create):
3178         (JSC::SparseArrayValueMap::destroy):
3179         (JSC::SparseArrayValueMap::createStructure):
3180         (JSC::SparseArrayValueMap::add):
3181         (JSC::SparseArrayValueMap::putEntry):
3182         (JSC::SparseArrayValueMap::putDirect):
3183         (JSC::SparseArrayEntry::get):
3184         (JSC::SparseArrayEntry::getNonSparseMode):
3185         (JSC::SparseArrayValueMap::visitChildren):
3186         * runtime/StorageBarrier.h: Removed.
3187         * runtime/StringObject.cpp:
3188         (JSC::StringObject::putByIndex):
3189         (JSC):
3190         (JSC::StringObject::deletePropertyByIndex):
3191         * runtime/StringObject.h:
3192         (StringObject):
3193         * runtime/StringPrototype.cpp:
3194         * runtime/Structure.cpp:
3195         (JSC::Structure::Structure):
3196         (JSC::Structure::materializePropertyMap):
3197         (JSC::Structure::nonPropertyTransition):
3198         (JSC):
3199         * runtime/Structure.h:
3200         (Structure):
3201         (JSC::Structure::indexingType):
3202         (JSC::Structure::indexingTypeIncludingHistory):
3203         (JSC::Structure::indexingTypeOffset):
3204         (JSC::Structure::create):
3205         * runtime/StructureTransitionTable.h:
3206         (JSC):
3207         (JSC::toAttributes):
3208         (JSC::newIndexingType):
3209         (JSC::StructureTransitionTable::Hash::hash):
3210         * tests/mozilla/js1_6/Array/regress-304828.js:
3211
3212 2012-09-12  Mark Lam  <mark.lam@apple.com>
3213
3214         Refactor Opcodes to distinguish between core and extension opcodes.
3215         https://bugs.webkit.org/show_bug.cgi?id=96466.
3216
3217         Reviewed by Filip Pizlo.
3218
3219         * bytecode/Opcode.h:
3220         (JSC): Added FOR_EACH_CORE_OPCODE_ID() macro.
3221         * llint/LowLevelInterpreter.h:
3222         (JSC): Auto-generate llint opcode aliases using the
3223             FOR_EACH_CORE_OPCODE_ID() macro.
3224
3225 2012-09-11  Geoffrey Garen  <ggaren@apple.com>
3226
3227         Second step to fixing the Windows build: Add new symbols.
3228
3229         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
3230
3231 2012-09-11  Geoffrey Garen  <ggaren@apple.com>
3232
3233         First step to fixing the Windows build: Remove old symbols.
3234
3235         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
3236
3237 2012-09-11  Geoffrey Garen  <ggaren@apple.com>
3238
3239         Don't allocate a backing store just for a function's name
3240         https://bugs.webkit.org/show_bug.cgi?id=96468
3241
3242         Reviewed by Oliver Hunt.
3243
3244         Treat function.name like function.length etc., and use a custom getter.
3245         This saves space in closures.
3246
3247         * debugger/DebuggerCallFrame.cpp:
3248         (JSC::DebuggerCallFrame::functionName):
3249         * debugger/DebuggerCallFrame.h:
3250         (DebuggerCallFrame): Updated for interface change.
3251
3252         * runtime/Executable.h:
3253         (JSC::JSFunction::JSFunction): Do a little inlining.
3254
3255         * runtime/JSFunction.cpp:
3256         (JSC::JSFunction::finishCreation): Gone now. That's the point of the patch.
3257
3258         (JSC::JSFunction::name):
3259         (JSC::JSFunction::displayName):
3260         (JSC::JSFunction::nameGetter):
3261         (JSC::JSFunction::getOwnPropertySlot):
3262         (JSC::JSFunction::getOwnPropertyDescriptor):
3263         (JSC::JSFunction::getOwnPropertyNames):
3264         (JSC::JSFunction::put):
3265         (JSC::JSFunction::deleteProperty):
3266         (JSC::JSFunction::defineOwnProperty): Added custom accessors for .name
3267         just like .length and others.
3268
3269         * runtime/JSFunction.h:
3270         (JSC::JSFunction::create):
3271         (JSFunction): Updated for interface changes.
3272
3273 2012-09-11  Mark Hahnenberg  <mhahnenberg@apple.com>
3274
3275         IncrementalSweeper should not sweep/free Zapped blocks
3276         https://bugs.webkit.org/show_bug.cgi?id=96464
3277
3278         Reviewed by Filip Pizlo.
3279
3280         This is not beneficial in terms of performance because there isn't any way a block can emerge
3281         in the Zapped state from a call to Heap::collect() unless we run an eager sweep on it, in which 
3282         case we've already run all the destructors we possibly can. This also causes bugs since we don't 
3283         take zapped-ness into account when determining whether or not a block is empty to free it. The 
3284         incremental sweeper can then accidentally free blocks that it thinks are empty but are in fact 
3285         zapped with still-live objects in them.
3286
3287         * heap/MarkedBlock.h:
3288         (JSC::MarkedBlock::needsSweeping): It is only valid to sweep a block if it is in the Marked state.
3289
3290 2012-09-11  Geoffrey Garen  <ggaren@apple.com>
3291
3292         JSActivation should inline allocate its registers, and eliminate
3293         'arguments' registers in the common case
3294         https://bugs.webkit.org/show_bug.cgi?id=96427
3295
3296         Reviewed by Filip Pizlo.
3297
3298         This cuts the size class for simple closures down to 64 bytes.
3299
3300         * bytecompiler/BytecodeGenerator.cpp:
3301         (JSC::BytecodeGenerator::BytecodeGenerator): Set the usesNonStrictEval
3302         flag, which is new. Use a more specific test for whether a function
3303         uses 'arguments', so we can avoid allocating, initializing, and tearing
3304         off those registers in the common case. Distinguish between capturing
3305         arguments and not, so we can avoid allocating space for arguments in
3306         the torn-off object.
3307
3308         We can make this even more general in the future, with some bytecode
3309         generator refactoring.
3310
3311         (JSC::BytecodeGenerator::resolve): Updated for new interface.
3312
3313         * bytecompiler/BytecodeGenerator.h:
3314         (BytecodeGenerator):
3315         (JSC::BytecodeGenerator::symbolTable): Updated some types.
3316
3317         * heap/Heap.cpp:
3318         (JSC::Heap::isValidAllocation): Allow large allocations, now that they
3319         are both supported and used.
3320
3321         * heap/Heap.h:
3322         (Heap): Added a new form of allocateCell that specifies the full size
3323         of the allocation, to allow for extra space on the end.
3324
3325         * interpreter/CallFrame.h:
3326         (JSC::ExecState::argumentOffset):
3327         (JSC::ExecState::argumentOffsetIncludingThis):
3328         * interpreter/Interpreter.cpp:
3329         (JSC::Interpreter::unwindCallFrame): Refactored this code to be more
3330         specific about tearing off 'arguments' vs activations. This is something
3331         I forgot in my last patch, and it is required now that we can have
3332         acitvations without 'arguments' registers.
3333
3334         * runtime/Arguments.h:
3335         (JSC::Arguments::setRegisters): No need for setRegisters anymore because
3336         the activation object's storage doesn't change.
3337
3338         * runtime/JSActivation.cpp:
3339         (JSC::JSActivation::JSActivation): Initialize our storage manually because
3340         it's not declared to the C++ compiler.
3341
3342         (JSC::JSActivation::visitChildren): No copyAndAppend because our storage
3343         is not out-of-line anymore.
3344
3345         (JSC::JSActivation::symbolTableGet):
3346         (JSC::JSActivation::symbolTablePut):
3347         (JSC::JSActivation::getOwnPropertyNames):
3348         (JSC::JSActivation::symbolTablePutWithAttributes):
3349         (JSC::JSActivation::getOwnPropertySlot):
3350         (JSC::JSActivation::getOwnPropertyDescriptor):
3351         (JSC::JSActivation::argumentsGetter): Refactored isTornOff() testing to
3352         avoid using a data member and to avoid hard-coding any offset assumptions.
3353
3354         * runtime/JSActivation.h:
3355         (JSC):
3356         (JSActivation):
3357         (JSC::JSActivation::create):
3358         (JSC::JSActivation::isDynamicScope):
3359         (JSC::JSActivation::captureStart):
3360         (JSC::JSActivation::storageSize):
3361         (JSC::JSActivation::storageSizeInBytes):
3362         (JSC::JSActivation::registerOffset):
3363         (JSC::JSActivation::tearOff):
3364         (JSC::JSActivation::isTornOff):
3365         (JSC::JSActivation::storage):
3366         (JSC::JSActivation::allocationSize):
3367         (JSC::JSActivation::isValid): New helper functions for doing the math
3368         on our inline storage. Note that in the "AllOfTheThings" tear-off case,
3369         the number of things is not known at compile time, so we store the
3370         number in the argument count register. We can't just copy the raw contents
3371         of the register beacuse we need a value that is safe for precise marking,
3372         and the value in the register file has an invalid tag.
3373
3374         * runtime/JSCell.h:
3375         (JSC::allocateCell): New function for allocating with extra storage
3376         on the end.
3377
3378         * runtime/JSSymbolTableObject.h:
3379         (JSC::JSSymbolTableObject::JSSymbolTableObject):