Attempt to fix the build.
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2012-10-17  Sam Weinig  <sam@webkit.org>
2
3         Attempt to fix the build.
4
5         * bytecode/GlobalResolveInfo.h: Copied from bytecode/GlobalResolveInfo.h.
6
7 2012-10-17  Oliver Hunt  <oliver@apple.com>
8
9         Roll out r131645 as it causes random site crashes.
10         
11         * GNUmakefile.list.am:
12         * JavaScriptCore.xcodeproj/project.pbxproj:
13         * bytecode/CodeBlock.cpp:
14         (JSC):
15         (JSC::isGlobalResolve):
16         (JSC::instructionOffsetForNth):
17         (JSC::printGlobalResolveInfo):
18         (JSC::CodeBlock::printStructures):
19         (JSC::CodeBlock::dump):
20         (JSC::CodeBlock::CodeBlock):
21         (JSC::CodeBlock::visitStructures):
22         (JSC::CodeBlock::finalizeUnconditionally):
23         (JSC::CodeBlock::hasGlobalResolveInfoAtBytecodeOffset):
24         (JSC::CodeBlock::globalResolveInfoForBytecodeOffset):
25         (JSC::CodeBlock::shrinkToFit):
26         * bytecode/CodeBlock.h:
27         (CodeBlock):
28         (JSC::CodeBlock::addGlobalResolveInstruction):
29         (JSC::CodeBlock::addGlobalResolveInfo):
30         (JSC::CodeBlock::globalResolveInfo):
31         (JSC::CodeBlock::numberOfGlobalResolveInfos):
32         (JSC::CodeBlock::globalResolveInfoCount):
33         * bytecode/Opcode.h:
34         (JSC):
35         (JSC::padOpcodeName):
36         * bytecode/ResolveGlobalStatus.cpp:
37         (JSC):
38         (JSC::computeForStructure):
39         (JSC::computeForLLInt):
40         (JSC::ResolveGlobalStatus::computeFor):
41         * bytecode/ResolveGlobalStatus.h:
42         (JSC):
43         (ResolveGlobalStatus):
44         * bytecompiler/BytecodeGenerator.cpp:
45         (JSC::ResolveResult::checkValidity):
46         (JSC::ResolveResult::registerPointer):
47         (JSC):
48         (JSC::BytecodeGenerator::BytecodeGenerator):
49         (JSC::BytecodeGenerator::resolve):
50         (JSC::BytecodeGenerator::resolveConstDecl):
51         (JSC::BytecodeGenerator::shouldAvoidResolveGlobal):
52         (JSC::BytecodeGenerator::emitResolve):
53         (JSC::BytecodeGenerator::emitResolveBase):
54         (JSC::BytecodeGenerator::emitResolveBaseForPut):
55         (JSC::BytecodeGenerator::emitResolveWithBase):
56         (JSC::BytecodeGenerator::emitResolveWithThis):
57         (JSC::BytecodeGenerator::emitGetStaticVar):
58         (JSC::BytecodeGenerator::emitInitGlobalConst):
59         (JSC::BytecodeGenerator::emitPutStaticVar):
60         * bytecompiler/BytecodeGenerator.h:
61         (JSC::ResolveResult::registerResolve):
62         (JSC::ResolveResult::dynamicResolve):
63         (JSC::ResolveResult::lexicalResolve):
64         (JSC::ResolveResult::indexedGlobalResolve):
65         (JSC::ResolveResult::dynamicIndexedGlobalResolve):
66         (JSC::ResolveResult::globalResolve):
67         (JSC::ResolveResult::dynamicGlobalResolve):
68         (JSC::ResolveResult::type):
69         (JSC::ResolveResult::index):
70         (JSC::ResolveResult::depth):
71         (JSC::ResolveResult::globalObject):
72         (ResolveResult):
73         (JSC::ResolveResult::isStatic):
74         (JSC::ResolveResult::isIndexed):
75         (JSC::ResolveResult::isScoped):
76         (JSC::ResolveResult::isGlobal):
77         (JSC::ResolveResult::ResolveResult):
78         (BytecodeGenerator):
79         * bytecompiler/NodesCodegen.cpp:
80         (JSC::ResolveNode::isPure):
81         (JSC::FunctionCallResolveNode::emitBytecode):
82         (JSC::PostfixNode::emitResolve):
83         (JSC::PrefixNode::emitResolve):
84         (JSC::ReadModifyResolveNode::emitBytecode):
85         (JSC::AssignResolveNode::emitBytecode):
86         (JSC::ConstDeclNode::emitCodeSingle):
87         (JSC::ForInNode::emitBytecode):
88         * dfg/DFGAbstractState.cpp:
89         (JSC::DFG::AbstractState::execute):
90         * dfg/DFGByteCodeParser.cpp:
91         (ByteCodeParser):
92         (InlineStackEntry):
93         (JSC::DFG::ByteCodeParser::handleGetByOffset):
94         (JSC::DFG::ByteCodeParser::parseBlock):
95         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
96         * dfg/DFGCapabilities.h:
97         (DFG):
98         (JSC::DFG::canCompileOpcode):
99         (JSC::DFG::canInlineOpcode):
100         * dfg/DFGGraph.h:
101         (ResolveGlobalData):
102         (DFG):
103         (Graph):
104         * dfg/DFGNode.h:
105         (JSC::DFG::Node::hasIdentifier):
106         * dfg/DFGNodeType.h:
107         (DFG):
108         * dfg/DFGOSRExit.cpp:
109         (JSC::DFG::OSRExit::OSRExit):
110         * dfg/DFGOSRExit.h:
111         (OSRExit):
112         * dfg/DFGOSRExitCompiler.cpp:
113         * dfg/DFGOSRExitCompiler32_64.cpp:
114         (JSC::DFG::OSRExitCompiler::compileExit):
115         * dfg/DFGOSRExitCompiler64.cpp:
116         (JSC::DFG::OSRExitCompiler::compileExit):
117         * dfg/DFGOperations.cpp:
118         * dfg/DFGOperations.h:
119         (JSC):
120         * dfg/DFGPredictionPropagationPhase.cpp:
121         (JSC::DFG::PredictionPropagationPhase::propagate):
122         * dfg/DFGRepatch.cpp:
123         (JSC::DFG::tryCacheGetByID):
124         * dfg/DFGSpeculativeJIT.cpp:
125         (JSC::DFG::SpeculativeJIT::convertLastOSRExitToForward):
126         * dfg/DFGSpeculativeJIT.h:
127         (JSC::DFG::SpeculativeJIT::callOperation):
128         * dfg/DFGSpeculativeJIT32_64.cpp:
129         (JSC::DFG::SpeculativeJIT::compile):
130         * dfg/DFGSpeculativeJIT64.cpp:
131         (JSC::DFG::SpeculativeJIT::compile):
132         * dfg/DFGStructureCheckHoistingPhase.cpp:
133         (JSC::DFG::StructureCheckHoistingPhase::run):
134         * jit/JIT.cpp:
135         (JSC::JIT::privateCompileMainPass):
136         (JSC::JIT::privateCompileSlowCases):
137         * jit/JIT.h:
138         (JIT):
139         (JSC::JIT::emit_op_get_global_var_watchable):
140         * jit/JITOpcodes.cpp:
141         (JSC::JIT::emit_op_resolve):
142         (JSC):
143         (JSC::JIT::emit_op_resolve_base):
144         (JSC::JIT::emit_op_resolve_skip):
145         (JSC::JIT::emit_op_resolve_global):
146         (JSC::JIT::emitSlow_op_resolve_global):
147         (JSC::JIT::emit_op_resolve_with_base):
148         (JSC::JIT::emit_op_resolve_with_this):
149         (JSC::JIT::emit_op_resolve_global_dynamic):
150         (JSC::JIT::emitSlow_op_resolve_global_dynamic):
151         * jit/JITOpcodes32_64.cpp:
152         (JSC::JIT::emit_op_resolve):
153         (JSC):
154         (JSC::JIT::emit_op_resolve_base):
155         (JSC::JIT::emit_op_resolve_skip):
156         (JSC::JIT::emit_op_resolve_global):
157         (JSC::JIT::emitSlow_op_resolve_global):
158         (JSC::JIT::emit_op_resolve_with_base):
159         (JSC::JIT::emit_op_resolve_with_this):
160         * jit/JITPropertyAccess.cpp:
161         (JSC::JIT::emit_op_get_scoped_var):
162         (JSC):
163         (JSC::JIT::emit_op_put_scoped_var):
164         (JSC::JIT::emit_op_get_global_var):
165         (JSC::JIT::emit_op_put_global_var):
166         (JSC::JIT::emit_op_put_global_var_check):
167         (JSC::JIT::emitSlow_op_put_global_var_check):
168         * jit/JITPropertyAccess32_64.cpp:
169         (JSC::JIT::emit_op_get_scoped_var):
170         (JSC):
171         (JSC::JIT::emit_op_put_scoped_var):
172         (JSC::JIT::emit_op_get_global_var):
173         (JSC::JIT::emit_op_put_global_var):
174         (JSC::JIT::emit_op_put_global_var_check):
175         (JSC::JIT::emitSlow_op_put_global_var_check):
176         * jit/JITStubs.cpp:
177         (JSC::DEFINE_STUB_FUNCTION):
178         (JSC):
179         * jit/JITStubs.h:
180         * llint/LLIntSlowPaths.cpp:
181         (LLInt):
182         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
183         * llint/LLIntSlowPaths.h:
184         (LLInt):
185         * llint/LowLevelInterpreter.asm:
186         * llint/LowLevelInterpreter32_64.asm:
187         * llint/LowLevelInterpreter64.asm:
188         * runtime/JSScope.cpp:
189         (JSC::JSScope::resolve):
190         (JSC::JSScope::resolveSkip):
191         (JSC::JSScope::resolveGlobal):
192         (JSC::JSScope::resolveGlobalDynamic):
193         (JSC::JSScope::resolveBase):
194         (JSC::JSScope::resolveWithBase):
195         (JSC::JSScope::resolveWithThis):
196         * runtime/JSScope.h:
197         (JSScope):
198         * runtime/JSVariableObject.cpp:
199         * runtime/JSVariableObject.h:
200         * runtime/Structure.h:
201
202 2012-10-17  Filip Pizlo  <fpizlo@apple.com>
203
204         REGRESSION (r130826 or r130828): Twitter top bar is dysfunctional
205         https://bugs.webkit.org/show_bug.cgi?id=99577
206         <rdar://problem/12518883>
207
208         Reviewed by Mark Hahnenberg.
209
210         It turns out that it's a good idea to maintain the invariants of your object model, such as that
211         elements past publicLength should have the hole value.
212
213         * dfg/DFGGraph.cpp:
214         (JSC::DFG::Graph::dump):
215         * dfg/DFGSpeculativeJIT32_64.cpp:
216         (JSC::DFG::SpeculativeJIT::compile):
217         * dfg/DFGSpeculativeJIT64.cpp:
218         (JSC::DFG::SpeculativeJIT::compile):
219
220 2012-10-17  Anders Carlsson  <andersca@apple.com>
221
222         Clean up Vector.h
223         https://bugs.webkit.org/show_bug.cgi?id=99622
224
225         Reviewed by Benjamin Poulain.
226
227         Fix fallout from removing std::max and std::min using declarations.
228
229         * runtime/StringPrototype.cpp:
230         (JSC::jsSpliceSubstrings):
231         (JSC::jsSpliceSubstringsWithSeparators):
232         (JSC::stringProtoFuncIndexOf):
233         * yarr/YarrPattern.cpp:
234         (JSC::Yarr::YarrPatternConstructor::setupDisjunctionOffsets):
235
236 2012-10-17  Oliver Hunt  <oliver@apple.com>
237
238         Committing new files is so overrated.
239
240         * bytecode/ResolveOperation.h: Added.
241         (JSC):
242         (JSC::ResolveOperation::getAndReturnScopedVar):
243         (JSC::ResolveOperation::checkForDynamicEntriesBeforeGlobalScope):
244         (ResolveOperation):
245         (JSC::ResolveOperation::getAndReturnGlobalVar):
246         (JSC::ResolveOperation::getAndReturnGlobalProperty):
247         (JSC::ResolveOperation::resolveFail):
248         (JSC::ResolveOperation::skipTopScopeNode):
249         (JSC::ResolveOperation::skipScopes):
250         (JSC::ResolveOperation::returnGlobalObjectAsBase):
251         (JSC::ResolveOperation::setBaseToGlobal):
252         (JSC::ResolveOperation::setBaseToUndefined):
253         (JSC::ResolveOperation::setBaseToScope):
254         (JSC::ResolveOperation::returnScopeAsBase):
255         (JSC::PutToBaseOperation::PutToBaseOperation):
256
257 2012-10-17  Michael Saboff  <msaboff@apple.com>
258
259         StringPrototype::jsSpliceSubstringsWithSeparators() doesn't optimally handle 8 bit strings
260         https://bugs.webkit.org/show_bug.cgi?id=99230
261
262         Reviewed by Geoffrey Garen.
263
264         Added code to select characters8() or characters16() on the not all 8 bit path for both the 
265         processing of the source and the separators.
266
267         * runtime/StringPrototype.cpp:
268         (JSC::jsSpliceSubstringsWithSeparators):
269
270 2012-10-17  Filip Pizlo  <fpizlo@apple.com>
271
272         Array and object allocations via 'new Object' or 'new Array' should be inlined in bytecode to allow allocation site profiling
273         https://bugs.webkit.org/show_bug.cgi?id=99557
274
275         Reviewed by Geoffrey Garen.
276
277         Removed an inaccurate and misleading comment as per Geoff's review. (I forgot
278         to make this change as part of http://trac.webkit.org/changeset/131644).
279
280         * bytecompiler/NodesCodegen.cpp:
281         (JSC::FunctionCallResolveNode::emitBytecode):
282
283 2012-10-17  Oliver Hunt  <oliver@apple.com>
284
285         Bytecode should not have responsibility for determining how to perform non-local resolves
286         https://bugs.webkit.org/show_bug.cgi?id=99349
287
288         Reviewed by Gavin Barraclough.
289
290         This patch removes lexical analysis from the bytecode generation.  This allows
291         us to delay lookup of a non-local variables until the lookup is actually necessary,
292         and simplifies a lot of the resolve logic in BytecodeGenerator.
293
294         Once a lookup is performed we cache the lookup information in a set of out-of-line
295         buffers in CodeBlock.  This allows subsequent lookups to avoid unnecessary hashing,
296         etc, and allows the respective JITs to recreated optimal lookup code.
297
298         This is currently still a performance regression in LLInt, but most of the remaining
299         regression is caused by a lot of indirection that I'll remove in future work, as well
300         as some work necessary to allow LLInt to perform in line instruction repatching.
301         We will also want to improve the behaviour of the baseline JIT for some of the lookup
302         operations, however this patch was getting quite large already so I'm landing it now
303         that we've reached the bar of "performance-neutral".
304
305         * GNUmakefile.list.am:
306         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
307         * JavaScriptCore.xcodeproj/project.pbxproj:
308         * bytecode/CodeBlock.cpp:
309         (JSC::CodeBlock::printStructures):
310         (JSC::CodeBlock::dump):
311         (JSC::CodeBlock::CodeBlock):
312         (JSC::CodeBlock::visitStructures):
313         (JSC):
314         (JSC::CodeBlock::finalizeUnconditionally):
315         (JSC::CodeBlock::shrinkToFit):
316         * bytecode/CodeBlock.h:
317         (JSC::CodeBlock::addResolve):
318         (JSC::CodeBlock::addPutToBase):
319         (CodeBlock):
320         (JSC::CodeBlock::resolveOperations):
321         (JSC::CodeBlock::putToBaseOperation):
322         (JSC::CodeBlock::numberOfResolveOperations):
323         (JSC::CodeBlock::numberOfPutToBaseOperations):
324         (JSC::CodeBlock::addPropertyAccessInstruction):
325         (JSC::CodeBlock::globalObjectConstant):
326         (JSC::CodeBlock::setGlobalObjectConstant):
327         * bytecode/GlobalResolveInfo.h: Removed.
328         * bytecode/Opcode.h:
329         (JSC):
330         (JSC::padOpcodeName):
331         * bytecode/ResolveGlobalStatus.cpp:
332         (JSC::computeForStructure):
333         (JSC::ResolveGlobalStatus::computeFor):
334         * bytecode/ResolveGlobalStatus.h:
335         (JSC):
336         (ResolveGlobalStatus):
337         * bytecode/ResolveOperation.h: Added.
338           The new types and logic we use to perform the cached lookups.
339         (JSC):
340         (ResolveOperation):
341         (JSC::ResolveOperation::getAndReturnScopedVar):
342         (JSC::ResolveOperation::checkForDynamicEntriesBeforeGlobalScope):
343         (JSC::ResolveOperation::getAndReturnGlobalVar):
344         (JSC::ResolveOperation::getAndReturnGlobalProperty):
345         (JSC::ResolveOperation::resolveFail):
346         (JSC::ResolveOperation::skipTopScopeNode):
347         (JSC::ResolveOperation::skipScopes):
348         (JSC::ResolveOperation::returnGlobalObjectAsBase):
349         (JSC::ResolveOperation::setBaseToGlobal):
350         (JSC::ResolveOperation::setBaseToUndefined):
351         (JSC::ResolveOperation::setBaseToScope):
352         (JSC::ResolveOperation::returnScopeAsBase):
353         (JSC::PutToBaseOperation::PutToBaseOperation):
354         * bytecompiler/BytecodeGenerator.cpp:
355         (JSC::ResolveResult::checkValidity):
356         (JSC):
357         (JSC::BytecodeGenerator::BytecodeGenerator):
358         (JSC::BytecodeGenerator::resolve):
359         (JSC::BytecodeGenerator::resolveConstDecl):
360         (JSC::BytecodeGenerator::shouldAvoidResolveGlobal):
361         (JSC::BytecodeGenerator::emitResolve):
362         (JSC::BytecodeGenerator::emitResolveBase):
363         (JSC::BytecodeGenerator::emitResolveBaseForPut):
364         (JSC::BytecodeGenerator::emitResolveWithBaseForPut):
365         (JSC::BytecodeGenerator::emitResolveWithThis):
366         (JSC::BytecodeGenerator::emitGetLocalVar):
367         (JSC::BytecodeGenerator::emitInitGlobalConst):
368         (JSC::BytecodeGenerator::emitPutToBase):
369         * bytecompiler/BytecodeGenerator.h:
370         (JSC::ResolveResult::registerResolve):
371         (JSC::ResolveResult::dynamicResolve):
372         (ResolveResult):
373         (JSC::ResolveResult::ResolveResult):
374         (JSC):
375         (NonlocalResolveInfo):
376         (JSC::NonlocalResolveInfo::NonlocalResolveInfo):
377         (JSC::NonlocalResolveInfo::~NonlocalResolveInfo):
378         (JSC::NonlocalResolveInfo::resolved):
379         (JSC::NonlocalResolveInfo::put):
380         (BytecodeGenerator):
381         (JSC::BytecodeGenerator::getResolveOperations):
382         (JSC::BytecodeGenerator::getResolveWithThisOperations):
383         (JSC::BytecodeGenerator::getResolveBaseOperations):
384         (JSC::BytecodeGenerator::getResolveBaseForPutOperations):
385         (JSC::BytecodeGenerator::getResolveWithBaseForPutOperations):
386         (JSC::BytecodeGenerator::getPutToBaseOperation):
387         * bytecompiler/NodesCodegen.cpp:
388         (JSC::ResolveNode::isPure):
389         (JSC::FunctionCallResolveNode::emitBytecode):
390         (JSC::PostfixNode::emitResolve):
391         (JSC::PrefixNode::emitResolve):
392         (JSC::ReadModifyResolveNode::emitBytecode):
393         (JSC::AssignResolveNode::emitBytecode):
394         (JSC::ConstDeclNode::emitCodeSingle):
395         (JSC::ForInNode::emitBytecode):
396         * dfg/DFGAbstractState.cpp:
397         (JSC::DFG::AbstractState::execute):
398         * dfg/DFGByteCodeParser.cpp:
399         (ByteCodeParser):
400         (InlineStackEntry):
401         (JSC::DFG::ByteCodeParser::handleGetByOffset):
402         (DFG):
403         (JSC::DFG::ByteCodeParser::parseResolveOperations):
404         (JSC::DFG::ByteCodeParser::parseBlock):
405         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
406         * dfg/DFGCapabilities.h:
407         (JSC::DFG::canCompileResolveOperations):
408         (DFG):
409         (JSC::DFG::canCompilePutToBaseOperation):
410         (JSC::DFG::canCompileOpcode):
411         (JSC::DFG::canInlineOpcode):
412         * dfg/DFGGraph.h:
413         (ResolveGlobalData):
414         (ResolveOperationData):
415         (DFG):
416         (PutToBaseOperationData):
417         (Graph):
418         * dfg/DFGNode.h:
419         (JSC::DFG::Node::hasIdentifier):
420         (JSC::DFG::Node::resolveOperationsDataIndex):
421         (Node):
422         * dfg/DFGNodeType.h:
423         (DFG):
424         * dfg/DFGOSRExit.cpp:
425         (JSC::DFG::OSRExit::OSRExit):
426         * dfg/DFGOSRExit.h:
427         (OSRExit):
428         * dfg/DFGOSRExitCompiler.cpp:
429         * dfg/DFGOSRExitCompiler32_64.cpp:
430         (JSC::DFG::OSRExitCompiler::compileExit):
431         * dfg/DFGOSRExitCompiler64.cpp:
432         (JSC::DFG::OSRExitCompiler::compileExit):
433         * dfg/DFGOperations.cpp:
434         * dfg/DFGOperations.h:
435         * dfg/DFGPredictionPropagationPhase.cpp:
436         (JSC::DFG::PredictionPropagationPhase::propagate):
437         * dfg/DFGRepatch.cpp:
438         (JSC::DFG::tryCacheGetByID):
439         * dfg/DFGSpeculativeJIT.cpp:
440         (JSC::DFG::SpeculativeJIT::convertLastOSRExitToForward):
441         * dfg/DFGSpeculativeJIT.h:
442         (JSC::DFG::SpeculativeJIT::resolveOperations):
443         (SpeculativeJIT):
444         (JSC::DFG::SpeculativeJIT::putToBaseOperation):
445         (JSC::DFG::SpeculativeJIT::callOperation):
446         * dfg/DFGSpeculativeJIT32_64.cpp:
447         (JSC::DFG::SpeculativeJIT::compile):
448         * dfg/DFGSpeculativeJIT64.cpp:
449         (JSC::DFG::SpeculativeJIT::compile):
450         * dfg/DFGStructureCheckHoistingPhase.cpp:
451         (JSC::DFG::StructureCheckHoistingPhase::run):
452         * jit/JIT.cpp:
453         (JSC::JIT::privateCompileMainPass):
454         (JSC::JIT::privateCompileSlowCases):
455         * jit/JIT.h:
456         (JIT):
457         * jit/JITOpcodes.cpp:
458         (JSC::JIT::emit_op_put_to_base):
459         (JSC):
460         (JSC::JIT::emit_resolve_operations):
461         (JSC::JIT::emitSlow_link_resolve_operations):
462         (JSC::JIT::emit_op_resolve):
463         (JSC::JIT::emitSlow_op_resolve):
464         (JSC::JIT::emit_op_resolve_base):
465         (JSC::JIT::emitSlow_op_resolve_base):
466         (JSC::JIT::emit_op_resolve_with_base):
467         (JSC::JIT::emitSlow_op_resolve_with_base):
468         (JSC::JIT::emit_op_resolve_with_this):
469         (JSC::JIT::emitSlow_op_resolve_with_this):
470         (JSC::JIT::emitSlow_op_put_to_base):
471         * jit/JITOpcodes32_64.cpp:
472         (JSC::JIT::emit_op_put_to_base):
473         (JSC):
474         * jit/JITPropertyAccess.cpp:
475         (JSC::JIT::emit_op_init_global_const):
476         (JSC::JIT::emit_op_init_global_const_check):
477         (JSC::JIT::emitSlow_op_init_global_const_check):
478         * jit/JITPropertyAccess32_64.cpp:
479         (JSC::JIT::emit_op_init_global_const):
480         (JSC::JIT::emit_op_init_global_const_check):
481         (JSC::JIT::emitSlow_op_init_global_const_check):
482         * jit/JITStubs.cpp:
483         (JSC::DEFINE_STUB_FUNCTION):
484         (JSC):
485         * jit/JITStubs.h:
486         * llint/LLIntSlowPaths.cpp:
487         (LLInt):
488         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
489         * llint/LLIntSlowPaths.h:
490         (LLInt):
491         * llint/LowLevelInterpreter.asm:
492         * llint/LowLevelInterpreter32_64.asm:
493         * llint/LowLevelInterpreter64.asm:
494         * runtime/JSScope.cpp:
495         (JSC::LookupResult::base):
496         (JSC::LookupResult::value):
497         (JSC::LookupResult::setBase):
498         (JSC::LookupResult::setValue):
499         (LookupResult):
500         (JSC):
501         (JSC::setPutPropertyAccessOffset):
502         (JSC::executeResolveOperations):
503         (JSC::JSScope::resolveContainingScopeInternal):
504         (JSC::JSScope::resolveContainingScope):
505         (JSC::JSScope::resolve):
506         (JSC::JSScope::resolveBase):
507         (JSC::JSScope::resolveWithBase):
508         (JSC::JSScope::resolveWithThis):
509         (JSC::JSScope::resolvePut):
510         (JSC::JSScope::resolveGlobal):
511         * runtime/JSScope.h:
512         (JSScope):
513         * runtime/JSVariableObject.cpp:
514         (JSC):
515         * runtime/JSVariableObject.h:
516         (JSVariableObject):
517         * runtime/Structure.h:
518         (JSC::Structure::propertyAccessesAreCacheable):
519         (Structure):
520
521 2012-10-17  Filip Pizlo  <fpizlo@apple.com>
522
523         Array and object allocations via 'new Object' or 'new Array' should be inlined in bytecode to allow allocation site profiling
524         https://bugs.webkit.org/show_bug.cgi?id=99557
525
526         Reviewed by Geoffrey Garen.
527
528         This uses the old jneq_ptr trick to allow for the bytecode to "see" that the
529         operation in question is what we almost certainly know it to be.
530
531         * bytecode/CodeBlock.cpp:
532         (JSC::CodeBlock::dump):
533         * bytecode/Opcode.h:
534         (JSC):
535         (JSC::padOpcodeName):
536         * bytecode/SpecialPointer.h:
537         * bytecompiler/BytecodeGenerator.cpp:
538         (JSC::BytecodeGenerator::emitCall):
539         (JSC::BytecodeGenerator::emitCallEval):
540         (JSC::BytecodeGenerator::expectedFunctionForIdentifier):
541         (JSC):
542         (JSC::BytecodeGenerator::emitExpectedFunctionSnippet):
543         (JSC::BytecodeGenerator::emitConstruct):
544         * bytecompiler/BytecodeGenerator.h:
545         (BytecodeGenerator):
546         * bytecompiler/NodesCodegen.cpp:
547         (JSC::NewExprNode::emitBytecode):
548         (JSC::FunctionCallValueNode::emitBytecode):
549         (JSC::FunctionCallResolveNode::emitBytecode):
550         (JSC::FunctionCallBracketNode::emitBytecode):
551         (JSC::FunctionCallDotNode::emitBytecode):
552         (JSC::CallFunctionCallDotNode::emitBytecode):
553         (JSC::ApplyFunctionCallDotNode::emitBytecode):
554         * dfg/DFGByteCodeParser.cpp:
555         (JSC::DFG::ByteCodeParser::parseBlock):
556         * dfg/DFGCapabilities.h:
557         (JSC::DFG::canCompileOpcode):
558         * jit/JIT.cpp:
559         (JSC::JIT::privateCompileMainPass):
560         * jit/JIT.h:
561         (JIT):
562         * jit/JITOpcodes.cpp:
563         (JSC::JIT::emit_op_new_array_with_size):
564         (JSC):
565         * jit/JITStubs.cpp:
566         (JSC::DEFINE_STUB_FUNCTION):
567         (JSC):
568         * jit/JITStubs.h:
569         * llint/LLIntSlowPaths.cpp:
570         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
571         (LLInt):
572         * llint/LLIntSlowPaths.h:
573         (LLInt):
574         * llint/LowLevelInterpreter.asm:
575         * runtime/ArrayConstructor.cpp:
576         (JSC::constructArrayWithSizeQuirk):
577         (JSC):
578         * runtime/ArrayConstructor.h:
579         (JSC):
580         * runtime/CommonIdentifiers.h:
581         * runtime/JSGlobalObject.cpp:
582         (JSC::JSGlobalObject::reset):
583         (JSC):
584
585 2012-10-17  Filip Pizlo  <fpizlo@apple.com>
586
587         JIT op_get_by_pname should call cti_get_by_val_generic and not cti_get_by_val
588         https://bugs.webkit.org/show_bug.cgi?id=99631
589         <rdar://problem/12483221>
590
591         Reviewed by Mark Hahnenberg.
592
593         cti_get_by_val assumes that the return address has patching metadata associated with it, which won't
594         be true for op_get_by_pname. cti_get_by_val_generic makes no such assumptions.
595
596         * jit/JITPropertyAccess.cpp:
597         (JSC::JIT::emitSlow_op_get_by_pname):
598         * jit/JITPropertyAccess32_64.cpp:
599         (JSC::JIT::emitSlow_op_get_by_pname):
600
601 2012-10-17  Mark Hahnenberg  <mhahnenberg@apple.com>
602
603         Block freeing thread should sleep indefinitely when there's no work to do
604         https://bugs.webkit.org/show_bug.cgi?id=98084
605
606         Reviewed by Geoffrey Garen.
607
608         r130212 didn't fully fix the problem.
609
610         * heap/BlockAllocator.cpp:
611         (JSC::BlockAllocator::blockFreeingThreadMain): We would just continue to the next iteration if 
612         we found that we had zero blocks to copy. We should move the indefinite wait up to where that 
613         check is done so that we properly detect the "no more blocks to copy, wait for more" condition.
614
615 2012-10-16  Csaba Osztrogon√°c  <ossy@webkit.org>
616
617         Unreviewed, rolling out r131516 and r131550.
618         http://trac.webkit.org/changeset/131516
619         http://trac.webkit.org/changeset/131550
620         https://bugs.webkit.org/show_bug.cgi?id=99349
621
622         It caused zillion different problem on different platforms
623
624         * GNUmakefile.list.am:
625         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
626         * JavaScriptCore.xcodeproj/project.pbxproj:
627         * bytecode/CodeBlock.cpp:
628         (JSC):
629         (JSC::isGlobalResolve):
630         (JSC::instructionOffsetForNth):
631         (JSC::printGlobalResolveInfo):
632         (JSC::CodeBlock::printStructures):
633         (JSC::CodeBlock::dump):
634         (JSC::CodeBlock::CodeBlock):
635         (JSC::CodeBlock::visitStructures):
636         (JSC::CodeBlock::finalizeUnconditionally):
637         (JSC::CodeBlock::hasGlobalResolveInfoAtBytecodeOffset):
638         (JSC::CodeBlock::globalResolveInfoForBytecodeOffset):
639         (JSC::CodeBlock::shrinkToFit):
640         * bytecode/CodeBlock.h:
641         (CodeBlock):
642         (JSC::CodeBlock::addGlobalResolveInstruction):
643         (JSC::CodeBlock::addGlobalResolveInfo):
644         (JSC::CodeBlock::globalResolveInfo):
645         (JSC::CodeBlock::numberOfGlobalResolveInfos):
646         (JSC::CodeBlock::globalResolveInfoCount):
647         * bytecode/GlobalResolveInfo.h: Copied from Source/JavaScriptCore/bytecode/ResolveGlobalStatus.cpp.
648         (JSC):
649         (JSC::GlobalResolveInfo::GlobalResolveInfo):
650         (GlobalResolveInfo):
651         (JSC::getGlobalResolveInfoBytecodeOffset):
652         * bytecode/Opcode.h:
653         (JSC):
654         (JSC::padOpcodeName):
655         * bytecode/ResolveGlobalStatus.cpp:
656         (JSC):
657         (JSC::computeForStructure):
658         (JSC::computeForLLInt):
659         (JSC::ResolveGlobalStatus::computeFor):
660         * bytecode/ResolveGlobalStatus.h:
661         (JSC):
662         (ResolveGlobalStatus):
663         * bytecode/ResolveOperation.h: Removed.
664         * bytecompiler/BytecodeGenerator.cpp:
665         (JSC::ResolveResult::checkValidity):
666         (JSC::ResolveResult::registerPointer):
667         (JSC):
668         (JSC::BytecodeGenerator::BytecodeGenerator):
669         (JSC::BytecodeGenerator::resolve):
670         (JSC::BytecodeGenerator::resolveConstDecl):
671         (JSC::BytecodeGenerator::shouldAvoidResolveGlobal):
672         (JSC::BytecodeGenerator::emitResolve):
673         (JSC::BytecodeGenerator::emitResolveBase):
674         (JSC::BytecodeGenerator::emitResolveBaseForPut):
675         (JSC::BytecodeGenerator::emitResolveWithBase):
676         (JSC::BytecodeGenerator::emitResolveWithThis):
677         (JSC::BytecodeGenerator::emitGetStaticVar):
678         (JSC::BytecodeGenerator::emitInitGlobalConst):
679         (JSC::BytecodeGenerator::emitPutStaticVar):
680         * bytecompiler/BytecodeGenerator.h:
681         (JSC::ResolveResult::registerResolve):
682         (JSC::ResolveResult::dynamicResolve):
683         (JSC::ResolveResult::lexicalResolve):
684         (JSC::ResolveResult::indexedGlobalResolve):
685         (JSC::ResolveResult::dynamicIndexedGlobalResolve):
686         (JSC::ResolveResult::globalResolve):
687         (JSC::ResolveResult::dynamicGlobalResolve):
688         (JSC::ResolveResult::type):
689         (JSC::ResolveResult::index):
690         (JSC::ResolveResult::depth):
691         (JSC::ResolveResult::globalObject):
692         (ResolveResult):
693         (JSC::ResolveResult::isStatic):
694         (JSC::ResolveResult::isIndexed):
695         (JSC::ResolveResult::isScoped):
696         (JSC::ResolveResult::isGlobal):
697         (JSC::ResolveResult::ResolveResult):
698         (BytecodeGenerator):
699         * bytecompiler/NodesCodegen.cpp:
700         (JSC::ResolveNode::isPure):
701         (JSC::FunctionCallResolveNode::emitBytecode):
702         (JSC::PostfixNode::emitResolve):
703         (JSC::PrefixNode::emitResolve):
704         (JSC::ReadModifyResolveNode::emitBytecode):
705         (JSC::AssignResolveNode::emitBytecode):
706         (JSC::ConstDeclNode::emitCodeSingle):
707         (JSC::ForInNode::emitBytecode):
708         * dfg/DFGAbstractState.cpp:
709         (JSC::DFG::AbstractState::execute):
710         * dfg/DFGByteCodeParser.cpp:
711         (ByteCodeParser):
712         (InlineStackEntry):
713         (JSC::DFG::ByteCodeParser::handleGetByOffset):
714         (JSC::DFG::ByteCodeParser::parseBlock):
715         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
716         * dfg/DFGCapabilities.h:
717         (JSC::DFG::canCompileOpcode):
718         (JSC::DFG::canInlineOpcode):
719         * dfg/DFGGraph.h:
720         (ResolveGlobalData):
721         (DFG):
722         (Graph):
723         * dfg/DFGNode.h:
724         (JSC::DFG::Node::hasIdentifier):
725         * dfg/DFGNodeType.h:
726         (DFG):
727         * dfg/DFGOSRExit.cpp:
728         (JSC::DFG::OSRExit::OSRExit):
729         * dfg/DFGOSRExit.h:
730         (OSRExit):
731         * dfg/DFGOSRExitCompiler.cpp:
732         * dfg/DFGOSRExitCompiler32_64.cpp:
733         (JSC::DFG::OSRExitCompiler::compileExit):
734         * dfg/DFGOSRExitCompiler64.cpp:
735         (JSC::DFG::OSRExitCompiler::compileExit):
736         * dfg/DFGOperations.cpp:
737         * dfg/DFGOperations.h:
738         (JSC):
739         * dfg/DFGPredictionPropagationPhase.cpp:
740         (JSC::DFG::PredictionPropagationPhase::propagate):
741         * dfg/DFGRepatch.cpp:
742         (JSC::DFG::tryCacheGetByID):
743         * dfg/DFGSpeculativeJIT.cpp:
744         (JSC::DFG::SpeculativeJIT::convertLastOSRExitToForward):
745         * dfg/DFGSpeculativeJIT.h:
746         (JSC::DFG::SpeculativeJIT::callOperation):
747         * dfg/DFGSpeculativeJIT32_64.cpp:
748         (JSC::DFG::SpeculativeJIT::compile):
749         * dfg/DFGSpeculativeJIT64.cpp:
750         (JSC::DFG::SpeculativeJIT::compile):
751         * dfg/DFGStructureCheckHoistingPhase.cpp:
752         (JSC::DFG::StructureCheckHoistingPhase::run):
753         * jit/JIT.cpp:
754         (JSC::JIT::privateCompileMainPass):
755         (JSC::JIT::privateCompileSlowCases):
756         * jit/JIT.h:
757         (JIT):
758         (JSC::JIT::emit_op_get_global_var_watchable):
759         * jit/JITOpcodes.cpp:
760         (JSC::JIT::emit_op_resolve):
761         (JSC):
762         (JSC::JIT::emit_op_resolve_base):
763         (JSC::JIT::emit_op_resolve_skip):
764         (JSC::JIT::emit_op_resolve_global):
765         (JSC::JIT::emitSlow_op_resolve_global):
766         (JSC::JIT::emit_op_resolve_with_base):
767         (JSC::JIT::emit_op_resolve_with_this):
768         (JSC::JIT::emit_op_resolve_global_dynamic):
769         (JSC::JIT::emitSlow_op_resolve_global_dynamic):
770         * jit/JITOpcodes32_64.cpp:
771         (JSC::JIT::emit_op_resolve):
772         (JSC):
773         (JSC::JIT::emit_op_resolve_base):
774         (JSC::JIT::emit_op_resolve_skip):
775         (JSC::JIT::emit_op_resolve_global):
776         (JSC::JIT::emitSlow_op_resolve_global):
777         (JSC::JIT::emit_op_resolve_with_base):
778         (JSC::JIT::emit_op_resolve_with_this):
779         * jit/JITPropertyAccess.cpp:
780         (JSC::JIT::emit_op_get_scoped_var):
781         (JSC):
782         (JSC::JIT::emit_op_put_scoped_var):
783         (JSC::JIT::emit_op_get_global_var):
784         (JSC::JIT::emit_op_put_global_var):
785         (JSC::JIT::emit_op_put_global_var_check):
786         (JSC::JIT::emitSlow_op_put_global_var_check):
787         * jit/JITPropertyAccess32_64.cpp:
788         (JSC::JIT::emit_op_get_scoped_var):
789         (JSC):
790         (JSC::JIT::emit_op_put_scoped_var):
791         (JSC::JIT::emit_op_get_global_var):
792         (JSC::JIT::emit_op_put_global_var):
793         (JSC::JIT::emit_op_put_global_var_check):
794         (JSC::JIT::emitSlow_op_put_global_var_check):
795         * jit/JITStubs.cpp:
796         (JSC::DEFINE_STUB_FUNCTION):
797         (JSC):
798         * jit/JITStubs.h:
799         * llint/LLIntSlowPaths.cpp:
800         (LLInt):
801         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
802         * llint/LLIntSlowPaths.h:
803         (LLInt):
804         * llint/LowLevelInterpreter.asm:
805         * llint/LowLevelInterpreter32_64.asm:
806         * llint/LowLevelInterpreter64.asm:
807         * runtime/JSScope.cpp:
808         (JSC::JSScope::resolve):
809         (JSC::JSScope::resolveSkip):
810         (JSC::JSScope::resolveGlobal):
811         (JSC::JSScope::resolveGlobalDynamic):
812         (JSC::JSScope::resolveBase):
813         (JSC::JSScope::resolveWithBase):
814         (JSC::JSScope::resolveWithThis):
815         * runtime/JSScope.h:
816         (JSScope):
817         * runtime/JSVariableObject.cpp:
818         * runtime/JSVariableObject.h:
819         * runtime/Structure.h:
820
821 2012-10-16  Dongwoo Joshua Im  <dw.im@samsung.com>
822
823         [GTK] Fix build break - ResolveOperations.h is not in WebKit.
824         https://bugs.webkit.org/show_bug.cgi?id=99538
825
826         Unreviewed build fix.
827
828         There are some files including ResolveOperations.h which is not exist at all.
829
830         * GNUmakefile.list.am: s/ResolveOperations.h/ResolveOperation.h/
831         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: s/ResolveOperations.h/ResolveOperation.h/
832
833 2012-10-16  Jian Li  <jianli@chromium.org>
834
835         Rename feature define ENABLE_WIDGET_REGION to ENABLE_DRAGGBALE_REGION
836         https://bugs.webkit.org/show_bug.cgi?id=98975
837
838         Reviewed by Adam Barth.
839
840         Renaming is needed to better match with the draggable region code. 
841
842         * Configurations/FeatureDefines.xcconfig:
843
844 2012-10-15  Oliver Hunt  <oliver@apple.com>
845
846         Bytecode should not have responsibility for determining how to perform non-local resolves
847         https://bugs.webkit.org/show_bug.cgi?id=99349
848
849         Reviewed by Gavin Barraclough.
850
851         This patch removes lexical analysis from the bytecode generation.  This allows
852         us to delay lookup of a non-local variables until the lookup is actually necessary,
853         and simplifies a lot of the resolve logic in BytecodeGenerator.
854
855         Once a lookup is performed we cache the lookup information in a set of out-of-line
856         buffers in CodeBlock.  This allows subsequent lookups to avoid unnecessary hashing,
857         etc, and allows the respective JITs to recreated optimal lookup code.
858
859         This is currently still a performance regression in LLInt, but most of the remaining
860         regression is caused by a lot of indirection that I'll remove in future work, as well
861         as some work necessary to allow LLInt to perform in line instruction repatching.
862         We will also want to improve the behaviour of the baseline JIT for some of the lookup
863         operations, however this patch was getting quite large already so I'm landing it now
864         that we've reached the bar of "performance-neutral".
865
866         * GNUmakefile.list.am:
867         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
868         * JavaScriptCore.xcodeproj/project.pbxproj:
869         * bytecode/CodeBlock.cpp:
870         (JSC::CodeBlock::printStructures):
871         (JSC::CodeBlock::dump):
872         (JSC::CodeBlock::CodeBlock):
873         (JSC::CodeBlock::visitStructures):
874         (JSC):
875         (JSC::CodeBlock::finalizeUnconditionally):
876         (JSC::CodeBlock::shrinkToFit):
877         * bytecode/CodeBlock.h:
878         (JSC::CodeBlock::addResolve):
879         (JSC::CodeBlock::addPutToBase):
880         (CodeBlock):
881         (JSC::CodeBlock::resolveOperations):
882         (JSC::CodeBlock::putToBaseOperation):
883         (JSC::CodeBlock::numberOfResolveOperations):
884         (JSC::CodeBlock::numberOfPutToBaseOperations):
885         (JSC::CodeBlock::addPropertyAccessInstruction):
886         (JSC::CodeBlock::globalObjectConstant):
887         (JSC::CodeBlock::setGlobalObjectConstant):
888         * bytecode/GlobalResolveInfo.h: Removed.
889         * bytecode/Opcode.h:
890         (JSC):
891         (JSC::padOpcodeName):
892         * bytecode/ResolveGlobalStatus.cpp:
893         (JSC::computeForStructure):
894         (JSC::ResolveGlobalStatus::computeFor):
895         * bytecode/ResolveGlobalStatus.h:
896         (JSC):
897         (ResolveGlobalStatus):
898         * bytecode/ResolveOperation.h: Added.
899           The new types and logic we use to perform the cached lookups.
900         (JSC):
901         (ResolveOperation):
902         (JSC::ResolveOperation::getAndReturnScopedVar):
903         (JSC::ResolveOperation::checkForDynamicEntriesBeforeGlobalScope):
904         (JSC::ResolveOperation::getAndReturnGlobalVar):
905         (JSC::ResolveOperation::getAndReturnGlobalProperty):
906         (JSC::ResolveOperation::resolveFail):
907         (JSC::ResolveOperation::skipTopScopeNode):
908         (JSC::ResolveOperation::skipScopes):
909         (JSC::ResolveOperation::returnGlobalObjectAsBase):
910         (JSC::ResolveOperation::setBaseToGlobal):
911         (JSC::ResolveOperation::setBaseToUndefined):
912         (JSC::ResolveOperation::setBaseToScope):
913         (JSC::ResolveOperation::returnScopeAsBase):
914         (JSC::PutToBaseOperation::PutToBaseOperation):
915         * bytecompiler/BytecodeGenerator.cpp:
916         (JSC::ResolveResult::checkValidity):
917         (JSC):
918         (JSC::BytecodeGenerator::BytecodeGenerator):
919         (JSC::BytecodeGenerator::resolve):
920         (JSC::BytecodeGenerator::resolveConstDecl):
921         (JSC::BytecodeGenerator::shouldAvoidResolveGlobal):
922         (JSC::BytecodeGenerator::emitResolve):
923         (JSC::BytecodeGenerator::emitResolveBase):
924         (JSC::BytecodeGenerator::emitResolveBaseForPut):
925         (JSC::BytecodeGenerator::emitResolveWithBaseForPut):
926         (JSC::BytecodeGenerator::emitResolveWithThis):
927         (JSC::BytecodeGenerator::emitGetLocalVar):
928         (JSC::BytecodeGenerator::emitInitGlobalConst):
929         (JSC::BytecodeGenerator::emitPutToBase):
930         * bytecompiler/BytecodeGenerator.h:
931         (JSC::ResolveResult::registerResolve):
932         (JSC::ResolveResult::dynamicResolve):
933         (ResolveResult):
934         (JSC::ResolveResult::ResolveResult):
935         (JSC):
936         (NonlocalResolveInfo):
937         (JSC::NonlocalResolveInfo::NonlocalResolveInfo):
938         (JSC::NonlocalResolveInfo::~NonlocalResolveInfo):
939         (JSC::NonlocalResolveInfo::resolved):
940         (JSC::NonlocalResolveInfo::put):
941         (BytecodeGenerator):
942         (JSC::BytecodeGenerator::getResolveOperations):
943         (JSC::BytecodeGenerator::getResolveWithThisOperations):
944         (JSC::BytecodeGenerator::getResolveBaseOperations):
945         (JSC::BytecodeGenerator::getResolveBaseForPutOperations):
946         (JSC::BytecodeGenerator::getResolveWithBaseForPutOperations):
947         (JSC::BytecodeGenerator::getPutToBaseOperation):
948         * bytecompiler/NodesCodegen.cpp:
949         (JSC::ResolveNode::isPure):
950         (JSC::FunctionCallResolveNode::emitBytecode):
951         (JSC::PostfixNode::emitResolve):
952         (JSC::PrefixNode::emitResolve):
953         (JSC::ReadModifyResolveNode::emitBytecode):
954         (JSC::AssignResolveNode::emitBytecode):
955         (JSC::ConstDeclNode::emitCodeSingle):
956         (JSC::ForInNode::emitBytecode):
957         * dfg/DFGAbstractState.cpp:
958         (JSC::DFG::AbstractState::execute):
959         * dfg/DFGByteCodeParser.cpp:
960         (ByteCodeParser):
961         (InlineStackEntry):
962         (JSC::DFG::ByteCodeParser::handleGetByOffset):
963         (DFG):
964         (JSC::DFG::ByteCodeParser::parseResolveOperations):
965         (JSC::DFG::ByteCodeParser::parseBlock):
966         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
967         * dfg/DFGCapabilities.h:
968         (JSC::DFG::canCompileResolveOperations):
969         (DFG):
970         (JSC::DFG::canCompilePutToBaseOperation):
971         (JSC::DFG::canCompileOpcode):
972         (JSC::DFG::canInlineOpcode):
973         * dfg/DFGGraph.h:
974         (ResolveGlobalData):
975         (ResolveOperationData):
976         (DFG):
977         (PutToBaseOperationData):
978         (Graph):
979         * dfg/DFGNode.h:
980         (JSC::DFG::Node::hasIdentifier):
981         (JSC::DFG::Node::resolveOperationsDataIndex):
982         (Node):
983         * dfg/DFGNodeType.h:
984         (DFG):
985         * dfg/DFGOSRExit.cpp:
986         (JSC::DFG::OSRExit::OSRExit):
987         * dfg/DFGOSRExit.h:
988         (OSRExit):
989         * dfg/DFGOSRExitCompiler.cpp:
990         * dfg/DFGOSRExitCompiler32_64.cpp:
991         (JSC::DFG::OSRExitCompiler::compileExit):
992         * dfg/DFGOSRExitCompiler64.cpp:
993         (JSC::DFG::OSRExitCompiler::compileExit):
994         * dfg/DFGOperations.cpp:
995         * dfg/DFGOperations.h:
996         * dfg/DFGPredictionPropagationPhase.cpp:
997         (JSC::DFG::PredictionPropagationPhase::propagate):
998         * dfg/DFGRepatch.cpp:
999         (JSC::DFG::tryCacheGetByID):
1000         * dfg/DFGSpeculativeJIT.cpp:
1001         (JSC::DFG::SpeculativeJIT::convertLastOSRExitToForward):
1002         * dfg/DFGSpeculativeJIT.h:
1003         (JSC::DFG::SpeculativeJIT::resolveOperations):
1004         (SpeculativeJIT):
1005         (JSC::DFG::SpeculativeJIT::putToBaseOperation):
1006         (JSC::DFG::SpeculativeJIT::callOperation):
1007         * dfg/DFGSpeculativeJIT32_64.cpp:
1008         (JSC::DFG::SpeculativeJIT::compile):
1009         * dfg/DFGSpeculativeJIT64.cpp:
1010         (JSC::DFG::SpeculativeJIT::compile):
1011         * dfg/DFGStructureCheckHoistingPhase.cpp:
1012         (JSC::DFG::StructureCheckHoistingPhase::run):
1013         * jit/JIT.cpp:
1014         (JSC::JIT::privateCompileMainPass):
1015         (JSC::JIT::privateCompileSlowCases):
1016         * jit/JIT.h:
1017         (JIT):
1018         * jit/JITOpcodes.cpp:
1019         (JSC::JIT::emit_op_put_to_base):
1020         (JSC):
1021         (JSC::JIT::emit_resolve_operations):
1022         (JSC::JIT::emitSlow_link_resolve_operations):
1023         (JSC::JIT::emit_op_resolve):
1024         (JSC::JIT::emitSlow_op_resolve):
1025         (JSC::JIT::emit_op_resolve_base):
1026         (JSC::JIT::emitSlow_op_resolve_base):
1027         (JSC::JIT::emit_op_resolve_with_base):
1028         (JSC::JIT::emitSlow_op_resolve_with_base):
1029         (JSC::JIT::emit_op_resolve_with_this):
1030         (JSC::JIT::emitSlow_op_resolve_with_this):
1031         (JSC::JIT::emitSlow_op_put_to_base):
1032         * jit/JITOpcodes32_64.cpp:
1033         (JSC::JIT::emit_op_put_to_base):
1034         (JSC):
1035         * jit/JITPropertyAccess.cpp:
1036         (JSC::JIT::emit_op_init_global_const):
1037         (JSC::JIT::emit_op_init_global_const_check):
1038         (JSC::JIT::emitSlow_op_init_global_const_check):
1039         * jit/JITPropertyAccess32_64.cpp:
1040         (JSC::JIT::emit_op_init_global_const):
1041         (JSC::JIT::emit_op_init_global_const_check):
1042         (JSC::JIT::emitSlow_op_init_global_const_check):
1043         * jit/JITStubs.cpp:
1044         (JSC::DEFINE_STUB_FUNCTION):
1045         (JSC):
1046         * jit/JITStubs.h:
1047         * llint/LLIntSlowPaths.cpp:
1048         (LLInt):
1049         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
1050         * llint/LLIntSlowPaths.h:
1051         (LLInt):
1052         * llint/LowLevelInterpreter.asm:
1053         * llint/LowLevelInterpreter32_64.asm:
1054         * llint/LowLevelInterpreter64.asm:
1055         * runtime/JSScope.cpp:
1056         (JSC::LookupResult::base):
1057         (JSC::LookupResult::value):
1058         (JSC::LookupResult::setBase):
1059         (JSC::LookupResult::setValue):
1060         (LookupResult):
1061         (JSC):
1062         (JSC::setPutPropertyAccessOffset):
1063         (JSC::executeResolveOperations):
1064         (JSC::JSScope::resolveContainingScopeInternal):
1065         (JSC::JSScope::resolveContainingScope):
1066         (JSC::JSScope::resolve):
1067         (JSC::JSScope::resolveBase):
1068         (JSC::JSScope::resolveWithBase):
1069         (JSC::JSScope::resolveWithThis):
1070         (JSC::JSScope::resolvePut):
1071         (JSC::JSScope::resolveGlobal):
1072         * runtime/JSScope.h:
1073         (JSScope):
1074         * runtime/JSVariableObject.cpp:
1075         (JSC):
1076         * runtime/JSVariableObject.h:
1077         (JSVariableObject):
1078         * runtime/Structure.h:
1079         (JSC::Structure::propertyAccessesAreCacheable):
1080         (Structure):
1081
1082 2012-10-16  Filip Pizlo  <fpizlo@apple.com>
1083
1084         Accidental switch fall-through in DFG::FixupPhase
1085         https://bugs.webkit.org/show_bug.cgi?id=96956
1086         <rdar://problem/12313242>
1087
1088         Reviewed by Mark Hahnenberg.
1089
1090         * dfg/DFGFixupPhase.cpp:
1091         (JSC::DFG::FixupPhase::fixupNode):
1092
1093 2012-10-16  Filip Pizlo  <fpizlo@apple.com>
1094
1095         GetScopedVar CSE matches dead GetScopedVar's leading to IR corruption
1096         https://bugs.webkit.org/show_bug.cgi?id=99470
1097         <rdar://problem/12363698>
1098
1099         Reviewed by Mark Hahnenberg.
1100
1101         All it takes is to follow the "if (!shouldGenerate) continue" idiom and everything will be OK.
1102
1103         * dfg/DFGCSEPhase.cpp:
1104         (JSC::DFG::CSEPhase::globalVarLoadElimination):
1105         (JSC::DFG::CSEPhase::scopedVarLoadElimination):
1106         (JSC::DFG::CSEPhase::globalVarWatchpointElimination):
1107         (JSC::DFG::CSEPhase::getByValLoadElimination):
1108         (JSC::DFG::CSEPhase::checkStructureElimination):
1109         (JSC::DFG::CSEPhase::structureTransitionWatchpointElimination):
1110         (JSC::DFG::CSEPhase::getByOffsetLoadElimination):
1111
1112 2012-10-16  Dima Gorbik  <dgorbik@apple.com>
1113
1114         Remove Platform.h include from the header files.
1115         https://bugs.webkit.org/show_bug.cgi?id=98665
1116
1117         Reviewed by Eric Seidel.
1118
1119         We don't want other clients that include WebKit headers to know about Platform.h.
1120
1121         * API/tests/minidom.c:
1122         * API/tests/testapi.c:
1123
1124 2012-10-16  Balazs Kilvady  <kilvadyb@homejinni.com>
1125
1126         Add missing MIPS functions to assembler.
1127         https://bugs.webkit.org/show_bug.cgi?id=98856
1128
1129         Reviewed by Oliver Hunt.
1130
1131         Implement missing functions in MacroAssemblerMIPS and MIPSAssembler.
1132
1133         * assembler/MIPSAssembler.h:
1134         (JSC::MIPSAssembler::lb):
1135         (MIPSAssembler):
1136         (JSC::MIPSAssembler::lh):
1137         (JSC::MIPSAssembler::cvtds):
1138         (JSC::MIPSAssembler::cvtsd):
1139         (JSC::MIPSAssembler::vmov):
1140         * assembler/MacroAssemblerMIPS.h:
1141         (MacroAssemblerMIPS):
1142         (JSC::MacroAssemblerMIPS::load8Signed):
1143         (JSC::MacroAssemblerMIPS::load16Signed):
1144         (JSC::MacroAssemblerMIPS::moveDoubleToInts):
1145         (JSC::MacroAssemblerMIPS::moveIntsToDouble):
1146         (JSC::MacroAssemblerMIPS::loadFloat):
1147         (JSC::MacroAssemblerMIPS::loadDouble):
1148         (JSC::MacroAssemblerMIPS::storeFloat):
1149         (JSC::MacroAssemblerMIPS::storeDouble):
1150         (JSC::MacroAssemblerMIPS::addDouble):
1151         (JSC::MacroAssemblerMIPS::convertFloatToDouble):
1152         (JSC::MacroAssemblerMIPS::convertDoubleToFloat):
1153
1154 2012-10-16  Balazs Kilvady  <kilvadyb@homejinni.com>
1155
1156         MIPS assembler coding-style fix.
1157         https://bugs.webkit.org/show_bug.cgi?id=99359
1158
1159         Reviewed by Oliver Hunt.
1160
1161         Coding style fix of existing MIPS assembler header files.
1162
1163         * assembler/MIPSAssembler.h:
1164         (JSC::MIPSAssembler::addiu):
1165         (JSC::MIPSAssembler::addu):
1166         (JSC::MIPSAssembler::subu):
1167         (JSC::MIPSAssembler::mul):
1168         (JSC::MIPSAssembler::andInsn):
1169         (JSC::MIPSAssembler::andi):
1170         (JSC::MIPSAssembler::nor):
1171         (JSC::MIPSAssembler::orInsn):
1172         (JSC::MIPSAssembler::ori):
1173         (JSC::MIPSAssembler::xorInsn):
1174         (JSC::MIPSAssembler::xori):
1175         (JSC::MIPSAssembler::slt):
1176         (JSC::MIPSAssembler::sltu):
1177         (JSC::MIPSAssembler::sltiu):
1178         (JSC::MIPSAssembler::sll):
1179         (JSC::MIPSAssembler::sllv):
1180         (JSC::MIPSAssembler::sra):
1181         (JSC::MIPSAssembler::srav):
1182         (JSC::MIPSAssembler::srl):
1183         (JSC::MIPSAssembler::srlv):
1184         (JSC::MIPSAssembler::lbu):
1185         (JSC::MIPSAssembler::lw):
1186         (JSC::MIPSAssembler::lwl):
1187         (JSC::MIPSAssembler::lwr):
1188         (JSC::MIPSAssembler::lhu):
1189         (JSC::MIPSAssembler::sb):
1190         (JSC::MIPSAssembler::sh):
1191         (JSC::MIPSAssembler::sw):
1192         (JSC::MIPSAssembler::addd):
1193         (JSC::MIPSAssembler::subd):
1194         (JSC::MIPSAssembler::muld):
1195         (JSC::MIPSAssembler::divd):
1196         (JSC::MIPSAssembler::lwc1):
1197         (JSC::MIPSAssembler::ldc1):
1198         (JSC::MIPSAssembler::swc1):
1199         (JSC::MIPSAssembler::sdc1):
1200         (MIPSAssembler):
1201         (JSC::MIPSAssembler::relocateJumps):
1202         (JSC::MIPSAssembler::linkWithOffset):
1203         * assembler/MacroAssemblerMIPS.h:
1204         (JSC::MacroAssemblerMIPS::add32):
1205         (JSC::MacroAssemblerMIPS::and32):
1206         (JSC::MacroAssemblerMIPS::sub32):
1207         (MacroAssemblerMIPS):
1208         (JSC::MacroAssemblerMIPS::load8):
1209         (JSC::MacroAssemblerMIPS::load32):
1210         (JSC::MacroAssemblerMIPS::load32WithUnalignedHalfWords):
1211         (JSC::MacroAssemblerMIPS::load16):
1212         (JSC::MacroAssemblerMIPS::store8):
1213         (JSC::MacroAssemblerMIPS::store16):
1214         (JSC::MacroAssemblerMIPS::store32):
1215         (JSC::MacroAssemblerMIPS::nearCall):
1216         (JSC::MacroAssemblerMIPS::test8):
1217         (JSC::MacroAssemblerMIPS::test32):
1218
1219 2012-10-16  Yuqiang Xian  <yuqiang.xian@intel.com>
1220
1221         Refactor MacroAssembler interfaces to differentiate the pointer operands from the 64-bit integer operands
1222         https://bugs.webkit.org/show_bug.cgi?id=99154
1223
1224         Reviewed by Gavin Barraclough.
1225
1226         In current JavaScriptCore implementation for JSVALUE64 platform (i.e.,
1227         the X64 platform), we assume that the JSValue size is same to the
1228         pointer size, and thus EncodedJSValue is simply type defined as a
1229         "void*". In the JIT compiler, we also take this assumption and invoke
1230         the same macro assembler interfaces for both JSValue and pointer
1231         operands. We need to differentiate the operations on pointers from the
1232         operations on JSValues, and let them invoking different macro
1233         assembler interfaces. For example, we now use the interface of
1234         "loadPtr" to load either a pointer or a JSValue, and we need to switch
1235         to using "loadPtr" to load a pointer and some new "load64" interface
1236         to load a JSValue. This would help us supporting other JSVALUE64
1237         platforms where pointer size is not necessarily 64-bits, for example
1238         x32 (bug #99153).
1239
1240         The major modification I made is to introduce the "*64" interfaces in
1241         the MacroAssembler for those operations on JSValues, keep the "*Ptr"
1242         interfaces for those operations on real pointers, and go through all
1243         the JIT compiler code to correct the usage.
1244
1245         This is the first part of the work, i.e, to add the *64 interfaces to
1246         the MacroAssembler.
1247
1248         * assembler/AbstractMacroAssembler.h: Add the Imm64 interfaces.
1249         (AbstractMacroAssembler):
1250         (JSC::AbstractMacroAssembler::TrustedImm64::TrustedImm64):
1251         (TrustedImm64):
1252         (JSC::AbstractMacroAssembler::Imm64::Imm64):
1253         (Imm64):
1254         (JSC::AbstractMacroAssembler::Imm64::asTrustedImm64):
1255         * assembler/MacroAssembler.h: map <foo>Ptr methods to <foo>64 for X86_64.
1256         (MacroAssembler):
1257         (JSC::MacroAssembler::peek64):
1258         (JSC::MacroAssembler::poke):
1259         (JSC::MacroAssembler::poke64):
1260         (JSC::MacroAssembler::addPtr):
1261         (JSC::MacroAssembler::andPtr):
1262         (JSC::MacroAssembler::negPtr):
1263         (JSC::MacroAssembler::orPtr):
1264         (JSC::MacroAssembler::rotateRightPtr):
1265         (JSC::MacroAssembler::subPtr):
1266         (JSC::MacroAssembler::xorPtr):
1267         (JSC::MacroAssembler::loadPtr):
1268         (JSC::MacroAssembler::loadPtrWithAddressOffsetPatch):
1269         (JSC::MacroAssembler::loadPtrWithCompactAddressOffsetPatch):
1270         (JSC::MacroAssembler::storePtr):
1271         (JSC::MacroAssembler::storePtrWithAddressOffsetPatch):
1272         (JSC::MacroAssembler::movePtrToDouble):
1273         (JSC::MacroAssembler::moveDoubleToPtr):
1274         (JSC::MacroAssembler::comparePtr):
1275         (JSC::MacroAssembler::testPtr):
1276         (JSC::MacroAssembler::branchPtr):
1277         (JSC::MacroAssembler::branchTestPtr):
1278         (JSC::MacroAssembler::branchAddPtr):
1279         (JSC::MacroAssembler::branchSubPtr):
1280         (JSC::MacroAssembler::shouldBlindDouble):
1281         (JSC::MacroAssembler::shouldBlind):
1282         (JSC::MacroAssembler::RotatedImm64::RotatedImm64):
1283         (RotatedImm64):
1284         (JSC::MacroAssembler::rotationBlindConstant):
1285         (JSC::MacroAssembler::loadRotationBlindedConstant):
1286         (JSC::MacroAssembler::move):
1287         (JSC::MacroAssembler::and64):
1288         (JSC::MacroAssembler::store64):
1289         * assembler/MacroAssemblerX86Common.h:
1290         (JSC::MacroAssemblerX86Common::shouldBlindForSpecificArch):
1291         (MacroAssemblerX86Common):
1292         (JSC::MacroAssemblerX86Common::move):
1293         * assembler/MacroAssemblerX86_64.h: Add the <foo>64 methods for X86_64.
1294         (JSC::MacroAssemblerX86_64::branchAdd32):
1295         (JSC::MacroAssemblerX86_64::add64):
1296         (MacroAssemblerX86_64):
1297         (JSC::MacroAssemblerX86_64::and64):
1298         (JSC::MacroAssemblerX86_64::neg64):
1299         (JSC::MacroAssemblerX86_64::or64):
1300         (JSC::MacroAssemblerX86_64::rotateRight64):
1301         (JSC::MacroAssemblerX86_64::sub64):
1302         (JSC::MacroAssemblerX86_64::xor64):
1303         (JSC::MacroAssemblerX86_64::load64):
1304         (JSC::MacroAssemblerX86_64::load64WithAddressOffsetPatch):
1305         (JSC::MacroAssemblerX86_64::load64WithCompactAddressOffsetPatch):
1306         (JSC::MacroAssemblerX86_64::store64):
1307         (JSC::MacroAssemblerX86_64::store64WithAddressOffsetPatch):
1308         (JSC::MacroAssemblerX86_64::move64ToDouble):
1309         (JSC::MacroAssemblerX86_64::moveDoubleTo64):
1310         (JSC::MacroAssemblerX86_64::compare64):
1311         (JSC::MacroAssemblerX86_64::branch64):
1312         (JSC::MacroAssemblerX86_64::branchTest64):
1313         (JSC::MacroAssemblerX86_64::test64):
1314         (JSC::MacroAssemblerX86_64::branchAdd64):
1315         (JSC::MacroAssemblerX86_64::branchSub64):
1316         (JSC::MacroAssemblerX86_64::branchPtrWithPatch):
1317         (JSC::MacroAssemblerX86_64::storePtrWithPatch):
1318
1319 2012-10-15  Mark Hahnenberg  <mhahnenberg@apple.com>
1320
1321         Make CopiedSpace and MarkedSpace regions independent
1322         https://bugs.webkit.org/show_bug.cgi?id=99222
1323
1324         Reviewed by Filip Pizlo.
1325
1326         Right now CopiedSpace and MarkedSpace have the same block size and share the same regions, 
1327         but there's no reason that they can't have different block sizes while still sharing the 
1328         same underlying regions. We should factor the two "used" lists of regions apart so that 
1329         MarkedBlocks and CopiedBlocks can be different sizes. Regions will still be a uniform size 
1330         so that when they become empty they may be shared between the CopiedSpace and the MarkedSpace, 
1331         since benchmarks indicate that sharing is a boon for performance.
1332
1333         * heap/BlockAllocator.cpp:
1334         (JSC::BlockAllocator::BlockAllocator):
1335         * heap/BlockAllocator.h:
1336         (JSC):
1337         (Region):
1338         (JSC::Region::create): We now have a fixed size for Regions so that empty regions can continue to 
1339         be shared between the MarkedSpace and CopiedSpace. Once they are used for a specific type of block,
1340         however, they can only be used for that type of block until they become empty again.
1341         (JSC::Region::createCustomSize):
1342         (JSC::Region::Region):
1343         (JSC::Region::~Region):
1344         (JSC::Region::reset):
1345         (BlockAllocator):
1346         (JSC::BlockAllocator::RegionSet::RegionSet):
1347         (RegionSet):
1348         (JSC::BlockAllocator::tryAllocateFromRegion): We change this function so that it correctly 
1349         moves blocks between empty, partial, and full lists.
1350         (JSC::BlockAllocator::allocate):
1351         (JSC::BlockAllocator::allocateCustomSize):
1352         (JSC::BlockAllocator::deallocate): Ditto.
1353         (JSC::CopiedBlock):
1354         (JSC::MarkedBlock):
1355         (JSC::BlockAllocator::regionSetFor): We use this so that we can use the same allocate/deallocate
1356         functions with different RegionSets. We specialize the function for each type of block that we 
1357         want to allocate.
1358         * heap/CopiedBlock.h:
1359         (CopiedBlock):
1360         * heap/CopiedSpace.h:
1361         (CopiedSpace):
1362         * heap/HeapBlock.h:
1363         (HeapBlock):
1364         * heap/MarkedBlock.cpp:
1365         (JSC::MarkedBlock::MarkedBlock): For oversize MarkedBlocks, if the block size gets too big we can 
1366         underflow the endAtom, which will cause us to segfault when we try to sweep a block. If we're a 
1367         custom size MarkedBlock we need to calculate endAtom so it doesn't underflow.
1368
1369 2012-10-14  Filip Pizlo  <fpizlo@apple.com>
1370
1371         JIT::JIT fails to initialize all of its fields
1372         https://bugs.webkit.org/show_bug.cgi?id=99283
1373
1374         Reviewed by Andreas Kling.
1375
1376         There were two groups of such fields, all of which are eventually initialized
1377         prior to use inside of privateCompile(). But it's safer to make sure that they
1378         are initialized in the constructor as well, since we may use the JIT to do a
1379         stub compile without calling into privateCompile().
1380         
1381         Unsigned index fields for dynamic repatching meta-data: this change
1382         initializes them to UINT_MAX, so we should crash if we try to use those
1383         indices without initializing them.
1384         
1385         Boolean flags for value profiling: this change initializes them to false, so
1386         we at worst turn off value profiling.
1387
1388         * jit/JIT.cpp:
1389         (JSC::JIT::JIT):
1390
1391 2012-10-15  Mark Hahnenberg  <mhahnenberg@apple.com>
1392
1393         We should avoid weakCompareAndSwap when parallel GC is disabled
1394         https://bugs.webkit.org/show_bug.cgi?id=99331
1395
1396         Reviewed by Filip Pizlo.
1397
1398         CopiedBlock::reportLiveBytes and didEvacuateBytes uses weakCompareAndSwap, which some platforms 
1399         don't support. For platforms that don't have parallel GC enabled, we should just use a normal store.
1400
1401         * heap/CopiedBlock.h:
1402         (JSC::CopiedBlock::reportLiveBytes):
1403         (JSC::CopiedBlock::didEvacuateBytes):
1404
1405 2012-10-15  Carlos Garcia Campos  <cgarcia@igalia.com>
1406
1407         Unreviewed. Fix make distcheck.
1408
1409         * GNUmakefile.list.am: Add missing header file.
1410
1411 2012-10-14  Filip Pizlo  <fpizlo@apple.com>
1412
1413         DFG should handle polymorphic array modes by eagerly transforming arrays into the most general applicable form
1414         https://bugs.webkit.org/show_bug.cgi?id=99269
1415
1416         Reviewed by Geoffrey Garen.
1417
1418         This kills off a bunch of code for "polymorphic" array modes in the DFG. It should
1419         also be a performance win for code that uses a lot of array storage arrays.
1420
1421         * dfg/DFGAbstractState.cpp:
1422         (JSC::DFG::AbstractState::execute):
1423         * dfg/DFGArrayMode.cpp:
1424         (JSC::DFG::fromObserved):
1425         (JSC::DFG::modeAlreadyChecked):
1426         (JSC::DFG::modeToString):
1427         * dfg/DFGArrayMode.h:
1428         (DFG):
1429         (JSC::DFG::modeUsesButterfly):
1430         (JSC::DFG::modeIsJSArray):
1431         (JSC::DFG::mayStoreToTail):
1432         (JSC::DFG::mayStoreToHole):
1433         (JSC::DFG::canCSEStorage):
1434         (JSC::DFG::modeSupportsLength):
1435         (JSC::DFG::benefitsFromStructureCheck):
1436         * dfg/DFGFixupPhase.cpp:
1437         (JSC::DFG::FixupPhase::checkArray):
1438         (JSC::DFG::FixupPhase::blessArrayOperation):
1439         * dfg/DFGGraph.h:
1440         (JSC::DFG::Graph::byValIsPure):
1441         * dfg/DFGSpeculativeJIT.cpp:
1442         (JSC::DFG::SpeculativeJIT::jumpSlowForUnwantedArrayMode):
1443         (JSC::DFG::SpeculativeJIT::checkArray):
1444         (JSC::DFG::SpeculativeJIT::arrayify):
1445         (DFG):
1446         (JSC::DFG::SpeculativeJIT::compileGetArrayLength):
1447         * dfg/DFGSpeculativeJIT.h:
1448         (JSC::DFG::SpeculativeJIT::putByValWillNeedExtraRegister):
1449         (SpeculativeJIT):
1450         * dfg/DFGSpeculativeJIT32_64.cpp:
1451         (JSC::DFG::SpeculativeJIT::compile):
1452         * dfg/DFGSpeculativeJIT64.cpp:
1453         (JSC::DFG::SpeculativeJIT::compile):
1454
1455 2012-10-14  Filip Pizlo  <fpizlo@apple.com>
1456
1457         REGRESSION(126886): Fat binary builds don't know how to handle architecture variants to which the LLInt is agnostic
1458         https://bugs.webkit.org/show_bug.cgi?id=99270
1459
1460         Reviewed by Geoffrey Garen.
1461
1462         The fix is to hash cons the offsets based on configuration index, not the offsets
1463         themselves.
1464
1465         * offlineasm/offsets.rb:
1466
1467 2012-10-13  Filip Pizlo  <fpizlo@apple.com>
1468
1469         IndexingType should not have a bit for each type
1470         https://bugs.webkit.org/show_bug.cgi?id=98997
1471
1472         Reviewed by Oliver Hunt.
1473
1474         Somewhat incidentally, the introduction of butterflies led to each indexing
1475         type being represented by a unique bit. This is superficially nice since it
1476         allows you to test if a structure corresponds to a particular indexing type
1477         by saying !!(structure->indexingType() & TheType). But the downside is that
1478         given the 8 bits we have for the m_indexingType field, that leaves only a
1479         small number of possible indexing types if we have one per bit.
1480         
1481         This changeset changes the indexing type to be:
1482         
1483         Bit #1: Tells you if you're an array.
1484         
1485         Bits #2 - #5: 16 possible indexing types, including the blank type for
1486             objects that don't have indexed properties.
1487         
1488         Bits #6-8: Auxiliary bits that we could use for other things. Currently we
1489             just use one of those bits, for MayHaveIndexedAccessors.
1490         
1491         This is performance-neutral, and is primarily intended to give us more
1492         breathing room for introducing new inferred array modes.
1493
1494         * assembler/AbstractMacroAssembler.h:
1495         (JSC::AbstractMacroAssembler::JumpList::jumps):
1496         * assembler/MacroAssembler.h:
1497         (MacroAssembler):
1498         (JSC::MacroAssembler::patchableBranch32):
1499         * assembler/MacroAssemblerARMv7.h:
1500         (JSC::MacroAssemblerARMv7::patchableBranch32):
1501         (MacroAssemblerARMv7):
1502         * dfg/DFGArrayMode.cpp:
1503         (JSC::DFG::modeAlreadyChecked):
1504         * dfg/DFGRepatch.cpp:
1505         (JSC::DFG::tryCacheGetByID):
1506         * dfg/DFGSpeculativeJIT.cpp:
1507         (JSC::DFG::SpeculativeJIT::speculationCheck):
1508         (JSC::DFG::SpeculativeJIT::forwardSpeculationCheck):
1509         (JSC::DFG::SpeculativeJIT::jumpSlowForUnwantedArrayMode):
1510         (DFG):
1511         (JSC::DFG::SpeculativeJIT::checkArray):
1512         (JSC::DFG::SpeculativeJIT::arrayify):
1513         * dfg/DFGSpeculativeJIT.h:
1514         (SpeculativeJIT):
1515         * dfg/DFGSpeculativeJIT32_64.cpp:
1516         (JSC::DFG::SpeculativeJIT::compile):
1517         * dfg/DFGSpeculativeJIT64.cpp:
1518         (JSC::DFG::SpeculativeJIT::compile):
1519         * jit/JITInlineMethods.h:
1520         (JSC::JIT::emitAllocateJSArray):
1521         (JSC::JIT::chooseArrayMode):
1522         * jit/JITPropertyAccess.cpp:
1523         (JSC::JIT::emit_op_get_by_val):
1524         (JSC::JIT::emitContiguousGetByVal):
1525         (JSC::JIT::emitArrayStorageGetByVal):
1526         (JSC::JIT::emit_op_put_by_val):
1527         (JSC::JIT::emitContiguousPutByVal):
1528         (JSC::JIT::emitArrayStoragePutByVal):
1529         (JSC::JIT::privateCompilePatchGetArrayLength):
1530         * jit/JITPropertyAccess32_64.cpp:
1531         (JSC::JIT::emit_op_get_by_val):
1532         (JSC::JIT::emitContiguousGetByVal):
1533         (JSC::JIT::emitArrayStorageGetByVal):
1534         (JSC::JIT::emit_op_put_by_val):
1535         (JSC::JIT::emitContiguousPutByVal):
1536         (JSC::JIT::emitArrayStoragePutByVal):
1537         (JSC::JIT::privateCompilePatchGetArrayLength):
1538         * llint/LowLevelInterpreter.asm:
1539         * llint/LowLevelInterpreter32_64.asm:
1540         * llint/LowLevelInterpreter64.asm:
1541         * runtime/IndexingType.h:
1542         (JSC):
1543         (JSC::hasIndexedProperties):
1544         (JSC::hasContiguous):
1545         (JSC::hasFastArrayStorage):
1546         (JSC::hasArrayStorage):
1547         (JSC::shouldUseSlowPut):
1548         * runtime/JSGlobalObject.cpp:
1549         (JSC):
1550         * runtime/StructureTransitionTable.h:
1551         (JSC::newIndexingType):
1552
1553 2012-10-14  Filip Pizlo  <fpizlo@apple.com>
1554
1555         DFG structure check hoisting should attempt to ignore side effects and make transformations that are sound even in their presence
1556         https://bugs.webkit.org/show_bug.cgi?id=99262
1557
1558         Reviewed by Oliver Hunt.
1559
1560         This hugely simplifies the structure check hoisting phase. It will no longer be necessary
1561         to modify it when the effectfulness of operations changes. This also enables the hoister
1562         to hoist effectful things in the future.
1563         
1564         The downside is that the hoister may end up adding strictly more checks than were present
1565         in the original code, if the code truly has a lot of side-effects. I don't see evidence
1566         of this happening. This patch does have some speed-ups and some slow-downs, but is
1567         neutral in the average, and the slow-downs do not appear to have more structure checks
1568         than ToT.
1569
1570         * dfg/DFGStructureCheckHoistingPhase.cpp:
1571         (JSC::DFG::StructureCheckHoistingPhase::run):
1572         (JSC::DFG::StructureCheckHoistingPhase::noticeStructureCheck):
1573         (StructureCheckHoistingPhase):
1574         (CheckData):
1575         (JSC::DFG::StructureCheckHoistingPhase::CheckData::CheckData):
1576
1577 2012-10-14  Filip Pizlo  <fpizlo@apple.com>
1578
1579         Fix the build of universal binary with ARMv7s of JavaScriptCore
1580
1581         * llint/LLIntOfflineAsmConfig.h:
1582         * llint/LowLevelInterpreter.asm:
1583
1584 2012-10-13  Filip Pizlo  <fpizlo@apple.com>
1585
1586         Array length array profiling is broken in the baseline JIT
1587         https://bugs.webkit.org/show_bug.cgi?id=99258
1588
1589         Reviewed by Oliver Hunt.
1590
1591         The code generator for array length stubs calls into
1592         emitArrayProfilingSiteForBytecodeIndex(), which emits profiling only if
1593         canBeOptimized() returns true. But m_canBeOptimized is only initialized during
1594         full method compiles, so in a stub compile it may (or may not) be false, meaning
1595         that we may, or may not, get meaningful profiling info.
1596         
1597         This appeared to not affect too many programs since the LLInt has good array
1598         length array profiling.
1599
1600         * jit/JIT.h:
1601         (JSC::JIT::compilePatchGetArrayLength):
1602
1603 2012-10-14  Patrick Gansterer  <paroga@webkit.org>
1604
1605         Build fix for WinCE after r131089.
1606
1607         WinCE does not support getenv().
1608
1609         * runtime/Options.cpp:
1610         (JSC::overrideOptionWithHeuristic):
1611
1612 2012-10-12  Kangil Han  <kangil.han@samsung.com>
1613
1614         Fix build error on DFGSpeculativeJIT32_64.cpp
1615         https://bugs.webkit.org/show_bug.cgi?id=99234
1616
1617         Reviewed by Anders Carlsson.
1618
1619         Seems BUG 98608 causes build error on 32bit machine so fix it.
1620
1621         * dfg/DFGSpeculativeJIT32_64.cpp:
1622         (JSC::DFG::SpeculativeJIT::compile):
1623
1624 2012-10-12  Filip Pizlo  <fpizlo@apple.com>
1625
1626         Contiguous array allocation should always be inlined
1627         https://bugs.webkit.org/show_bug.cgi?id=98608
1628
1629         Reviewed by Oliver Hunt and Mark Hahnenberg.
1630
1631         This inlines contiguous array allocation in the most obvious way possible.
1632
1633         * JavaScriptCore.xcodeproj/project.pbxproj:
1634         * assembler/MacroAssembler.h:
1635         (JSC::MacroAssembler::branchSubPtr):
1636         (MacroAssembler):
1637         * assembler/MacroAssemblerX86_64.h:
1638         (JSC::MacroAssemblerX86_64::branchSubPtr):
1639         (MacroAssemblerX86_64):
1640         * dfg/DFGAbstractState.cpp:
1641         (JSC::DFG::AbstractState::execute):
1642         * dfg/DFGCCallHelpers.h:
1643         (JSC::DFG::CCallHelpers::setupArgumentsWithExecState):
1644         (CCallHelpers):
1645         * dfg/DFGCallArrayAllocatorSlowPathGenerator.h: Added.
1646         (DFG):
1647         (CallArrayAllocatorSlowPathGenerator):
1648         (JSC::DFG::CallArrayAllocatorSlowPathGenerator::CallArrayAllocatorSlowPathGenerator):
1649         (JSC::DFG::CallArrayAllocatorSlowPathGenerator::generateInternal):
1650         (CallArrayAllocatorWithVariableSizeSlowPathGenerator):
1651         (JSC::DFG::CallArrayAllocatorWithVariableSizeSlowPathGenerator::CallArrayAllocatorWithVariableSizeSlowPathGenerator):
1652         (JSC::DFG::CallArrayAllocatorWithVariableSizeSlowPathGenerator::generateInternal):
1653         * dfg/DFGSpeculativeJIT.cpp:
1654         (JSC::DFG::SpeculativeJIT::emitAllocateJSArray):
1655         (DFG):
1656         (JSC::DFG::SpeculativeJIT::compileAllocatePropertyStorage):
1657         (JSC::DFG::SpeculativeJIT::compileReallocatePropertyStorage):
1658         * dfg/DFGSpeculativeJIT.h:
1659         (JSC::DFG::SpeculativeJIT::callOperation):
1660         (SpeculativeJIT):
1661         (JSC::DFG::SpeculativeJIT::emitAllocateBasicStorage):
1662         (JSC::DFG::SpeculativeJIT::emitAllocateBasicJSObject):
1663         (JSC::DFG::SpeculativeJIT::emitAllocateJSFinalObject):
1664         * dfg/DFGSpeculativeJIT32_64.cpp:
1665         (JSC::DFG::SpeculativeJIT::compile):
1666         * dfg/DFGSpeculativeJIT64.cpp:
1667         (JSC::DFG::SpeculativeJIT::compile):
1668
1669 2012-10-12  Mark Hahnenberg  <mhahnenberg@apple.com>
1670
1671         Race condition during CopyingPhase can lead to deadlock
1672         https://bugs.webkit.org/show_bug.cgi?id=99226
1673
1674         Reviewed by Filip Pizlo.
1675
1676         The main thread calls startCopying() for each of the GCThreads at the beginning of the copy phase. 
1677         It then proceeds to start copying. If copying completes before one of the GCThreads wakes up, the 
1678         main thread will set m_currentPhase back to NoPhase, the GCThread will wake up, see that there's 
1679         nothing to do, and then it will go back to sleep without ever calling CopyVisitor::doneCopying() 
1680         to return its borrowed block to the CopiedSpace. CopiedSpace::doneCopying() will then sleep forever 
1681         waiting on the block.
1682
1683         The fix for this is to make sure we call CopiedSpace::doneCopying() on the main thread before we 
1684         call GCThreadSharedData::didFinishCopying(), which sets the m_currentPhase flag to NoPhase. This 
1685         way we will wait until all threads have woken up and given back their borrowed blocks before 
1686         clearing the flag.
1687
1688         * heap/Heap.cpp:
1689         (JSC::Heap::copyBackingStores):
1690
1691 2012-10-12  Anders Carlsson  <andersca@apple.com>
1692
1693         Move macros from Parser.h to Parser.cpp
1694         https://bugs.webkit.org/show_bug.cgi?id=99217
1695
1696         Reviewed by Andreas Kling.
1697
1698         There are a bunch of macros in Parser.h that are only used in Parser.cpp. Move them to Parser.cpp
1699         so they won't pollute the global namespace.
1700         * parser/Parser.cpp:
1701         * parser/Parser.h:
1702         (JSC):
1703
1704 2012-10-12  Mark Hahnenberg  <mhahnenberg@apple.com>
1705
1706         Another build fix after r131213
1707
1708         Added some symbol magic to placate the linker on some platforms.
1709
1710         * JavaScriptCore.order:
1711
1712 2012-10-12  Mark Hahnenberg  <mhahnenberg@apple.com>
1713
1714         Build fix after r131213
1715
1716         Removed an unused variable that was making compilers unhappy.
1717
1718         * heap/GCThread.cpp:
1719         (JSC::GCThread::GCThread):
1720         * heap/GCThread.h:
1721         (GCThread):
1722         * heap/GCThreadSharedData.cpp:
1723         (JSC::GCThreadSharedData::GCThreadSharedData):
1724
1725 2012-10-09  Mark Hahnenberg  <mhahnenberg@apple.com>
1726
1727         Copying collection shouldn't require O(live bytes) memory overhead
1728         https://bugs.webkit.org/show_bug.cgi?id=98792
1729
1730         Reviewed by Filip Pizlo.
1731
1732         Currently our copying collection occurs simultaneously with the marking phase. We'd like 
1733         to be able to reuse CopiedBlocks as soon as they become fully evacuated, but this is not 
1734         currently possible because we don't know the liveness statistics of each old CopiedBlock 
1735         until marking/copying has already finished. Instead, we have to allocate additional memory 
1736         from the OS to use as our working set of CopiedBlocks while copying. We then return the 
1737         fully evacuated old CopiedBlocks back to the block allocator, thus giving our copying phase 
1738         an O(live bytes) overhead.
1739
1740         To fix this, we should instead split the copying phase apart from the marking phase. This 
1741         way we have full liveness data for each CopiedBlock during the copying phase so that we 
1742         can reuse them the instant they become fully evacuated. With the additional liveness data 
1743         that each CopiedBlock accumulates, we can add some additional heuristics to the collector. 
1744         For example, we can calculate our global Heap fragmentation and only choose to do a copying 
1745         phase if that fragmentation exceeds some limit. As another example, we can skip copying 
1746         blocks that are already above a particular fragmentation limit, which allows older objects 
1747         to coalesce into blocks that are rarely copied.
1748
1749         * JavaScriptCore.xcodeproj/project.pbxproj:
1750         * heap/CopiedBlock.h:
1751         (CopiedBlock):
1752         (JSC::CopiedBlock::CopiedBlock): Added support for tracking live bytes in a CopiedBlock in a 
1753         thread-safe fashion.
1754         (JSC::CopiedBlock::reportLiveBytes): Adds a number of live bytes to the block in a thread-safe 
1755         fashion using compare and swap.
1756         (JSC):
1757         (JSC::CopiedBlock::didSurviveGC): Called when a block survives a single GC without being 
1758         evacuated. This could be called for a couple reasons: (a) the block was pinned or (b) we 
1759         decided not to do any copying. A block can become pinned for a few reasons: (1) a pointer into 
1760         the block was found during the conservative scan. (2) the block was deemed full enough to 
1761         not warrant any copying. (3) The block is oversize and was found to be live. 
1762         (JSC::CopiedBlock::didEvacuateBytes): Called when some number of bytes are copied from this 
1763         block. If the number of live bytes ever hits zero, the block will return itself to the 
1764         BlockAllocator to be recycled.
1765         (JSC::CopiedBlock::canBeRecycled): Indicates that a block has no live bytes and can be 
1766         immediately recycled. This is used for blocks that are found to have zero live bytes at the 
1767         beginning of the copying phase.
1768         (JSC::CopiedBlock::shouldEvacuate): This function returns true if the current fragmentation 
1769         of the block is above our fragmentation threshold, and false otherwise.
1770         (JSC::CopiedBlock::isPinned): Added an accessor for the pinned flag
1771         (JSC::CopiedBlock::liveBytes): 
1772         * heap/CopiedSpace.cpp:
1773         (JSC::CopiedSpace::CopiedSpace):
1774         (JSC::CopiedSpace::doneFillingBlock): Changed so that we can exchange our filled block for a 
1775         fresh block. This avoids the situation where a thread returns its borrowed block, it's the last 
1776         borrowed block, so CopiedSpace thinks that copying has completed, and it starts doing all of the 
1777         copying phase cleanup. In actuality, the thread wanted another block after returning the current 
1778         block. So we allow the thread to atomically exchange its block for another block.
1779         (JSC::CopiedSpace::startedCopying): Added the calculation of global Heap fragmentation to 
1780         determine if the copying phase should commence. We include the MarkedSpace in our fragmentation 
1781         calculation by assuming that the MarkedSpace is 0% fragmented since we can reuse any currently 
1782         free memory in it (i.e. we ignore any internal fragmentation in the MarkedSpace). While we're 
1783         calculating the fragmentation of CopiedSpace, we also return any free blocks we find along the 
1784         way (meaning liveBytes() == 0).
1785         (JSC):
1786         (JSC::CopiedSpace::doneCopying): We still have to iterate over all the blocks, regardless of
1787         whether the copying phase took place or not so that we can reset all of the live bytes counters 
1788         and un-pin any pinned blocks.
1789         * heap/CopiedSpace.h:
1790         (CopiedSpace):
1791         (JSC::CopiedSpace::shouldDoCopyPhase):
1792         * heap/CopiedSpaceInlineMethods.h:
1793         (JSC::CopiedSpace::recycleEvacuatedBlock): This function is distinct from recycling a borrowed block 
1794         because a borrowed block hasn't been added to the CopiedSpace yet, but an evacuated block is still
1795         currently in CopiedSpace, so we have to make sure we properly remove all traces of the block from 
1796         CopiedSpace before returning it to BlockAllocator.
1797         (JSC::CopiedSpace::recycleBorrowedBlock): Renamed to indicate the distinction mentioned above.
1798         * heap/CopyVisitor.cpp: Added.
1799         (JSC):
1800         (JSC::CopyVisitor::CopyVisitor):
1801         (JSC::CopyVisitor::copyFromShared): Main function for any thread participating in the copying phase.
1802         Grabs chunks of MarkedBlocks from the shared list and copies the backing store of anybody who needs
1803         it until there are no more chunks to copy.
1804         * heap/CopyVisitor.h: Added.
1805         (JSC):
1806         (CopyVisitor):
1807         * heap/CopyVisitorInlineMethods.h: Added.
1808         (JSC):
1809         (GCCopyPhaseFunctor):
1810         (JSC::GCCopyPhaseFunctor::GCCopyPhaseFunctor):
1811         (JSC::GCCopyPhaseFunctor::operator()):
1812         (JSC::CopyVisitor::checkIfShouldCopy): We don't have to check shouldEvacuate() because all of those 
1813         checks are done during the marking phase.
1814         (JSC::CopyVisitor::allocateNewSpace): 
1815         (JSC::CopyVisitor::allocateNewSpaceSlow):
1816         (JSC::CopyVisitor::startCopying): Initialization function for a thread that is about to start copying.
1817         (JSC::CopyVisitor::doneCopying):
1818         (JSC::CopyVisitor::didCopy): This callback is called by an object that has just successfully copied its
1819         backing store. It indicates to the CopiedBlock that somebody has just finished evacuating some number of 
1820         bytes from it, and, if the CopiedBlock now has no more live bytes, can be recycled immediately.
1821         * heap/GCThread.cpp: Added.
1822         (JSC):
1823         (JSC::GCThread::GCThread): This is a new class that encapsulates a single thread responsible for participating 
1824         in a specific set of GC phases. Currently, that set of phases includes Mark, Copy, and Exit. Each thread 
1825         monitors a shared variable in its associated GCThreadSharedData. The main thread updates this m_currentPhase
1826         variable as collection progresses through the various phases. Parallel marking still works exactly like it 
1827         has. In other words, the "run loop" for each of the GC threads sits above any individual phase, thus keeping 
1828         the separate phases of the collector orthogonal.
1829         (JSC::GCThread::threadID):
1830         (JSC::GCThread::initializeThreadID):
1831         (JSC::GCThread::slotVisitor):
1832         (JSC::GCThread::copyVisitor):
1833         (JSC::GCThread::waitForNextPhase):
1834         (JSC::GCThread::gcThreadMain):
1835         (JSC::GCThread::gcThreadStartFunc):
1836         * heap/GCThread.h: Added.
1837         (JSC):
1838         (GCThread):
1839         * heap/GCThreadSharedData.cpp: The GCThreadSharedData now has a list of GCThread objects rather than raw 
1840         ThreadIdentifiers.
1841         (JSC::GCThreadSharedData::resetChildren):
1842         (JSC::GCThreadSharedData::childVisitCount):
1843         (JSC::GCThreadSharedData::GCThreadSharedData):
1844         (JSC::GCThreadSharedData::~GCThreadSharedData):
1845         (JSC::GCThreadSharedData::reset):
1846         (JSC::GCThreadSharedData::didStartMarking): Callback to let the GCThreadSharedData know that marking has 
1847         started and updates the m_currentPhase variable and notifies the GCThreads accordingly.
1848         (JSC::GCThreadSharedData::didFinishMarking): Ditto for finishing marking. 
1849         (JSC::GCThreadSharedData::didStartCopying): Ditto for starting the copying phase.
1850         (JSC::GCThreadSharedData::didFinishCopying): Ditto for finishing copying. 
1851         * heap/GCThreadSharedData.h:
1852         (JSC):
1853         (GCThreadSharedData):
1854         (JSC::GCThreadSharedData::getNextBlocksToCopy): Atomically gets the next chunk of work for a copying thread.
1855         * heap/Heap.cpp:
1856         (JSC::Heap::Heap):
1857         (JSC::Heap::markRoots):
1858         (JSC):
1859         (JSC::Heap::copyBackingStores): Responsible for setting up the copying phase, notifying the copying threads, 
1860         and doing any copying work if necessary.
1861         (JSC::Heap::collect):
1862         * heap/Heap.h:
1863         (Heap):
1864         (JSC):
1865         (JSC::CopyFunctor::CopyFunctor):
1866         (CopyFunctor):
1867         (JSC::CopyFunctor::operator()):
1868         * heap/IncrementalSweeper.cpp: Changed the incremental sweeper to have a reference to the list of MarkedBlocks 
1869         that need sweeping, since this now resides in the Heap so that it can be easily shared by the GCThreads.
1870         (JSC::IncrementalSweeper::IncrementalSweeper):
1871         (JSC::IncrementalSweeper::startSweeping):
1872         * heap/IncrementalSweeper.h:
1873         (JSC):
1874         (IncrementalSweeper):
1875         * heap/SlotVisitor.cpp:
1876         (JSC::SlotVisitor::setup):
1877         (JSC::SlotVisitor::drainFromShared): We no longer do any copying-related work here.
1878         (JSC):
1879         * heap/SlotVisitor.h:
1880         (SlotVisitor):
1881         * heap/SlotVisitorInlineMethods.h:
1882         (JSC):
1883         (JSC::SlotVisitor::copyLater): Notifies the CopiedBlock that there are some live bytes that may need 
1884         to be copied.
1885         * runtime/Butterfly.h:
1886         (JSC):
1887         (Butterfly):
1888         * runtime/ButterflyInlineMethods.h:
1889         (JSC::Butterfly::createUninitializedDuringCollection): Uses the new CopyVisitor.
1890         * runtime/ClassInfo.h:
1891         (MethodTable): Added new "virtual" function copyBackingStore to method table.
1892         (JSC):
1893         * runtime/JSCell.cpp:
1894         (JSC::JSCell::copyBackingStore): Default implementation that does nothing.
1895         (JSC):
1896         * runtime/JSCell.h:
1897         (JSC):
1898         (JSCell):
1899         * runtime/JSObject.cpp:
1900         (JSC::JSObject::copyButterfly): Does the actual copying of the butterfly.
1901         (JSC):
1902         (JSC::JSObject::visitButterfly): Calls copyLater for the butterfly.
1903         (JSC::JSObject::copyBackingStore): 
1904         * runtime/JSObject.h:
1905         (JSObject):
1906         (JSC::JSCell::methodTable):
1907         (JSC::JSCell::inherits):
1908         * runtime/Options.h: Added two new constants, minHeapUtilization and minCopiedBlockUtilization, 
1909         to govern the amount of fragmentation we allow before doing copying.
1910         (JSC):
1911
1912 2012-10-12  Filip Pizlo  <fpizlo@apple.com>
1913
1914         DFG array allocation calls should not return an encoded JSValue
1915         https://bugs.webkit.org/show_bug.cgi?id=99196
1916
1917         Reviewed by Mark Hahnenberg.
1918
1919         The array allocation operations now return a pointer instead. This makes it
1920         easier to share code between 32-bit and 64-bit.
1921
1922         * dfg/DFGOperations.cpp:
1923         * dfg/DFGOperations.h:
1924         * dfg/DFGSpeculativeJIT.h:
1925         (JSC::DFG::SpeculativeJIT::callOperation):
1926         * dfg/DFGSpeculativeJIT32_64.cpp:
1927         (JSC::DFG::SpeculativeJIT::compile):
1928
1929 2012-10-01  Jer Noble  <jer.noble@apple.com>
1930
1931         Enable ENCRYPTED_MEDIA support on Mac.
1932         https://bugs.webkit.org/show_bug.cgi?id=98044
1933
1934         Reviewed by Anders Carlsson.
1935
1936         Enable the ENCRYPTED_MEDIA flag.
1937
1938         * Configurations/FeatureDefines.xcconfig:
1939
1940 2012-10-12  Filip Pizlo  <fpizlo@apple.com>
1941
1942         Unreviewed. It should be possible to build JSC on ARMv7.
1943
1944         * assembler/MacroAssemblerARMv7.h:
1945         (JSC::MacroAssemblerARMv7::patchableBranchPtr):
1946
1947 2012-10-11  Mark Hahnenberg  <mhahnenberg@apple.com>
1948
1949         BlockAllocator should use regions as its VM allocation abstraction
1950         https://bugs.webkit.org/show_bug.cgi?id=99107
1951
1952         Reviewed by Geoffrey Garen.
1953
1954         Currently the BlockAllocator allocates a single block at a time directly from the OS. Our block 
1955         allocations are on the large-ish side (64 KB) to amortize across many allocations the expense of 
1956         mapping new virtual memory from the OS. These large blocks are then shared between the MarkedSpace 
1957         and the CopiedSpace. This design makes it difficult to vary the size of the blocks in different 
1958         parts of the Heap while still allowing us to amortize the VM allocation costs.
1959
1960         We should redesign the BlockAllocator so that it has a layer of indirection between blocks that are 
1961         used by the allocator/collector and our primary unit of VM allocation from the OS. In particular, 
1962         the BlockAllocator should allocate Regions of virtual memory from the OS, which are then subdivided 
1963         into one or more Blocks to be used in our custom allocators. This design has the following nice properties:
1964
1965         1) We can remove the knowledge of PageAllocationAligned from HeapBlocks. Each HeapBlock will now 
1966            only know what Region it belongs to. The Region maintains all the metadata for how to allocate 
1967            and deallocate virtual memory from the OS.
1968
1969         2) We can easily allocate in larger chunks than we need to satisfy a particular request for a Block. 
1970            We can then continue to amortize our VM allocation costs while allowing for smaller block sizes, 
1971            which should increase locality in the mutator when allocating, lazy sweeping, etc.
1972
1973         3) By encapsulating the logic of where our memory comes from inside of the Region class, we can more 
1974            easily transition over to allocating VM from a specific range of pre-reserved address space. This 
1975            will be a necessary step along the way to 32-bit pointers.
1976
1977         This particular patch will not change the size of MarkedBlocks or CopiedBlocks, nor will it change how 
1978         much VM we allocate per failed Block request. It only sets up the data structures that we need to make 
1979         these changes in future patches.
1980
1981         Most of the changes in this patch relate to the addition of the Region class to be used by the 
1982         BlockAllocator and the threading of changes made to BlockAllocator's interface through to the call sites.
1983
1984         * heap/BlockAllocator.cpp: The BlockAllocator now has three lists that track the three disjoint sets of
1985         Regions that it cares about: empty regions, partially full regions, and completely full regions. 
1986         Empty regions have no blocks currently in use and can be freed immediately if the freeing thread 
1987         determines they should be. Partial regions have some blocks used, but aren't completely in use yet. 
1988         These regions are preferred for recycling before empty regions to mitigate fragmentation within regions.
1989         Completely full regions are no longer able to be used for allocations. Regions move between these 
1990         three lists as they are created and their constituent blocks are allocated and deallocated.
1991         (JSC::BlockAllocator::BlockAllocator):
1992         (JSC::BlockAllocator::~BlockAllocator):
1993         (JSC::BlockAllocator::releaseFreeRegions):
1994         (JSC::BlockAllocator::waitForRelativeTimeWhileHoldingLock):
1995         (JSC::BlockAllocator::waitForRelativeTime):
1996         (JSC::BlockAllocator::blockFreeingThreadMain):
1997         * heap/BlockAllocator.h:
1998         (JSC):
1999         (DeadBlock):
2000         (JSC::DeadBlock::DeadBlock):
2001         (Region):
2002         (JSC::Region::blockSize):
2003         (JSC::Region::isFull):
2004         (JSC::Region::isEmpty):
2005         (JSC::Region::create): This function is responsible for doing the actual VM allocation. This should be the 
2006         only function in the entire JSC object runtime that calls out the OS for virtual memory allocation.
2007         (JSC::Region::Region):
2008         (JSC::Region::~Region):
2009         (JSC::Region::allocate):
2010         (JSC::Region::deallocate):
2011         (BlockAllocator):
2012         (JSC::BlockAllocator::tryAllocateFromRegion): Helper function that encapsulates checking a particular list 
2013         of regions for a free block.
2014         (JSC::BlockAllocator::allocate):
2015         (JSC::BlockAllocator::allocateCustomSize): This function is responsible for allocating one-off custom size 
2016         regions for use in oversize allocations in both the MarkedSpace and the CopiedSpace. These regions are not 
2017         tracked by the BlockAllocator. The only pointer to them is in the HeapBlock that is returned. These regions 
2018         contain exactly one block.
2019         (JSC::BlockAllocator::deallocate):
2020         (JSC::BlockAllocator::deallocateCustomSize): This function is responsible for deallocating one-off custom size
2021         regions. The regions are deallocated back to the OS eagerly.
2022         * heap/CopiedBlock.h: Re-worked CopiedBlocks to use Regions instead of PageAllocationAligned.
2023         (CopiedBlock):
2024         (JSC::CopiedBlock::createNoZeroFill):
2025         (JSC::CopiedBlock::create):
2026         (JSC::CopiedBlock::CopiedBlock):
2027         (JSC::CopiedBlock::payloadEnd):
2028         (JSC::CopiedBlock::capacity):
2029         * heap/CopiedSpace.cpp:
2030         (JSC::CopiedSpace::~CopiedSpace):
2031         (JSC::CopiedSpace::tryAllocateOversize):
2032         (JSC::CopiedSpace::tryReallocateOversize):
2033         (JSC::CopiedSpace::doneCopying):
2034         * heap/CopiedSpaceInlineMethods.h:
2035         (JSC::CopiedSpace::allocateBlockForCopyingPhase):
2036         (JSC::CopiedSpace::allocateBlock):
2037         * heap/HeapBlock.h:
2038         (JSC::HeapBlock::destroy):
2039         (JSC::HeapBlock::HeapBlock):
2040         (JSC::HeapBlock::region):
2041         (HeapBlock):
2042         * heap/MarkedAllocator.cpp:
2043         (JSC::MarkedAllocator::allocateBlock):
2044         * heap/MarkedBlock.cpp:
2045         (JSC::MarkedBlock::create):
2046         (JSC::MarkedBlock::MarkedBlock):
2047         * heap/MarkedBlock.h:
2048         (JSC::MarkedBlock::capacity):
2049         * heap/MarkedSpace.cpp:
2050         (JSC::MarkedSpace::freeBlock):
2051
2052 2012-10-11  Filip Pizlo  <fpizlo@apple.com>
2053
2054         UInt32ToNumber and OSR exit should be aware of copy propagation and correctly recover both versions of a variable that was subject to a UInt32ToNumber cast
2055         https://bugs.webkit.org/show_bug.cgi?id=99100
2056         <rdar://problem/12480955>
2057
2058         Reviewed by Michael Saboff and Mark Hahnenberg.
2059
2060         Fixed by forcing UInt32ToNumber to use a different register. This "undoes" the copy propagation that we
2061         would have been doing, since it has no performance effect in this case and has the benefit of making the
2062         OSR exit compiler a lot simpler.
2063
2064         * dfg/DFGSpeculativeJIT.cpp:
2065         (JSC::DFG::SpeculativeJIT::compileUInt32ToNumber):
2066
2067 2012-10-11  Geoffrey Garen  <ggaren@apple.com>
2068
2069         Removed some more static assumptions about inline object capacity
2070         https://bugs.webkit.org/show_bug.cgi?id=98603
2071
2072         Reviewed by Filip Pizlo.
2073
2074         * dfg/DFGSpeculativeJIT.h:
2075         (JSC::DFG::SpeculativeJIT::emitAllocateBasicJSObject): Use JSObject::allocationSize()
2076         for a little more flexibility. We still pass it a constant inline capacity
2077         because the JIT doesn't have a strategy for selecting a size class based
2078         on non-constant capacity yet. "INLINE_STORAGE_CAPACITY" is a marker for
2079         code that makes static assumptions about object size.
2080
2081         * jit/JITInlineMethods.h:
2082         (JSC::JIT::emitAllocateBasicJSObject):
2083         * llint/LLIntData.cpp:
2084         (JSC::LLInt::Data::performAssertions):
2085         * llint/LowLevelInterpreter32_64.asm:
2086         * llint/LowLevelInterpreter64.asm: Ditto for the rest of our many execution engines.
2087
2088         * runtime/JSObject.h:
2089         (JSC::JSObject::allocationSize):
2090         (JSC::JSFinalObject::finishCreation):
2091         (JSC::JSFinalObject::create): New helper function for computing object
2092         size dynamically, since we plan to have objects of different sizes.
2093
2094         (JSC::JSFinalObject::JSFinalObject): Note that our m_inlineStorage used
2095         to auto-generate an implicit C++ constructor with default null initialization.
2096         This memory is not observed in its uninitialized state, and our LLInt and
2097         JIT allocators do not initialize it, so I did not add any explicit code
2098         to do so, now that the implicit code is gone.
2099
2100         (JSC::JSObject::offsetOfInlineStorage): Changed the math here to match
2101         inlineStorageUnsafe(), since we can rely on an explicit data member anymore.
2102
2103 2012-10-11  Geoffrey Garen  <ggaren@apple.com>
2104
2105         Enable RUNTIME_HEURISTICS all the time, for easier testing
2106         https://bugs.webkit.org/show_bug.cgi?id=99090
2107
2108         Reviewed by Filip Pizlo.
2109
2110         I find myself using this a lot, and there doesn't seem to be an obvious
2111         reason to compile it out, since it only runs once at startup.
2112
2113         * runtime/Options.cpp:
2114         (JSC::overrideOptionWithHeuristic):
2115         (JSC::Options::initialize):
2116         * runtime/Options.h: Removed the #ifdef.
2117
2118 2012-10-11  Geoffrey Garen  <ggaren@apple.com>
2119
2120         Removed ASSERT_CLASS_FITS_IN_CELL
2121         https://bugs.webkit.org/show_bug.cgi?id=97634
2122
2123         Reviewed by Mark Hahnenberg.
2124
2125         Our collector now supports arbitrarily sized objects, so the ASSERT is not needed.
2126
2127         * API/JSCallbackFunction.cpp:
2128         * API/JSCallbackObject.cpp:
2129         * heap/MarkedSpace.h:
2130         * jsc.cpp:
2131         * runtime/Arguments.cpp:
2132         * runtime/ArrayConstructor.cpp:
2133         * runtime/ArrayPrototype.cpp:
2134         * runtime/BooleanConstructor.cpp:
2135         * runtime/BooleanObject.cpp:
2136         * runtime/BooleanPrototype.cpp:
2137         * runtime/DateConstructor.cpp:
2138         * runtime/DatePrototype.cpp:
2139         * runtime/Error.cpp:
2140         * runtime/ErrorConstructor.cpp:
2141         * runtime/ErrorPrototype.cpp:
2142         * runtime/FunctionConstructor.cpp:
2143         * runtime/FunctionPrototype.cpp:
2144         * runtime/InternalFunction.cpp:
2145         * runtime/JSActivation.cpp:
2146         * runtime/JSArray.cpp:
2147         * runtime/JSBoundFunction.cpp:
2148         * runtime/JSFunction.cpp:
2149         * runtime/JSGlobalObject.cpp:
2150         * runtime/JSGlobalThis.cpp:
2151         * runtime/JSNameScope.cpp:
2152         * runtime/JSNotAnObject.cpp:
2153         * runtime/JSONObject.cpp:
2154         * runtime/JSObject.cpp:
2155         * runtime/JSPropertyNameIterator.cpp:
2156         * runtime/JSScope.cpp:
2157         * runtime/JSWithScope.cpp:
2158         * runtime/JSWrapperObject.cpp:
2159         * runtime/MathObject.cpp:
2160         * runtime/NameConstructor.cpp:
2161         * runtime/NamePrototype.cpp:
2162         * runtime/NativeErrorConstructor.cpp:
2163         * runtime/NativeErrorPrototype.cpp:
2164         * runtime/NumberConstructor.cpp:
2165         * runtime/NumberObject.cpp:
2166         * runtime/NumberPrototype.cpp:
2167         * runtime/ObjectConstructor.cpp:
2168         * runtime/ObjectPrototype.cpp:
2169         * runtime/RegExpConstructor.cpp:
2170         * runtime/RegExpMatchesArray.cpp:
2171         * runtime/RegExpObject.cpp:
2172         * runtime/RegExpPrototype.cpp:
2173         * runtime/StringConstructor.cpp:
2174         * runtime/StringObject.cpp:
2175         * runtime/StringPrototype.cpp:
2176         * testRegExp.cpp: Removed the ASSERT.
2177
2178 2012-10-11  Filip Pizlo  <fpizlo@apple.com>
2179
2180         DFG should inline code blocks that use new_array_buffer
2181         https://bugs.webkit.org/show_bug.cgi?id=98996
2182
2183         Reviewed by Geoffrey Garen.
2184
2185         This adds plumbing to drop in constant buffers from the inlinees to the inliner.
2186         It's smart about not duplicating buffers needlessly but doesn't try to completely
2187         hash-cons them, either.
2188
2189         * bytecode/CodeBlock.h:
2190         (JSC::CodeBlock::numberOfConstantBuffers):
2191         (JSC::CodeBlock::addConstantBuffer):
2192         (JSC::CodeBlock::constantBufferAsVector):
2193         (JSC::CodeBlock::constantBuffer):
2194         * dfg/DFGAbstractState.cpp:
2195         (JSC::DFG::AbstractState::execute):
2196         * dfg/DFGByteCodeParser.cpp:
2197         (ConstantBufferKey):
2198         (JSC::DFG::ConstantBufferKey::ConstantBufferKey):
2199         (JSC::DFG::ConstantBufferKey::operator==):
2200         (JSC::DFG::ConstantBufferKey::hash):
2201         (JSC::DFG::ConstantBufferKey::isHashTableDeletedValue):
2202         (JSC::DFG::ConstantBufferKey::codeBlock):
2203         (JSC::DFG::ConstantBufferKey::index):
2204         (DFG):
2205         (JSC::DFG::ConstantBufferKeyHash::hash):
2206         (JSC::DFG::ConstantBufferKeyHash::equal):
2207         (ConstantBufferKeyHash):
2208         (WTF):
2209         (ByteCodeParser):
2210         (InlineStackEntry):
2211         (JSC::DFG::ByteCodeParser::parseBlock):
2212         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2213         * dfg/DFGCapabilities.h:
2214         (JSC::DFG::canInlineOpcode):
2215         * dfg/DFGOperations.cpp:
2216         * dfg/DFGOperations.h:
2217         * dfg/DFGSpeculativeJIT.h:
2218         (JSC::DFG::SpeculativeJIT::callOperation):
2219         * dfg/DFGSpeculativeJIT32_64.cpp:
2220         (JSC::DFG::SpeculativeJIT::compile):
2221         * dfg/DFGSpeculativeJIT64.cpp:
2222         (JSC::DFG::SpeculativeJIT::compile):
2223
2224 2012-10-10  Zoltan Horvath  <zoltan@webkit.org>
2225
2226         Pageload tests should measure memory usage
2227         https://bugs.webkit.org/show_bug.cgi?id=93958
2228
2229         Reviewed by Ryosuke Niwa.
2230
2231         Add JS Heap and Heap memory measurement to PageLoad tests.
2232
2233         * heap/HeapStatistics.cpp:
2234         (JSC::HeapStatistics::usedJSHeap): Add new private function to expose the used JS Heap size.
2235         (JSC):
2236         * heap/HeapStatistics.h:
2237         (HeapStatistics): Add new private function to expose the used JS Heap size.
2238
2239 2012-10-10  Balazs Kilvady  <kilvadyb@homejinni.com>
2240
2241         RegisterFile to JSStack rename fix for a struct member.
2242
2243         Compilation problem in debug build on MIPS
2244         https://bugs.webkit.org/show_bug.cgi?id=98808
2245
2246         Reviewed by Alexey Proskuryakov.
2247
2248         In ASSERT conditions structure field name "registerFile" was replaced
2249         with type name "JSStack" and it should be "stack".
2250
2251         * jit/JITStubs.cpp:
2252         (JSC::JITThunks::JITThunks): structure member name fix.
2253
2254 2012-10-10  Michael Saboff  <msaboff@apple.com>
2255
2256         After r130344, OpaqueJSString::string() shouldn't directly return the wrapped String
2257         https://bugs.webkit.org/show_bug.cgi?id=98801
2258
2259         Reviewed by Geoffrey Garen.
2260
2261         Return a copy of the wrapped String so that the wrapped string cannot be turned into 
2262         an Identifier.
2263
2264         * API/OpaqueJSString.cpp:
2265         (OpaqueJSString::string):
2266         * API/OpaqueJSString.h:
2267         (OpaqueJSString):
2268
2269 2012-10-10  Peter Gal  <galpeter@inf.u-szeged.hu>
2270
2271         Add moveDoubleToInts and moveIntsToDouble to MacroAssemblerARM
2272         https://bugs.webkit.org/show_bug.cgi?id=98855
2273
2274         Reviewed by Filip Pizlo.
2275
2276         Implement the missing moveDoubleToInts and moveIntsToDouble
2277         methods in the MacroAssemblerARM after r130839.
2278
2279         * assembler/MacroAssemblerARM.h:
2280         (JSC::MacroAssemblerARM::moveDoubleToInts):
2281         (MacroAssemblerARM):
2282         (JSC::MacroAssemblerARM::moveIntsToDouble):
2283
2284 2012-10-09  Filip Pizlo  <fpizlo@apple.com>
2285
2286         Typed arrays should not be 20x slower in the baseline JIT than in the DFG JIT
2287         https://bugs.webkit.org/show_bug.cgi?id=98605
2288
2289         Reviewed by Oliver Hunt and Gavin Barraclough.
2290
2291         This adds typed array get_by_val/put_by_val patching to the baseline JIT. It's
2292         a big (~40%) win on benchmarks that have trouble staying in the DFG JIT. Even
2293         if we fix those benchmarks, this functionality gives us the insurance that we
2294         typically desire with all speculative optimizations: even if we bail to
2295         baseline, we're still reasonably performant.
2296
2297         * CMakeLists.txt:
2298         * GNUmakefile.list.am:
2299         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
2300         * JavaScriptCore.xcodeproj/project.pbxproj:
2301         * Target.pri:
2302         * assembler/MacroAssembler.cpp: Added.
2303         (JSC):
2304         * assembler/MacroAssembler.h:
2305         (MacroAssembler):
2306         (JSC::MacroAssembler::patchableBranchPtr):
2307         * assembler/MacroAssemblerARMv7.h:
2308         (MacroAssemblerARMv7):
2309         (JSC::MacroAssemblerARMv7::moveDoubleToInts):
2310         (JSC::MacroAssemblerARMv7::moveIntsToDouble):
2311         (JSC::MacroAssemblerARMv7::patchableBranchPtr):
2312         * assembler/MacroAssemblerX86.h:
2313         (MacroAssemblerX86):
2314         (JSC::MacroAssemblerX86::moveDoubleToInts):
2315         (JSC::MacroAssemblerX86::moveIntsToDouble):
2316         * bytecode/ByValInfo.h:
2317         (JSC::hasOptimizableIndexingForClassInfo):
2318         (JSC):
2319         (JSC::hasOptimizableIndexing):
2320         (JSC::jitArrayModeForClassInfo):
2321         (JSC::jitArrayModeForStructure):
2322         (JSC::ByValInfo::ByValInfo):
2323         (ByValInfo):
2324         * dfg/DFGAssemblyHelpers.cpp:
2325         (DFG):
2326         * dfg/DFGAssemblyHelpers.h:
2327         (AssemblyHelpers):
2328         (JSC::DFG::AssemblyHelpers::boxDouble):
2329         (JSC::DFG::AssemblyHelpers::unboxDouble):
2330         * dfg/DFGSpeculativeJIT.cpp:
2331         (JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
2332         (JSC::DFG::SpeculativeJIT::compilePutByValForIntTypedArray):
2333         * dfg/DFGSpeculativeJIT.h:
2334         (SpeculativeJIT):
2335         * jit/JIT.h:
2336         (JIT):
2337         * jit/JITPropertyAccess.cpp:
2338         (JSC::JIT::emit_op_get_by_val):
2339         (JSC::JIT::emit_op_put_by_val):
2340         (JSC::JIT::privateCompileGetByVal):
2341         (JSC::JIT::privateCompilePutByVal):
2342         (JSC::JIT::emitIntTypedArrayGetByVal):
2343         (JSC):
2344         (JSC::JIT::emitFloatTypedArrayGetByVal):
2345         (JSC::JIT::emitIntTypedArrayPutByVal):
2346         (JSC::JIT::emitFloatTypedArrayPutByVal):
2347         * jit/JITPropertyAccess32_64.cpp:
2348         (JSC::JIT::emit_op_get_by_val):
2349         (JSC::JIT::emit_op_put_by_val):
2350         * jit/JITStubs.cpp:
2351         (JSC::DEFINE_STUB_FUNCTION):
2352         * runtime/JSCell.h:
2353         * runtime/JSGlobalData.h:
2354         (JSGlobalData):
2355         (JSC::JSGlobalData::typedArrayDescriptor):
2356         * runtime/TypedArrayDescriptor.h: Added.
2357         (JSC):
2358         (JSC::TypedArrayDescriptor::TypedArrayDescriptor):
2359         (TypedArrayDescriptor):
2360
2361 2012-10-09  Michael Saboff  <msaboff@apple.com>
2362
2363         Add tests to testapi for null OpaqueJSStrings
2364         https://bugs.webkit.org/show_bug.cgi?id=98805
2365
2366         Reviewed by Geoffrey Garen.
2367
2368         Added tests that check that OpaqueJSString, which is wrapped via JSStringRef, properly returns
2369         null strings and that a null string in a JSStringRef will return a NULL JSChar* and 0 length
2370         via the JSStringGetCharactersPtr() and JSStringGetLength() APIs respectively. Added a check that 
2371         JSValueMakeFromJSONString() properly handles a null string as well.
2372
2373         * API/tests/testapi.c:
2374         (main):
2375
2376 2012-10-09  Jian Li  <jianli@chromium.org>
2377
2378         Update the CSS property used to support draggable regions.
2379         https://bugs.webkit.org/show_bug.cgi?id=97156
2380
2381         Reviewed by Adam Barth.
2382
2383         The CSS property to support draggable regions, guarded under
2384         WIDGET_REGION is now disabled from Mac WebKit, in order not to cause
2385         confusion with DASHBOARD_SUPPORT feature.
2386
2387         * Configurations/FeatureDefines.xcconfig: Disable WIDGET_REGION feature.
2388
2389 2012-10-09  Filip Pizlo  <fpizlo@apple.com>
2390
2391         Unreviewed, adding forgotten files.
2392
2393         * bytecode/ByValInfo.h: Added.
2394         (JSC):
2395         (JSC::isOptimizableIndexingType):
2396         (JSC::jitArrayModeForIndexingType):
2397         (JSC::ByValInfo::ByValInfo):
2398         (ByValInfo):
2399         (JSC::getByValInfoBytecodeIndex):
2400         * runtime/IndexingType.cpp: Added.
2401         (JSC):
2402         (JSC::indexingTypeToString):
2403
2404 2012-10-08  Filip Pizlo  <fpizlo@apple.com>
2405
2406         JSC should infer when indexed storage is contiguous, and optimize for it
2407         https://bugs.webkit.org/show_bug.cgi?id=97288
2408
2409         Reviewed by Mark Hahnenberg.
2410
2411         This introduces a new kind of indexed property storage called Contiguous,
2412         which has the following properties:
2413         
2414         - No header bits beyond IndexedHeader. This results in a 16 byte reduction
2415           in memory usage per array versus an ArrayStorage array. It also means
2416           that the total memory usage for an empty array is now just 3 * 8 on both
2417           32-bit and 64-bit. Of that, only 8 bytes are array-specific; the rest is
2418           our standard object header overhead.
2419         
2420         - No need for hole checks on store. This results in a ~4% speed-up on
2421           Kraken and a ~1% speed-up on V8v7.
2422         
2423         - publicLength <= vectorLength. This means that doing new Array(blah)
2424           immediately allocates room for blah elements.
2425         
2426         - No sparse map or index bias.
2427         
2428         If you ever do things to an array that would require publicLength >
2429         vectorLength, a sparse map, or index bias, then we switch to ArrayStorage
2430         mode. This seems to never happen in any benchmark we track, and is unlikely
2431         to happen very frequently on any website.
2432
2433         * CMakeLists.txt:
2434         * GNUmakefile.list.am:
2435         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
2436         * JavaScriptCore.xcodeproj/project.pbxproj:
2437         * Target.pri:
2438         * assembler/AbstractMacroAssembler.h:
2439         (JSC::AbstractMacroAssembler::JumpList::append):
2440         * assembler/MacroAssembler.h:
2441         (MacroAssembler):
2442         (JSC::MacroAssembler::patchableBranchTest32):
2443         * bytecode/ByValInfo.h: Added.
2444         (JSC):
2445         (JSC::isOptimizableIndexingType):
2446         (JSC::jitArrayModeForIndexingType):
2447         (JSC::ByValInfo::ByValInfo):
2448         (ByValInfo):
2449         (JSC::getByValInfoBytecodeIndex):
2450         * bytecode/CodeBlock.h:
2451         (CodeBlock):
2452         (JSC::CodeBlock::getByValInfo):
2453         (JSC::CodeBlock::setNumberOfByValInfos):
2454         (JSC::CodeBlock::numberOfByValInfos):
2455         (JSC::CodeBlock::byValInfo):
2456         * bytecode/SamplingTool.h:
2457         * dfg/DFGAbstractState.cpp:
2458         (JSC::DFG::AbstractState::execute):
2459         * dfg/DFGArrayMode.cpp:
2460         (JSC::DFG::fromObserved):
2461         (JSC::DFG::modeAlreadyChecked):
2462         (JSC::DFG::modeToString):
2463         * dfg/DFGArrayMode.h:
2464         (DFG):
2465         (JSC::DFG::modeUsesButterfly):
2466         (JSC::DFG::modeIsJSArray):
2467         (JSC::DFG::isInBoundsAccess):
2468         (JSC::DFG::mayStoreToTail):
2469         (JSC::DFG::mayStoreToHole):
2470         (JSC::DFG::modeIsPolymorphic):
2471         (JSC::DFG::polymorphicIncludesContiguous):
2472         (JSC::DFG::polymorphicIncludesArrayStorage):
2473         (JSC::DFG::canCSEStorage):
2474         (JSC::DFG::modeSupportsLength):
2475         (JSC::DFG::benefitsFromStructureCheck):
2476         (JSC::DFG::isEffectful):
2477         * dfg/DFGByteCodeParser.cpp:
2478         (JSC::DFG::ByteCodeParser::handleIntrinsic):
2479         * dfg/DFGCSEPhase.cpp:
2480         (JSC::DFG::CSEPhase::getArrayLengthElimination):
2481         (JSC::DFG::CSEPhase::getByValLoadElimination):
2482         (JSC::DFG::CSEPhase::performNodeCSE):
2483         * dfg/DFGFixupPhase.cpp:
2484         (JSC::DFG::FixupPhase::fixupNode):
2485         (JSC::DFG::FixupPhase::checkArray):
2486         (JSC::DFG::FixupPhase::blessArrayOperation):
2487         * dfg/DFGGraph.h:
2488         (JSC::DFG::Graph::byValIsPure):
2489         * dfg/DFGOperations.cpp:
2490         * dfg/DFGOperations.h:
2491         * dfg/DFGRepatch.cpp:
2492         (JSC::DFG::tryCacheGetByID):
2493         * dfg/DFGSpeculativeJIT.cpp:
2494         (JSC::DFG::SpeculativeJIT::checkArray):
2495         (JSC::DFG::SpeculativeJIT::arrayify):
2496         (JSC::DFG::SpeculativeJIT::compileGetArrayLength):
2497         (JSC::DFG::SpeculativeJIT::temporaryRegisterForPutByVal):
2498         (DFG):
2499         * dfg/DFGSpeculativeJIT.h:
2500         (DFG):
2501         (JSC::DFG::SpeculativeJIT::callOperation):
2502         (SpeculativeJIT):
2503         (JSC::DFG::SpeculativeJIT::putByValWillNeedExtraRegister):
2504         (JSC::DFG::SpeculativeJIT::temporaryRegisterForPutByVal):
2505         * dfg/DFGSpeculativeJIT32_64.cpp:
2506         (JSC::DFG::SpeculativeJIT::compileContiguousGetByVal):
2507         (DFG):
2508         (JSC::DFG::SpeculativeJIT::compileArrayStorageGetByVal):
2509         (JSC::DFG::SpeculativeJIT::compileContiguousPutByVal):
2510         (JSC::DFG::SpeculativeJIT::compileArrayStoragePutByVal):
2511         (JSC::DFG::SpeculativeJIT::compile):
2512         * dfg/DFGSpeculativeJIT64.cpp:
2513         (JSC::DFG::SpeculativeJIT::compileContiguousGetByVal):
2514         (DFG):
2515         (JSC::DFG::SpeculativeJIT::compileArrayStorageGetByVal):
2516         (JSC::DFG::SpeculativeJIT::compileContiguousPutByVal):
2517         (JSC::DFG::SpeculativeJIT::compileArrayStoragePutByVal):
2518         (JSC::DFG::SpeculativeJIT::compile):
2519         * interpreter/Interpreter.cpp:
2520         (SamplingScope):
2521         (JSC::SamplingScope::SamplingScope):
2522         (JSC::SamplingScope::~SamplingScope):
2523         (JSC):
2524         (JSC::Interpreter::execute):
2525         * jit/JIT.cpp:
2526         (JSC::JIT::privateCompileSlowCases):
2527         (JSC::JIT::privateCompile):
2528         * jit/JIT.h:
2529         (JSC::ByValCompilationInfo::ByValCompilationInfo):
2530         (ByValCompilationInfo):
2531         (JSC):
2532         (JIT):
2533         (JSC::JIT::compileGetByVal):
2534         (JSC::JIT::compilePutByVal):
2535         * jit/JITInlineMethods.h:
2536         (JSC::JIT::emitAllocateJSArray):
2537         (JSC::JIT::emitArrayProfileStoreToHoleSpecialCase):
2538         (JSC):
2539         (JSC::arrayProfileSaw):
2540         (JSC::JIT::chooseArrayMode):
2541         * jit/JITOpcodes.cpp:
2542         (JSC::JIT::emitSlow_op_get_argument_by_val):
2543         (JSC::JIT::emit_op_new_array):
2544         (JSC::JIT::emitSlow_op_new_array):
2545         * jit/JITOpcodes32_64.cpp:
2546         (JSC::JIT::emitSlow_op_get_argument_by_val):
2547         * jit/JITPropertyAccess.cpp:
2548         (JSC::JIT::emit_op_get_by_val):
2549         (JSC):
2550         (JSC::JIT::emitContiguousGetByVal):
2551         (JSC::JIT::emitArrayStorageGetByVal):
2552         (JSC::JIT::emitSlow_op_get_by_val):
2553         (JSC::JIT::emit_op_put_by_val):
2554         (JSC::JIT::emitContiguousPutByVal):
2555         (JSC::JIT::emitArrayStoragePutByVal):
2556         (JSC::JIT::emitSlow_op_put_by_val):
2557         (JSC::JIT::privateCompilePatchGetArrayLength):
2558         (JSC::JIT::privateCompileGetByVal):
2559         (JSC::JIT::privateCompilePutByVal):
2560         * jit/JITPropertyAccess32_64.cpp:
2561         (JSC::JIT::emit_op_get_by_val):
2562         (JSC):
2563         (JSC::JIT::emitContiguousGetByVal):
2564         (JSC::JIT::emitArrayStorageGetByVal):
2565         (JSC::JIT::emitSlow_op_get_by_val):
2566         (JSC::JIT::emit_op_put_by_val):
2567         (JSC::JIT::emitContiguousPutByVal):
2568         (JSC::JIT::emitArrayStoragePutByVal):
2569         (JSC::JIT::emitSlow_op_put_by_val):
2570         * jit/JITStubs.cpp:
2571         (JSC::getByVal):
2572         (JSC):
2573         (JSC::DEFINE_STUB_FUNCTION):
2574         (JSC::putByVal):
2575         * jit/JITStubs.h:
2576         * llint/LowLevelInterpreter.asm:
2577         * llint/LowLevelInterpreter32_64.asm:
2578         * llint/LowLevelInterpreter64.asm:
2579         * runtime/ArrayConventions.h:
2580         (JSC::isDenseEnoughForVector):
2581         * runtime/ArrayPrototype.cpp:
2582         (JSC):
2583         (JSC::shift):
2584         (JSC::unshift):
2585         (JSC::arrayProtoFuncPush):
2586         (JSC::arrayProtoFuncShift):
2587         (JSC::arrayProtoFuncSplice):
2588         (JSC::arrayProtoFuncUnShift):
2589         * runtime/Butterfly.h:
2590         (Butterfly):
2591         (JSC::Butterfly::fromPointer):
2592         (JSC::Butterfly::pointer):
2593         (JSC::Butterfly::publicLength):
2594         (JSC::Butterfly::vectorLength):
2595         (JSC::Butterfly::setPublicLength):
2596         (JSC::Butterfly::setVectorLength):
2597         (JSC::Butterfly::contiguous):
2598         (JSC::Butterfly::fromContiguous):
2599         * runtime/ButterflyInlineMethods.h:
2600         (JSC::Butterfly::unshift):
2601         (JSC::Butterfly::shift):
2602         * runtime/IndexingHeaderInlineMethods.h:
2603         (JSC::IndexingHeader::indexingPayloadSizeInBytes):
2604         * runtime/IndexingType.cpp: Added.
2605         (JSC):
2606         (JSC::indexingTypeToString):
2607         * runtime/IndexingType.h:
2608         (JSC):
2609         (JSC::hasContiguous):
2610         * runtime/JSArray.cpp:
2611         (JSC::JSArray::setLengthWithArrayStorage):
2612         (JSC::JSArray::setLength):
2613         (JSC):
2614         (JSC::JSArray::pop):
2615         (JSC::JSArray::push):
2616         (JSC::JSArray::shiftCountWithArrayStorage):
2617         (JSC::JSArray::shiftCountWithAnyIndexingType):
2618         (JSC::JSArray::unshiftCountWithArrayStorage):
2619         (JSC::JSArray::unshiftCountWithAnyIndexingType):
2620         (JSC::JSArray::sortNumericVector):
2621         (JSC::JSArray::sortNumeric):
2622         (JSC::JSArray::sortCompactedVector):
2623         (JSC::JSArray::sort):
2624         (JSC::JSArray::sortVector):
2625         (JSC::JSArray::fillArgList):
2626         (JSC::JSArray::copyToArguments):
2627         (JSC::JSArray::compactForSorting):
2628         * runtime/JSArray.h:
2629         (JSC::JSArray::shiftCountForShift):
2630         (JSC::JSArray::shiftCountForSplice):
2631         (JSArray):
2632         (JSC::JSArray::shiftCount):
2633         (JSC::JSArray::unshiftCountForShift):
2634         (JSC::JSArray::unshiftCountForSplice):
2635         (JSC::JSArray::unshiftCount):
2636         (JSC::JSArray::isLengthWritable):
2637         (JSC::createContiguousArrayButterfly):
2638         (JSC):
2639         (JSC::JSArray::create):
2640         (JSC::JSArray::tryCreateUninitialized):
2641         * runtime/JSGlobalObject.cpp:
2642         (JSC::JSGlobalObject::reset):
2643         (JSC):
2644         (JSC::JSGlobalObject::haveABadTime):
2645         (JSC::JSGlobalObject::visitChildren):
2646         * runtime/JSGlobalObject.h:
2647         (JSGlobalObject):
2648         (JSC::JSGlobalObject::arrayStructureWithArrayStorage):
2649         (JSC::JSGlobalObject::addressOfArrayStructureWithArrayStorage):
2650         (JSC::constructEmptyArray):
2651         * runtime/JSObject.cpp:
2652         (JSC::JSObject::visitButterfly):
2653         (JSC::JSObject::getOwnPropertySlotByIndex):
2654         (JSC::JSObject::putByIndex):
2655         (JSC::JSObject::enterDictionaryIndexingMode):
2656         (JSC::JSObject::createInitialContiguous):
2657         (JSC):
2658         (JSC::JSObject::createArrayStorage):
2659         (JSC::JSObject::convertContiguousToArrayStorage):
2660         (JSC::JSObject::ensureContiguousSlow):
2661         (JSC::JSObject::ensureArrayStorageSlow):
2662         (JSC::JSObject::ensureIndexedStorageSlow):
2663         (JSC::JSObject::ensureArrayStorageExistsAndEnterDictionaryIndexingMode):
2664         (JSC::JSObject::switchToSlowPutArrayStorage):
2665         (JSC::JSObject::setPrototype):
2666         (JSC::JSObject::deletePropertyByIndex):
2667         (JSC::JSObject::getOwnPropertyNames):
2668         (JSC::JSObject::defineOwnIndexedProperty):
2669         (JSC::JSObject::putByIndexBeyondVectorLengthContiguousWithoutAttributes):
2670         (JSC::JSObject::putByIndexBeyondVectorLength):
2671         (JSC::JSObject::putDirectIndexBeyondVectorLengthWithArrayStorage):
2672         (JSC::JSObject::putDirectIndexBeyondVectorLength):
2673         (JSC::JSObject::getNewVectorLength):
2674         (JSC::JSObject::countElementsInContiguous):
2675         (JSC::JSObject::increaseVectorLength):
2676         (JSC::JSObject::ensureContiguousLengthSlow):
2677         (JSC::JSObject::getOwnPropertyDescriptor):
2678         * runtime/JSObject.h:
2679         (JSC::JSObject::getArrayLength):
2680         (JSC::JSObject::getVectorLength):
2681         (JSC::JSObject::canGetIndexQuickly):
2682         (JSC::JSObject::getIndexQuickly):
2683         (JSC::JSObject::tryGetIndexQuickly):
2684         (JSC::JSObject::canSetIndexQuickly):
2685         (JSC::JSObject::canSetIndexQuicklyForPutDirect):
2686         (JSC::JSObject::setIndexQuickly):
2687         (JSC::JSObject::initializeIndex):
2688         (JSC::JSObject::hasSparseMap):
2689         (JSC::JSObject::inSparseIndexingMode):
2690         (JSObject):
2691         (JSC::JSObject::ensureContiguous):
2692         (JSC::JSObject::ensureIndexedStorage):
2693         (JSC::JSObject::ensureContiguousLength):
2694         (JSC::JSObject::indexingData):
2695         (JSC::JSObject::relevantLength):
2696         * runtime/JSValue.cpp:
2697         (JSC::JSValue::description):
2698         * runtime/Options.cpp:
2699         (JSC::Options::initialize):
2700         * runtime/Structure.cpp:
2701         (JSC::Structure::needsSlowPutIndexing):
2702         (JSC):
2703         (JSC::Structure::suggestedArrayStorageTransition):
2704         * runtime/Structure.h:
2705         (Structure):
2706         * runtime/StructureTransitionTable.h:
2707         (JSC::newIndexingType):
2708
2709 2012-10-09  Michael Saboff  <msaboff@apple.com>
2710
2711         After r130344, OpaqueJSString::identifier() adds wrapped String to identifier table
2712         https://bugs.webkit.org/show_bug.cgi?id=98693
2713         REGRESSION (r130344): Install failed in Install Environment
2714         <rdar://problem/12450118>
2715
2716         Reviewed by Mark Rowe.
2717
2718         Use Identifier(LChar*, length) or Identifier(UChar*, length) constructors so that we don't
2719         add the String instance in the OpaqueJSString to any identifier tables.
2720
2721         * API/OpaqueJSString.cpp:
2722         (OpaqueJSString::identifier):
2723
2724 2012-10-08  Mark Lam  <mark.lam@apple.com>
2725
2726         Renamed RegisterFile to JSStack, and removed prototype of the
2727         previously deleted Interpreter::privateExecute().
2728         https://bugs.webkit.org/show_bug.cgi?id=98717.
2729
2730         Reviewed by Filip Pizlo.
2731
2732         * CMakeLists.txt:
2733         * GNUmakefile.list.am:
2734         * JavaScriptCore.order:
2735         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
2736         * JavaScriptCore.xcodeproj/project.pbxproj:
2737         * Target.pri:
2738         * bytecode/BytecodeConventions.h:
2739         * bytecode/CodeBlock.cpp:
2740         (JSC::CodeBlock::nameForRegister):
2741         * bytecode/CodeBlock.h:
2742         (CodeBlock):
2743         * bytecode/ValueRecovery.h:
2744         (JSC::ValueRecovery::alreadyInJSStack):
2745         (JSC::ValueRecovery::alreadyInJSStackAsUnboxedInt32):
2746         (JSC::ValueRecovery::alreadyInJSStackAsUnboxedCell):
2747         (JSC::ValueRecovery::alreadyInJSStackAsUnboxedBoolean):
2748         (JSC::ValueRecovery::alreadyInJSStackAsUnboxedDouble):
2749         (JSC::ValueRecovery::displacedInJSStack):
2750         (JSC::ValueRecovery::isAlreadyInJSStack):
2751         (JSC::ValueRecovery::virtualRegister):
2752         (JSC::ValueRecovery::dump):
2753         * bytecompiler/BytecodeGenerator.cpp:
2754         (JSC::BytecodeGenerator::resolveCallee):
2755         (JSC::BytecodeGenerator::emitCall):
2756         (JSC::BytecodeGenerator::emitConstruct):
2757         * bytecompiler/BytecodeGenerator.h:
2758         (JSC::BytecodeGenerator::registerFor):
2759         * dfg/DFGAbstractState.h:
2760         (AbstractState):
2761         * dfg/DFGAssemblyHelpers.h:
2762         (JSC::DFG::AssemblyHelpers::emitGetFromCallFrameHeaderPtr):
2763         (JSC::DFG::AssemblyHelpers::emitPutToCallFrameHeader):
2764         (JSC::DFG::AssemblyHelpers::emitPutImmediateToCallFrameHeader):
2765         * dfg/DFGByteCodeParser.cpp:
2766         (JSC::DFG::ByteCodeParser::getDirect):
2767         (JSC::DFG::ByteCodeParser::findArgumentPositionForLocal):
2768         (JSC::DFG::ByteCodeParser::addCall):
2769         (JSC::DFG::ByteCodeParser::InlineStackEntry::remapOperand):
2770         (JSC::DFG::ByteCodeParser::handleInlining):
2771         (JSC::DFG::ByteCodeParser::parseBlock):
2772         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2773         * dfg/DFGGenerationInfo.h:
2774         (GenerationInfo):
2775         (JSC::DFG::GenerationInfo::needsSpill):
2776         * dfg/DFGGraph.h:
2777         * dfg/DFGJITCompiler.cpp:
2778         (JSC::DFG::JITCompiler::compileEntry):
2779         (JSC::DFG::JITCompiler::compileFunction):
2780         * dfg/DFGJITCompiler.h:
2781         (JSC::DFG::JITCompiler::beginCall):
2782         * dfg/DFGOSREntry.cpp:
2783         (JSC::DFG::prepareOSREntry):
2784         * dfg/DFGOSRExitCompiler32_64.cpp:
2785         (JSC::DFG::OSRExitCompiler::compileExit):
2786         * dfg/DFGOSRExitCompiler64.cpp:
2787         (JSC::DFG::OSRExitCompiler::compileExit):
2788         * dfg/DFGRepatch.cpp:
2789         (JSC::DFG::tryBuildGetByIDList):
2790         * dfg/DFGSpeculativeJIT.cpp:
2791         (JSC::DFG::SpeculativeJIT::compile):
2792         (JSC::DFG::SpeculativeJIT::checkArgumentTypes):
2793         (JSC::DFG::SpeculativeJIT::computeValueRecoveryFor):
2794         * dfg/DFGSpeculativeJIT.h:
2795         (SpeculativeJIT):
2796         (JSC::DFG::SpeculativeJIT::spill):
2797         * dfg/DFGSpeculativeJIT32_64.cpp:
2798         (JSC::DFG::SpeculativeJIT::emitCall):
2799         (JSC::DFG::SpeculativeJIT::compile):
2800         * dfg/DFGSpeculativeJIT64.cpp:
2801         (JSC::DFG::SpeculativeJIT::fillInteger):
2802         (JSC::DFG::SpeculativeJIT::emitCall):
2803         (JSC::DFG::SpeculativeJIT::compile):
2804         * dfg/DFGThunks.cpp:
2805         (JSC::DFG::throwExceptionFromCallSlowPathGenerator):
2806         (JSC::DFG::slowPathFor):
2807         (JSC::DFG::virtualForThunkGenerator):
2808         * dfg/DFGValueSource.cpp:
2809         (JSC::DFG::ValueSource::dump):
2810         * dfg/DFGValueSource.h:
2811         (JSC::DFG::dataFormatToValueSourceKind):
2812         (JSC::DFG::valueSourceKindToDataFormat):
2813         (JSC::DFG::isInJSStack):
2814         (JSC::DFG::ValueSource::forSpeculation):
2815         (JSC::DFG::ValueSource::isInJSStack):
2816         (JSC::DFG::ValueSource::valueRecovery):
2817         * dfg/DFGVariableEventStream.cpp:
2818         (JSC::DFG::VariableEventStream::reconstruct):
2819         * heap/Heap.cpp:
2820         (JSC::Heap::stack):
2821         (JSC::Heap::getConservativeRegisterRoots):
2822         (JSC::Heap::markRoots):
2823         * heap/Heap.h:
2824         (JSC):
2825         (Heap):
2826         * interpreter/CallFrame.cpp:
2827         (JSC::CallFrame::stack):
2828         * interpreter/CallFrame.h:
2829         (JSC::ExecState::calleeAsValue):
2830         (JSC::ExecState::callee):
2831         (JSC::ExecState::codeBlock):
2832         (JSC::ExecState::scope):
2833         (JSC::ExecState::callerFrame):
2834         (JSC::ExecState::returnPC):
2835         (JSC::ExecState::hasReturnPC):
2836         (JSC::ExecState::clearReturnPC):
2837         (JSC::ExecState::bytecodeOffsetForNonDFGCode):
2838         (JSC::ExecState::setBytecodeOffsetForNonDFGCode):
2839         (JSC::ExecState::inlineCallFrame):
2840         (JSC::ExecState::codeOriginIndexForDFG):
2841         (JSC::ExecState::currentVPC):
2842         (JSC::ExecState::setCurrentVPC):
2843         (JSC::ExecState::setCallerFrame):
2844         (JSC::ExecState::setScope):
2845         (JSC::ExecState::init):
2846         (JSC::ExecState::argumentCountIncludingThis):
2847         (JSC::ExecState::offsetFor):
2848         (JSC::ExecState::setArgumentCountIncludingThis):
2849         (JSC::ExecState::setCallee):
2850         (JSC::ExecState::setCodeBlock):
2851         (JSC::ExecState::setReturnPC):
2852         (JSC::ExecState::setInlineCallFrame):
2853         (ExecState):
2854         * interpreter/Interpreter.cpp:
2855         (JSC::Interpreter::slideRegisterWindowForCall):
2856         (JSC::eval):
2857         (JSC::loadVarargs):
2858         (JSC::Interpreter::dumpRegisters):
2859         (JSC::Interpreter::throwException):
2860         (JSC::Interpreter::execute):
2861         (JSC::Interpreter::executeCall):
2862         (JSC::Interpreter::executeConstruct):
2863         (JSC::Interpreter::prepareForRepeatCall):
2864         (JSC::Interpreter::endRepeatCall):
2865         * interpreter/Interpreter.h:
2866         (JSC::Interpreter::stack):
2867         (Interpreter):
2868         (JSC::Interpreter::execute):
2869         (JSC):
2870         * interpreter/JSStack.cpp: Copied from Source/JavaScriptCore/interpreter/RegisterFile.cpp.
2871         (JSC::stackStatisticsMutex):
2872         (JSC::JSStack::~JSStack):
2873         (JSC::JSStack::growSlowCase):
2874         (JSC::JSStack::gatherConservativeRoots):
2875         (JSC::JSStack::releaseExcessCapacity):
2876         (JSC::JSStack::initializeThreading):
2877         (JSC::JSStack::committedByteCount):
2878         (JSC::JSStack::addToCommittedByteCount):
2879         * interpreter/JSStack.h: Copied from Source/JavaScriptCore/interpreter/RegisterFile.h.
2880         (JSStack):
2881         (JSC::JSStack::JSStack):
2882         (JSC::JSStack::shrink):
2883         (JSC::JSStack::grow):
2884         * interpreter/RegisterFile.cpp: Removed.
2885         * interpreter/RegisterFile.h: Removed.
2886         * interpreter/VMInspector.cpp:
2887         (JSC::VMInspector::dumpFrame):
2888         * jit/JIT.cpp:
2889         (JSC::JIT::JIT):
2890         (JSC::JIT::privateCompile):
2891         * jit/JIT.h:
2892         (JSC):
2893         (JIT):
2894         * jit/JITCall.cpp:
2895         (JSC::JIT::compileLoadVarargs):
2896         (JSC::JIT::compileCallEval):
2897         (JSC::JIT::compileCallEvalSlowCase):
2898         (JSC::JIT::compileOpCall):
2899         * jit/JITCall32_64.cpp:
2900         (JSC::JIT::emit_op_ret):
2901         (JSC::JIT::emit_op_ret_object_or_this):
2902         (JSC::JIT::compileLoadVarargs):
2903         (JSC::JIT::compileCallEval):
2904         (JSC::JIT::compileCallEvalSlowCase):
2905         (JSC::JIT::compileOpCall):
2906         * jit/JITCode.h:
2907         (JSC):
2908         (JSC::JITCode::execute):
2909         * jit/JITInlineMethods.h:
2910         (JSC::JIT::emitPutToCallFrameHeader):
2911         (JSC::JIT::emitPutCellToCallFrameHeader):
2912         (JSC::JIT::emitPutIntToCallFrameHeader):
2913         (JSC::JIT::emitPutImmediateToCallFrameHeader):
2914         (JSC::JIT::emitGetFromCallFrameHeaderPtr):
2915         (JSC::JIT::emitGetFromCallFrameHeader32):
2916         (JSC::JIT::updateTopCallFrame):
2917         (JSC::JIT::unmap):
2918         * jit/JITOpcodes.cpp:
2919         (JSC::JIT::privateCompileCTIMachineTrampolines):
2920         (JSC::JIT::privateCompileCTINativeCall):
2921         (JSC::JIT::emit_op_end):
2922         (JSC::JIT::emit_op_ret):
2923         (JSC::JIT::emit_op_ret_object_or_this):
2924         (JSC::JIT::emit_op_create_this):
2925         (JSC::JIT::emit_op_get_arguments_length):
2926         (JSC::JIT::emit_op_get_argument_by_val):
2927         (JSC::JIT::emit_op_resolve_global_dynamic):
2928         * jit/JITOpcodes32_64.cpp:
2929         (JSC::JIT::privateCompileCTIMachineTrampolines):
2930         (JSC::JIT::privateCompileCTINativeCall):
2931         (JSC::JIT::emit_op_end):
2932         (JSC::JIT::emit_op_create_this):
2933         (JSC::JIT::emit_op_get_arguments_length):
2934         (JSC::JIT::emit_op_get_argument_by_val):
2935         * jit/JITPropertyAccess.cpp:
2936         (JSC::JIT::emit_op_get_scoped_var):
2937         (JSC::JIT::emit_op_put_scoped_var):
2938         * jit/JITPropertyAccess32_64.cpp:
2939         (JSC::JIT::emit_op_get_scoped_var):
2940         (JSC::JIT::emit_op_put_scoped_var):
2941         * jit/JITStubs.cpp:
2942         (JSC::ctiTrampoline):
2943         (JSC::JITThunks::JITThunks):
2944         (JSC):
2945         (JSC::DEFINE_STUB_FUNCTION):
2946         * jit/JITStubs.h:
2947         (JSC):
2948         (JITStackFrame):
2949         * jit/JSInterfaceJIT.h:
2950         * jit/SpecializedThunkJIT.h:
2951         (JSC::SpecializedThunkJIT::SpecializedThunkJIT):
2952         (JSC::SpecializedThunkJIT::returnJSValue):
2953         (JSC::SpecializedThunkJIT::returnDouble):
2954         (JSC::SpecializedThunkJIT::returnInt32):
2955         (JSC::SpecializedThunkJIT::returnJSCell):
2956         * llint/LLIntData.cpp:
2957         (JSC::LLInt::Data::performAssertions):
2958         * llint/LLIntOffsetsExtractor.cpp:
2959         * llint/LLIntSlowPaths.cpp:
2960         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
2961         (JSC::LLInt::genericCall):
2962         * llint/LLIntSlowPaths.h:
2963         (LLInt):
2964         * llint/LowLevelInterpreter.asm:
2965         * runtime/Arguments.cpp:
2966         (JSC::Arguments::tearOffForInlineCallFrame):
2967         * runtime/CommonSlowPaths.h:
2968         (JSC::CommonSlowPaths::arityCheckFor):
2969         * runtime/InitializeThreading.cpp:
2970         (JSC::initializeThreadingOnce):
2971         * runtime/JSActivation.cpp:
2972         (JSC::JSActivation::visitChildren):
2973         * runtime/JSGlobalObject.cpp:
2974         (JSC::JSGlobalObject::globalExec):
2975         * runtime/JSGlobalObject.h:
2976         (JSC):
2977         (JSGlobalObject):
2978         * runtime/JSLock.cpp:
2979         (JSC):
2980         * runtime/JSVariableObject.h:
2981         (JSVariableObject):
2982         * runtime/MemoryStatistics.cpp:
2983         (JSC::globalMemoryStatistics):
2984
2985 2012-10-08  Kiran Muppala  <cmuppala@apple.com>
2986
2987         Throttle DOM timers on hidden pages.
2988         https://bugs.webkit.org/show_bug.cgi?id=98474
2989
2990         Reviewed by Maciej Stachowiak.
2991
2992         Add HIDDEN_PAGE_DOM_TIMER_THROTTLING feature define.
2993
2994         * Configurations/FeatureDefines.xcconfig:
2995
2996 2012-10-08  Michael Saboff  <msaboff@apple.com>
2997
2998         After r130344, OpaqueJSString() creates an empty string which should be a null string
2999         https://bugs.webkit.org/show_bug.cgi?id=98417
3000
3001         Reviewed by Sam Weinig.
3002
3003         Changed create() of a null string to return 0. This is the same behavior as before r130344.
3004
3005         * API/OpaqueJSString.cpp:
3006         (OpaqueJSString::create):
3007
3008 2012-10-07  Caio Marcelo de Oliveira Filho  <caio.oliveira@openbossa.org>
3009
3010         Rename first/second to key/value in HashMap iterators
3011         https://bugs.webkit.org/show_bug.cgi?id=82784
3012
3013         Reviewed by Eric Seidel.
3014
3015         * API/JSCallbackObject.h:
3016         (JSC::JSCallbackObjectData::JSPrivatePropertyMap::getPrivateProperty):
3017         (JSC::JSCallbackObjectData::JSPrivatePropertyMap::setPrivateProperty):
3018         (JSC::JSCallbackObjectData::JSPrivatePropertyMap::visitChildren):
3019         * API/JSCallbackObjectFunctions.h:
3020         (JSC::::getOwnNonIndexPropertyNames):
3021         * API/JSClassRef.cpp:
3022         (OpaqueJSClass::~OpaqueJSClass):
3023         (OpaqueJSClassContextData::OpaqueJSClassContextData):
3024         (OpaqueJSClass::contextData):
3025         * bytecode/CodeBlock.cpp:
3026         (JSC::CodeBlock::dump):
3027         (JSC::EvalCodeCache::visitAggregate):
3028         (JSC::CodeBlock::nameForRegister):
3029         * bytecode/JumpTable.h:
3030         (JSC::StringJumpTable::offsetForValue):
3031         (JSC::StringJumpTable::ctiForValue):
3032         * bytecode/LazyOperandValueProfile.cpp:
3033         (JSC::LazyOperandValueProfileParser::getIfPresent):
3034         * bytecode/SamplingTool.cpp:
3035         (JSC::SamplingTool::dump):
3036         * bytecompiler/BytecodeGenerator.cpp:
3037         (JSC::BytecodeGenerator::addVar):
3038         (JSC::BytecodeGenerator::addGlobalVar):
3039         (JSC::BytecodeGenerator::addConstant):
3040         (JSC::BytecodeGenerator::addConstantValue):
3041         (JSC::BytecodeGenerator::emitLoad):
3042         (JSC::BytecodeGenerator::addStringConstant):
3043         (JSC::BytecodeGenerator::emitLazyNewFunction):
3044         * bytecompiler/NodesCodegen.cpp:
3045         (JSC::PropertyListNode::emitBytecode):
3046         * debugger/Debugger.cpp:
3047         * dfg/DFGArgumentsSimplificationPhase.cpp:
3048         (JSC::DFG::ArgumentsSimplificationPhase::run):
3049         (JSC::DFG::ArgumentsSimplificationPhase::observeBadArgumentsUse):
3050         (JSC::DFG::ArgumentsSimplificationPhase::observeProperArgumentsUse):
3051         (JSC::DFG::ArgumentsSimplificationPhase::isOKToOptimize):
3052         (JSC::DFG::ArgumentsSimplificationPhase::removeArgumentsReferencingPhantomChild):
3053         * dfg/DFGAssemblyHelpers.cpp:
3054         (JSC::DFG::AssemblyHelpers::decodedCodeMapFor):
3055         * dfg/DFGByteCodeCache.h:
3056         (JSC::DFG::ByteCodeCache::~ByteCodeCache):
3057         (JSC::DFG::ByteCodeCache::get):
3058         * dfg/DFGByteCodeParser.cpp:
3059         (JSC::DFG::ByteCodeParser::cellConstant):
3060         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
3061         * dfg/DFGStructureCheckHoistingPhase.cpp:
3062         (JSC::DFG::StructureCheckHoistingPhase::run):
3063         (JSC::DFG::StructureCheckHoistingPhase::noticeStructureCheck):
3064         (JSC::DFG::StructureCheckHoistingPhase::noticeClobber):
3065         * heap/Heap.cpp:
3066         (JSC::Heap::markProtectedObjects):
3067         * heap/Heap.h:
3068         (JSC::Heap::forEachProtectedCell):
3069         * heap/JITStubRoutineSet.cpp:
3070         (JSC::JITStubRoutineSet::markSlow):
3071         (JSC::JITStubRoutineSet::deleteUnmarkedJettisonedStubRoutines):
3072         * heap/SlotVisitor.cpp:
3073         (JSC::SlotVisitor::internalAppend):
3074         * heap/Weak.h:
3075         (JSC::weakRemove):
3076         * jit/JIT.cpp:
3077         (JSC::JIT::privateCompile):
3078         * jit/JITStubs.cpp:
3079         (JSC::JITThunks::ctiStub):
3080         * parser/Parser.cpp:
3081         (JSC::::parseStrictObjectLiteral):
3082         * profiler/Profile.cpp:
3083         (JSC::functionNameCountPairComparator):
3084         (JSC::Profile::debugPrintDataSampleStyle):
3085         * runtime/Identifier.cpp:
3086         (JSC::Identifier::add):
3087         * runtime/JSActivation.cpp:
3088         (JSC::JSActivation::getOwnNonIndexPropertyNames):
3089         (JSC::JSActivation::symbolTablePutWithAttributes):
3090         * runtime/JSArray.cpp:
3091         (JSC::JSArray::setLength):
3092         * runtime/JSObject.cpp:
3093         (JSC::JSObject::getOwnPropertySlotByIndex):
3094         (JSC::JSObject::enterDictionaryIndexingModeWhenArrayStorageAlreadyExists):
3095         (JSC::JSObject::deletePropertyByIndex):
3096         (JSC::JSObject::getOwnPropertyNames):
3097         (JSC::JSObject::defineOwnIndexedProperty):
3098         (JSC::JSObject::attemptToInterceptPutByIndexOnHoleForPrototype):
3099         (JSC::JSObject::putByIndexBeyondVectorLengthWithArrayStorage):
3100         (JSC::JSObject::putDirectIndexBeyondVectorLengthWithArrayStorage):
3101         (JSC::JSObject::getOwnPropertyDescriptor):
3102         * runtime/JSSymbolTableObject.cpp:
3103         (JSC::JSSymbolTableObject::getOwnNonIndexPropertyNames):
3104         * runtime/JSSymbolTableObject.h:
3105         (JSC::symbolTableGet):
3106         (JSC::symbolTablePut):
3107         (JSC::symbolTablePutWithAttributes):
3108         * runtime/RegExpCache.cpp:
3109         (JSC::RegExpCache::invalidateCode):
3110         * runtime/SparseArrayValueMap.cpp:
3111         (JSC::SparseArrayValueMap::putEntry):
3112         (JSC::SparseArrayValueMap::putDirect):
3113         (JSC::SparseArrayValueMap::visitChildren):
3114         * runtime/WeakGCMap.h:
3115         (JSC::WeakGCMap::clear):
3116         (JSC::WeakGCMap::set):
3117         * tools/ProfileTreeNode.h:
3118         (JSC::ProfileTreeNode::sampleChild):
3119         (JSC::ProfileTreeNode::childCount):
3120         (JSC::ProfileTreeNode::dumpInternal):
3121         (JSC::ProfileTreeNode::compareEntries):
3122
3123 2012-10-05  Mark Hahnenberg  <mhahnenberg@apple.com>
3124
3125         JSC should have a way to gather and log Heap memory use and pause times
3126         https://bugs.webkit.org/show_bug.cgi?id=98431
3127
3128         Reviewed by Geoffrey Garen.
3129
3130         In order to improve our infrastructure for benchmark-driven development, we should 
3131         have a centralized method of gathering and logging various statistics about the state 
3132         of the JS heap. This would allow us to create and to use other tools to analyze the 
3133         output of the VM after running various workloads.
3134
3135         The first two statistics that might be interesting is memory use by JSC and GC pause 
3136         times. We can control whether this recording happens through the use of the Options 
3137         class, allowing us to either use environment variables or command line flags.
3138
3139         * JavaScriptCore.xcodeproj/project.pbxproj:
3140         * heap/Heap.cpp:
3141         (JSC::Heap::collect): If we finish a collection and are still over our set GC heap size, 
3142         we end the program immediately and report an error. Also added recording of pause times.
3143         * heap/Heap.h:
3144         (Heap):
3145         (JSC::Heap::shouldCollect): When we set a specific GC heap size through Options, we 
3146         ignore all other heuristics on when we should collect and instead only ask if we're 
3147         greater than the amount specified in the Option value. This allows us to view time/memory 
3148         tradeoffs more clearly.
3149         * heap/HeapStatistics.cpp: Added.
3150         (JSC):
3151         (JSC::HeapStatistics::initialize):
3152         (JSC::HeapStatistics::recordGCPauseTime):
3153         (JSC::HeapStatistics::logStatistics):
3154         (JSC::HeapStatistics::exitWithFailure):
3155         (JSC::HeapStatistics::reportSuccess):
3156         (JSC::HeapStatistics::parseMemoryAmount):
3157         (StorageStatistics):
3158         (JSC::StorageStatistics::StorageStatistics):
3159         (JSC::StorageStatistics::operator()):
3160         (JSC::StorageStatistics::objectWithOutOfLineStorageCount):
3161         (JSC::StorageStatistics::objectCount):
3162         (JSC::StorageStatistics::storageSize):
3163         (JSC::StorageStatistics::storageCapacity):
3164         (JSC::HeapStatistics::showObjectStatistics): Moved the old showHeapStatistics (renamed to showObjectStatistics) 
3165         to try to start collecting our various memory statistics gathering/reporting mechanisms scattered throughout the 
3166         codebase into one place.
3167         * heap/HeapStatistics.h: Added.
3168         (JSC):
3169         (HeapStatistics):
3170         * jsc.cpp:
3171         (main):
3172         * runtime/InitializeThreading.cpp:
3173         (JSC::initializeThreadingOnce): We need to initialize our data structures for recording 
3174         statistics if necessary.
3175         * runtime/Options.cpp: Add new Options for the various types of statistics we'll be gathering.
3176         (JSC::parse):
3177         (JSC):
3178         (JSC::Options::initialize): Initialize the various new options using environment variables.
3179         (JSC::Options::dumpOption):
3180         * runtime/Options.h:
3181         (JSC):
3182
3183 2012-10-04  Rik Cabanier  <cabanier@adobe.com>
3184
3185         Turn Compositing on by default in WebKit build
3186         https://bugs.webkit.org/show_bug.cgi?id=98315
3187
3188         Reviewed by Simon Fraser.
3189
3190         enable -webkit-blend-mode on trunk.
3191
3192         * Configurations/FeatureDefines.xcconfig:
3193
3194 2012-10-04  Michael Saboff  <msaboff@apple.com>
3195
3196         Crash in Safari at com.apple.JavaScriptCore: WTF::StringImpl::is8Bit const + 12
3197         https://bugs.webkit.org/show_bug.cgi?id=98433
3198
3199         Reviewed by Jessie Berlin.
3200
3201         The problem is due to a String with a null StringImpl (i.e. a null string).
3202         Added a length check before the is8Bit() check since length() checks for a null StringImpl.  Changed the
3203         characters16() call to characters() since it can handle a null StringImpl as well.
3204
3205         * API/JSValueRef.cpp:
3206         (JSValueMakeFromJSONString):
3207
3208 2012-10-04  Benjamin Poulain  <bpoulain@apple.com>
3209
3210         Use copyLCharsFromUCharSource() for IdentifierLCharFromUCharTranslator translation
3211         https://bugs.webkit.org/show_bug.cgi?id=98335
3212
3213         Reviewed by Michael Saboff.
3214
3215         Michael Saboff added an optimized version of UChar->LChar conversion in r125846.
3216         Use this function in JSC::Identifier.
3217
3218         * runtime/Identifier.cpp:
3219         (JSC::IdentifierLCharFromUCharTranslator::translate):
3220
3221 2012-10-04  Michael Saboff  <msaboff@apple.com>
3222
3223         After r130344, OpaqueJSString() creates a empty string which should be a null string
3224         https://bugs.webkit.org/show_bug.cgi?id=98417
3225
3226         Reviewed by Alexey Proskuryakov.
3227
3228         Removed the setting of enclosed string to an empty string from default constructor.
3229         Before changeset r130344, the semantic was the default constructor produced a null
3230         string.
3231
3232         * API/OpaqueJSString.h:
3233         (OpaqueJSString::OpaqueJSString):
3234
3235 2012-10-04  Csaba Osztrogon√°c  <ossy@webkit.org>
3236
3237         [Qt] Add missing LLInt dependencies to the build system
3238         https://bugs.webkit.org/show_bug.cgi?id=98394
3239
3240         Reviewed by Geoffrey Garen.
3241
3242         * DerivedSources.pri:
3243         * LLIntOffsetsExtractor.pro:
3244
3245 2012-10-03  Geoffrey Garen  <ggaren@apple.com>
3246
3247         Next step toward fixing Windows: add new symbol.
3248
3249         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
3250
3251 2012-10-03  Geoffrey Garen  <ggaren@apple.com>
3252
3253         First step toward fixing Windows: remove old symbol.
3254
3255         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
3256
3257 2012-10-03  Geoffrey Garen  <ggaren@apple.com>
3258
3259         Removed the assumption that "final" objects have a fixed number of inline slots
3260         https://bugs.webkit.org/show_bug.cgi?id=98332
3261
3262         Reviewed by Filip Pizlo.
3263
3264         This is a step toward object size inference.
3265
3266         I replaced the inline storage capacity constant with a data member per
3267         structure, set the the maximum supported value for the constant to 100,
3268         then fixed what broke. (Note that even though this patch increases the
3269         theoretical maximum inline capacity, it doesn't change any actual inline
3270         capacity.)
3271
3272         * dfg/DFGSpeculativeJIT32_64.cpp:
3273         (JSC::DFG::SpeculativeJIT::compile):
3274         * dfg/DFGSpeculativeJIT64.cpp:
3275         (JSC::DFG::SpeculativeJIT::compile):
3276         * jit/JITPropertyAccess.cpp:
3277         (JSC::JIT::compileGetDirectOffset): These functions just get a rename:
3278         the constant they need is the first out of line offset along the offset
3279         number line, which is not necessarily the same thing (and is, in this
3280         patch, never the same thing) as the inline capacity of any given object.
3281
3282         (JSC::JIT::emit_op_get_by_pname):
3283         * jit/JITPropertyAccess32_64.cpp: This function changes functionality,
3284         since it needs to convert from the abstract offset number line to an
3285         actual offset in memory, and it can't assume that inline and out-of-line
3286         offsets are contiguous on the number line.
3287
3288         (JSC::JIT::compileGetDirectOffset): Updated for rename.
3289
3290         (JSC::JIT::emit_op_get_by_pname): Same as emit_op_get_by_pname above.
3291
3292         * llint/LowLevelInterpreter.asm: Updated to mirror changes in PropertyOffset.h,
3293         since we duplicate values from there.
3294
3295         * llint/LowLevelInterpreter32_64.asm:
3296         * llint/LowLevelInterpreter64.asm: Just like the JIT, most things are just
3297         renames, and get_by_pname changes to do more math. I also standardized
3298         offset calculations to use a hard-coded "-2", to match the JIT. This
3299         isn't really better, but it makes global search and replace easier,
3300         should we choose to refactor this code not to hard-code constants.
3301
3302         I also renamed loadPropertyAtVariableOffsetKnownNotFinal to
3303         loadPropertyAtVariableOffsetKnownNotInline in order to sever the assumption
3304         that inline capacity is tied to object type, and I changed the 64bit LLInt
3305         to use this -- not using this previously seems to have been an oversight.
3306
3307         * runtime/JSObject.cpp:
3308         (JSC::JSObject::visitChildren):
3309         (JSC::JSFinalObject::visitChildren):
3310         * runtime/JSObject.h:
3311         (JSC::JSObject::offsetForLocation):
3312         (JSNonFinalObject):
3313         (JSC::JSFinalObject::createStructure):
3314         (JSFinalObject):
3315         (JSC::JSFinalObject::finishCreation): Updated for above changes.
3316
3317         * runtime/JSPropertyNameIterator.h:
3318         (JSPropertyNameIterator):
3319         (JSC::JSPropertyNameIterator::finishCreation): Store the inline capacity
3320         of our object, since it's not a constant.
3321
3322         (JSC::JSPropertyNameIterator::getOffset): Removed. This function was
3323         wrong. Luckily, it was also unused, since the C++ interpreter is gone.
3324
3325         * runtime/PropertyMapHashTable.h:
3326         (PropertyTable): Use a helper function instead of hard-coding assumptions
3327         about object types.
3328
3329         (JSC::PropertyTable::nextOffset):
3330         * runtime/PropertyOffset.h:
3331         (JSC):
3332         (JSC::checkOffset):
3333         (JSC::validateOffset):
3334         (JSC::isInlineOffset):
3335         (JSC::numberOfSlotsForLastOffset):
3336         (JSC::propertyOffsetFor): Refactored these functions to take inline capacity
3337         as an argument, since it's not fixed at compile time anymore.
3338
3339         * runtime/Structure.cpp:
3340         (JSC::Structure::Structure):
3341         (JSC::Structure::flattenDictionaryStructure):
3342         (JSC::Structure::putSpecificValue):
3343         * runtime/Structure.h:
3344         (Structure):
3345         (JSC::Structure::outOfLineCapacity):
3346         (JSC::Structure::hasInlineStorage):
3347         (JSC::Structure::inlineCapacity):
3348         (JSC::Structure::inlineSize):
3349         (JSC::Structure::firstValidOffset):
3350         (JSC::Structure::lastValidOffset):
3351         (JSC::Structure::create): Removed some hard-coded assumptions about inline
3352         capacity and object type, and replaced with more liberal use of helper functions.
3353
3354 2012-10-03  Michael Saboff  <msaboff@apple.com>
3355
3356         OpaqueJSString doesn't optimally handle 8 bit strings
3357         https://bugs.webkit.org/show_bug.cgi?id=98300
3358
3359         Reviewed by Geoffrey Garen.
3360
3361         Change OpaqueJSString to store and manage a String instead of a UChar buffer.
3362         The member string is a copy of any string used during creation.
3363
3364         * API/OpaqueJSString.cpp:
3365         (OpaqueJSString::create):
3366         (OpaqueJSString::identifier):
3367         * API/OpaqueJSString.h:
3368         (OpaqueJSString::characters):
3369         (OpaqueJSString::length):
3370         (OpaqueJSString::string):
3371         (OpaqueJSString::OpaqueJSString):
3372         (OpaqueJSString):
3373
3374 2012-10-03  Filip Pizlo  <fpizlo@apple.com>
3375
3376         Array.splice should be fast when it is used to remove elements other than the very first
3377         https://bugs.webkit.org/show_bug.cgi?id=98236
3378
3379         Reviewed by Michael Saboff.