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