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