ff4a4198a9d81f5df0e7aa7ab00edb04520bab5c
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2012-06-07  Gavin Barraclough  <barraclough@apple.com>
2
3         Math.pow on iOS does not support denormal numbers.
4         https://bugs.webkit.org/show_bug.cgi?id=88592
5
6         Reviewed by Filip Pizlo.
7
8         Import an implementation from fdlibm, detect cases where it is safe to use the system
9         implementation & where we should fall back to fdlibm.
10
11         * runtime/MathObject.cpp:
12         (JSC::isDenormal):
13         (JSC::isEdgeCase):
14         (JSC::mathPow):
15             - On iOS, detect cases where denormal support may be required & use fdlibm in these cases.
16         (JSC::mathProtoFuncPow):
17             - Changed to use mathPow.
18         (JSC::fdlibmScalbn):
19         (JSC::fdlibmPow):
20             - These functions imported from fdlibm; original style retained to ease future merging.
21
22 2012-06-07  Patrick Gansterer  <paroga@webkit.org>
23
24         Unreviewed. Build fix for !ENABLE(JIT) after r119441.
25
26         * interpreter/Interpreter.cpp:
27         (JSC::Interpreter::privateExecute):
28
29 2012-06-07  Andy Wingo  <wingo@igalia.com>
30
31         Unreviewed build fix after r119593.
32
33         * llint/LLIntOfflineAsmConfig.h (OFFLINE_ASM_GLOBAL_LABEL): Fix
34         uses of "name" to be "label", the macro's parameter.  Otherwise we
35         serialize mentions of the literal symbol "name" into the objcode.
36         Causes a build error using GNU ld (not gold).
37
38 2012-06-06  Ryosuke Niwa  <rniwa@webkit.org>
39
40         Chromium build fix attempt. Why do we need to list these files in gyp!?
41
42         * JavaScriptCore.gypi:
43
44 2012-06-06  Filip Pizlo  <fpizlo@apple.com>
45
46         PredictedType should be called SpeculatedType
47         https://bugs.webkit.org/show_bug.cgi?id=88477
48
49         Rubber stamped by Gavin Barraclough.
50
51         * CMakeLists.txt:
52         * GNUmakefile.list.am:
53         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
54         * JavaScriptCore.xcodeproj/project.pbxproj:
55         * Target.pri:
56         * bytecode/CodeBlock.cpp:
57         (JSC::CodeBlock::shouldOptimizeNow):
58         (JSC::CodeBlock::dumpValueProfiles):
59         * bytecode/CodeBlock.h:
60         (JSC::CodeBlock::valueProfilePredictionForBytecodeOffset):
61         * bytecode/LazyOperandValueProfile.cpp:
62         (JSC::LazyOperandValueProfileParser::prediction):
63         * bytecode/LazyOperandValueProfile.h:
64         (LazyOperandValueProfileParser):
65         * bytecode/PredictedType.cpp: Removed.
66         * bytecode/PredictedType.h: Removed.
67         * bytecode/SpeculatedType.cpp: Copied from Source/JavaScriptCore/bytecode/PredictedType.cpp.
68         (JSC::speculationToString):
69         (JSC::speculationToAbbreviatedString):
70         (JSC::speculationFromClassInfo):
71         (JSC::speculationFromStructure):
72         (JSC::speculationFromCell):
73         (JSC::speculationFromValue):
74         * bytecode/SpeculatedType.h: Copied from Source/JavaScriptCore/bytecode/PredictedType.h.
75         (JSC):
76         (JSC::isAnySpeculation):
77         (JSC::isCellSpeculation):
78         (JSC::isObjectSpeculation):
79         (JSC::isFinalObjectSpeculation):
80         (JSC::isFinalObjectOrOtherSpeculation):
81         (JSC::isFixedIndexedStorageObjectSpeculation):
82         (JSC::isStringSpeculation):
83         (JSC::isArraySpeculation):
84         (JSC::isFunctionSpeculation):
85         (JSC::isInt8ArraySpeculation):
86         (JSC::isInt16ArraySpeculation):
87         (JSC::isInt32ArraySpeculation):
88         (JSC::isUint8ArraySpeculation):
89         (JSC::isUint8ClampedArraySpeculation):
90         (JSC::isUint16ArraySpeculation):
91         (JSC::isUint32ArraySpeculation):
92         (JSC::isFloat32ArraySpeculation):
93         (JSC::isFloat64ArraySpeculation):
94         (JSC::isArgumentsSpeculation):
95         (JSC::isActionableIntMutableArraySpeculation):
96         (JSC::isActionableFloatMutableArraySpeculation):
97         (JSC::isActionableTypedMutableArraySpeculation):
98         (JSC::isActionableMutableArraySpeculation):
99         (JSC::isActionableArraySpeculation):
100         (JSC::isArrayOrOtherSpeculation):
101         (JSC::isMyArgumentsSpeculation):
102         (JSC::isInt32Speculation):
103         (JSC::isDoubleRealSpeculation):
104         (JSC::isDoubleSpeculation):
105         (JSC::isNumberSpeculation):
106         (JSC::isBooleanSpeculation):
107         (JSC::isOtherSpeculation):
108         (JSC::isEmptySpeculation):
109         (JSC::mergeSpeculations):
110         (JSC::mergeSpeculation):
111         * bytecode/StructureSet.h:
112         (JSC::StructureSet::speculationFromStructures):
113         * bytecode/ValueProfile.h:
114         (JSC::ValueProfileBase::ValueProfileBase):
115         (JSC::ValueProfileBase::dump):
116         (JSC::ValueProfileBase::computeUpdatedPrediction):
117         (ValueProfileBase):
118         * dfg/DFGAbstractState.cpp:
119         (JSC::DFG::AbstractState::initialize):
120         (JSC::DFG::AbstractState::execute):
121         (JSC::DFG::AbstractState::mergeStateAtTail):
122         * dfg/DFGAbstractState.h:
123         (JSC::DFG::AbstractState::speculateInt32Unary):
124         (JSC::DFG::AbstractState::speculateNumberUnary):
125         (JSC::DFG::AbstractState::speculateBooleanUnary):
126         (JSC::DFG::AbstractState::speculateInt32Binary):
127         (JSC::DFG::AbstractState::speculateNumberBinary):
128         * dfg/DFGAbstractValue.h:
129         (JSC::DFG::StructureAbstractValue::filter):
130         (JSC::DFG::StructureAbstractValue::speculationFromStructures):
131         (JSC::DFG::AbstractValue::AbstractValue):
132         (JSC::DFG::AbstractValue::clear):
133         (JSC::DFG::AbstractValue::isClear):
134         (JSC::DFG::AbstractValue::makeTop):
135         (JSC::DFG::AbstractValue::clobberStructures):
136         (JSC::DFG::AbstractValue::isTop):
137         (JSC::DFG::AbstractValue::set):
138         (JSC::DFG::AbstractValue::merge):
139         (JSC::DFG::AbstractValue::filter):
140         (JSC::DFG::AbstractValue::validateIgnoringValue):
141         (JSC::DFG::AbstractValue::validate):
142         (JSC::DFG::AbstractValue::checkConsistency):
143         (JSC::DFG::AbstractValue::dump):
144         (AbstractValue):
145         * dfg/DFGArgumentPosition.h:
146         (JSC::DFG::ArgumentPosition::ArgumentPosition):
147         (JSC::DFG::ArgumentPosition::mergeArgumentAwareness):
148         (JSC::DFG::ArgumentPosition::prediction):
149         (ArgumentPosition):
150         * dfg/DFGArgumentsSimplificationPhase.cpp:
151         (JSC::DFG::ArgumentsSimplificationPhase::run):
152         * dfg/DFGByteCodeParser.cpp:
153         (ByteCodeParser):
154         (JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
155         (JSC::DFG::ByteCodeParser::getLocal):
156         (JSC::DFG::ByteCodeParser::getArgument):
157         (JSC::DFG::ByteCodeParser::addCall):
158         (JSC::DFG::ByteCodeParser::getSpeculationWithoutOSRExit):
159         (JSC::DFG::ByteCodeParser::getSpeculation):
160         (InlineStackEntry):
161         (JSC::DFG::ByteCodeParser::handleCall):
162         (JSC::DFG::ByteCodeParser::handleIntrinsic):
163         (JSC::DFG::ByteCodeParser::handleGetById):
164         (JSC::DFG::ByteCodeParser::parseBlock):
165         (JSC::DFG::ByteCodeParser::fixVariableAccessSpeculations):
166         (JSC::DFG::ByteCodeParser::parse):
167         * dfg/DFGCSEPhase.cpp:
168         (JSC::DFG::CSEPhase::getIndexedPropertyStorageLoadElimination):
169         (JSC::DFG::CSEPhase::performNodeCSE):
170         * dfg/DFGConstantFoldingPhase.cpp:
171         (JSC::DFG::ConstantFoldingPhase::run):
172         * dfg/DFGFixupPhase.cpp:
173         (JSC::DFG::FixupPhase::fixupNode):
174         (JSC::DFG::FixupPhase::fixDoubleEdge):
175         * dfg/DFGGraph.cpp:
176         (JSC::DFG::Graph::nameOfVariableAccessData):
177         (JSC::DFG::Graph::dump):
178         (JSC::DFG::Graph::predictArgumentTypes):
179         * dfg/DFGGraph.h:
180         (JSC::DFG::Graph::getJSConstantSpeculation):
181         (JSC::DFG::Graph::isPredictedNumerical):
182         (JSC::DFG::Graph::byValIsPure):
183         * dfg/DFGJITCompiler.h:
184         (JSC::DFG::JITCompiler::getSpeculation):
185         * dfg/DFGNode.h:
186         (JSC::DFG::Node::Node):
187         (JSC::DFG::Node::getHeapPrediction):
188         (JSC::DFG::Node::predictHeap):
189         (JSC::DFG::Node::prediction):
190         (JSC::DFG::Node::predict):
191         (JSC::DFG::Node::shouldSpeculateInteger):
192         (JSC::DFG::Node::shouldSpeculateDouble):
193         (JSC::DFG::Node::shouldSpeculateNumber):
194         (JSC::DFG::Node::shouldSpeculateBoolean):
195         (JSC::DFG::Node::shouldSpeculateFinalObject):
196         (JSC::DFG::Node::shouldSpeculateFinalObjectOrOther):
197         (JSC::DFG::Node::shouldSpeculateArray):
198         (JSC::DFG::Node::shouldSpeculateArguments):
199         (JSC::DFG::Node::shouldSpeculateInt8Array):
200         (JSC::DFG::Node::shouldSpeculateInt16Array):
201         (JSC::DFG::Node::shouldSpeculateInt32Array):
202         (JSC::DFG::Node::shouldSpeculateUint8Array):
203         (JSC::DFG::Node::shouldSpeculateUint8ClampedArray):
204         (JSC::DFG::Node::shouldSpeculateUint16Array):
205         (JSC::DFG::Node::shouldSpeculateUint32Array):
206         (JSC::DFG::Node::shouldSpeculateFloat32Array):
207         (JSC::DFG::Node::shouldSpeculateFloat64Array):
208         (JSC::DFG::Node::shouldSpeculateArrayOrOther):
209         (JSC::DFG::Node::shouldSpeculateObject):
210         (JSC::DFG::Node::shouldSpeculateCell):
211         (Node):
212         * dfg/DFGPredictionPropagationPhase.cpp:
213         (JSC::DFG::PredictionPropagationPhase::setPrediction):
214         (JSC::DFG::PredictionPropagationPhase::mergePrediction):
215         (JSC::DFG::PredictionPropagationPhase::propagate):
216         (JSC::DFG::PredictionPropagationPhase::doRoundOfDoubleVoting):
217         * dfg/DFGSpeculativeJIT.cpp:
218         (JSC::DFG::SpeculativeJIT::fillStorage):
219         (JSC::DFG::SpeculativeJIT::writeBarrier):
220         (JSC::DFG::GPRTemporary::GPRTemporary):
221         (JSC::DFG::FPRTemporary::FPRTemporary):
222         (JSC::DFG::SpeculativeJIT::compilePeepHoleDoubleBranch):
223         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
224         (JSC::DFG::SpeculativeJIT::compilePeepHoleBranch):
225         (JSC::DFG::SpeculativeJIT::compile):
226         (JSC::DFG::SpeculativeJIT::checkArgumentTypes):
227         (JSC::DFG::SpeculativeJIT::compileGetCharCodeAt):
228         (JSC::DFG::SpeculativeJIT::compileGetByValOnString):
229         (JSC::DFG::SpeculativeJIT::compileValueToInt32):
230         (JSC::DFG::SpeculativeJIT::compileDoubleAsInt32):
231         (JSC::DFG::SpeculativeJIT::compileInt32ToDouble):
232         (JSC::DFG::SpeculativeJIT::compileGetTypedArrayLength):
233         (JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
234         (JSC::DFG::SpeculativeJIT::compilePutByValForIntTypedArray):
235         (JSC::DFG::SpeculativeJIT::compileGetByValOnFloatTypedArray):
236         (JSC::DFG::SpeculativeJIT::compilePutByValForFloatTypedArray):
237         (JSC::DFG::SpeculativeJIT::compileInstanceOf):
238         (JSC::DFG::SpeculativeJIT::compileAdd):
239         (JSC::DFG::SpeculativeJIT::compileArithSub):
240         (JSC::DFG::SpeculativeJIT::compileArithNegate):
241         (JSC::DFG::SpeculativeJIT::compileArithMul):
242         (JSC::DFG::SpeculativeJIT::compileArithMod):
243         (JSC::DFG::SpeculativeJIT::compare):
244         (JSC::DFG::SpeculativeJIT::compileStrictEq):
245         (JSC::DFG::SpeculativeJIT::compileGetIndexedPropertyStorage):
246         (JSC::DFG::SpeculativeJIT::compileGetByValOnArguments):
247         (JSC::DFG::SpeculativeJIT::compileGetArgumentsLength):
248         (JSC::DFG::SpeculativeJIT::compileRegExpExec):
249         * dfg/DFGSpeculativeJIT.h:
250         (DFG):
251         (JSC::DFG::ValueSource::forSpeculation):
252         (SpeculativeJIT):
253         (GPRTemporary):
254         (FPRTemporary):
255         (JSC::DFG::SpecDoubleOperand::SpecDoubleOperand):
256         (JSC::DFG::SpecDoubleOperand::~SpecDoubleOperand):
257         (JSC::DFG::SpecDoubleOperand::fpr):
258         (JSC::DFG::SpecCellOperand::SpecCellOperand):
259         (JSC::DFG::SpecCellOperand::~SpecCellOperand):
260         (JSC::DFG::SpecCellOperand::gpr):
261         (JSC::DFG::SpecBooleanOperand::SpecBooleanOperand):
262         (JSC::DFG::SpecBooleanOperand::~SpecBooleanOperand):
263         (JSC::DFG::SpecBooleanOperand::gpr):
264         * dfg/DFGSpeculativeJIT32_64.cpp:
265         (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
266         (JSC::DFG::SpeculativeJIT::fillSpecDouble):
267         (JSC::DFG::SpeculativeJIT::fillSpecCell):
268         (JSC::DFG::SpeculativeJIT::fillSpecBoolean):
269         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
270         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
271         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
272         (JSC::DFG::SpeculativeJIT::compileDoubleCompare):
273         (JSC::DFG::SpeculativeJIT::compileLogicalNot):
274         (JSC::DFG::SpeculativeJIT::emitBranch):
275         (JSC::DFG::SpeculativeJIT::compile):
276         * dfg/DFGSpeculativeJIT64.cpp:
277         (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
278         (JSC::DFG::SpeculativeJIT::fillSpecDouble):
279         (JSC::DFG::SpeculativeJIT::fillSpecCell):
280         (JSC::DFG::SpeculativeJIT::fillSpecBoolean):
281         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
282         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
283         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
284         (JSC::DFG::SpeculativeJIT::compileDoubleCompare):
285         (JSC::DFG::SpeculativeJIT::compileLogicalNot):
286         (JSC::DFG::SpeculativeJIT::emitBranch):
287         (JSC::DFG::SpeculativeJIT::compile):
288         * dfg/DFGVariableAccessData.h:
289         (JSC::DFG::VariableAccessData::VariableAccessData):
290         (JSC::DFG::VariableAccessData::predict):
291         (JSC::DFG::VariableAccessData::nonUnifiedPrediction):
292         (JSC::DFG::VariableAccessData::prediction):
293         (JSC::DFG::VariableAccessData::argumentAwarePrediction):
294         (JSC::DFG::VariableAccessData::mergeArgumentAwarePrediction):
295         (JSC::DFG::VariableAccessData::shouldUseDoubleFormatAccordingToVote):
296         (JSC::DFG::VariableAccessData::makePredictionForDoubleFormat):
297         (VariableAccessData):
298
299 2012-06-06  Filip Pizlo  <fpizlo@apple.com>
300
301         Global object variable accesses should not require an extra load
302         https://bugs.webkit.org/show_bug.cgi?id=88385
303
304         Reviewed by Gavin Barraclough and Geoffrey Garen.
305         
306         Previously, if you wanted to access a global variable, you'd first have
307         to load the register array from the appropriate global object and then
308         either load or store at an offset to the register array. This is because
309         JSGlobalObject inherited from JSVariableObject, and JSVariableObject is
310         designed with the pessimistic assumption that its register array may
311         point into the call stack. This is never the case for global objects.
312         Hence, even though the global object may add more registers at any time,
313         it does not need to store them in a contiguous array. It can use a
314         SegmentedVector or similar.
315         
316         This patch refactors global objects and variable objects as follows:
317         
318         - The functionality to track variables in an indexable array using a
319           SymbolTable to map names to indices is moved into JSSymbolTableObject,
320           which is now a supertype of JSVariableObject. JSVariableObject is now
321           just a holder for a registers array and implements the registerAt()
322           method that is left abstract in JSSymbolTableObject. Because all users
323           of JSVariableObject know whether they are a JSStaticScopeObject,
324           JSActivation, or JSGlobalObject, this "abstract" method is not virtual;
325           instead the utility methods that would call registerAt() are now
326           template functions that require you to know statically what subtype of
327           JSSymbolTableObject you're using (JSVariableObject or something else),
328           so that registerAt() can be statically bound.
329         
330         - A new class is added called JSSegmentedVariableObject, which only
331           differs from JSVariableObject in how it allocates registers. It uses a
332           SegmentedVector instead of manually managing a pointer to a contiguous
333           slab of registers. This changes the interface somewhat; for example
334           with JSVariableObject if you wanted to add a register you had to do
335           it yourself since the JSVariableObject didn't know how the registers
336           array ought to be allocated. With JSSegmentedVariableObject you can
337           just call addRegisters(). JSSegmentedVariableObject preserves the
338           invariant that once you get a pointer into a register, that pointer
339           will continue to be valid so long as the JSSegmentedVariableObject is
340           alive. This allows the JITs and interpreters to skip the extra load.
341         
342         - JSGlobalObject now inherits from JSSegmentedVariableObject. For now
343           (and possibly forever) it is the only subtype of this new class.
344         
345         - The bytecode format is changed so that get_global_var and
346           put_global_var have a pointer to the register directly rather than
347           having an index. A convenience method is provided in
348           JSSegmentedVariableObject to get the index given a a pointer, which is
349           used for assertions and debug dumps.
350         
351         This appears to be a 1% across the board win.
352
353         * CMakeLists.txt:
354         * GNUmakefile.list.am:
355         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
356         * JavaScriptCore.xcodeproj/project.pbxproj:
357         * Target.pri:
358         * bytecode/CodeBlock.cpp:
359         (JSC::CodeBlock::dump):
360         * bytecode/Instruction.h:
361         (Instruction):
362         (JSC::Instruction::Instruction):
363         * bytecompiler/BytecodeGenerator.cpp:
364         (JSC::ResolveResult::registerPointer):
365         (JSC):
366         (JSC::BytecodeGenerator::BytecodeGenerator):
367         (JSC::BytecodeGenerator::retrieveLastUnaryOp):
368         (JSC::BytecodeGenerator::resolve):
369         (JSC::BytecodeGenerator::resolveConstDecl):
370         (JSC::BytecodeGenerator::emitGetStaticVar):
371         (JSC::BytecodeGenerator::emitPutStaticVar):
372         * bytecompiler/BytecodeGenerator.h:
373         (ResolveResult):
374         (BytecodeGenerator):
375         * dfg/DFGAssemblyHelpers.h:
376         (AssemblyHelpers):
377         * dfg/DFGByteCodeParser.cpp:
378         (JSC::DFG::ByteCodeParser::parseBlock):
379         * dfg/DFGCSEPhase.cpp:
380         (JSC::DFG::CSEPhase::globalVarLoadElimination):
381         (JSC::DFG::CSEPhase::globalVarStoreElimination):
382         (JSC::DFG::CSEPhase::performNodeCSE):
383         * dfg/DFGGraph.cpp:
384         (JSC::DFG::Graph::dump):
385         * dfg/DFGGraph.h:
386         (JSC::DFG::Graph::globalObjectFor):
387         (Graph):
388         * dfg/DFGNode.h:
389         (JSC::DFG::Node::hasVarNumber):
390         (Node):
391         (JSC::DFG::Node::hasRegisterPointer):
392         (JSC::DFG::Node::registerPointer):
393         * dfg/DFGSpeculativeJIT32_64.cpp:
394         (JSC::DFG::SpeculativeJIT::compile):
395         * dfg/DFGSpeculativeJIT64.cpp:
396         (JSC::DFG::SpeculativeJIT::compile):
397         * heap/Heap.h:
398         (Heap):
399         (JSC::Heap::isWriteBarrierEnabled):
400         (JSC):
401         * interpreter/Interpreter.cpp:
402         (JSC::Interpreter::execute):
403         (JSC::Interpreter::privateExecute):
404         * jit/JITPropertyAccess.cpp:
405         (JSC::JIT::emit_op_get_global_var):
406         (JSC::JIT::emit_op_put_global_var):
407         * jit/JITPropertyAccess32_64.cpp:
408         (JSC::JIT::emit_op_get_global_var):
409         (JSC::JIT::emit_op_put_global_var):
410         * llint/LowLevelInterpreter32_64.asm:
411         * llint/LowLevelInterpreter64.asm:
412         * runtime/JSGlobalObject.cpp:
413         (JSC):
414         (JSC::JSGlobalObject::put):
415         (JSC::JSGlobalObject::putDirectVirtual):
416         (JSC::JSGlobalObject::defineOwnProperty):
417         (JSC::JSGlobalObject::visitChildren):
418         (JSC::JSGlobalObject::addStaticGlobals):
419         (JSC::JSGlobalObject::getOwnPropertySlot):
420         (JSC::JSGlobalObject::getOwnPropertyDescriptor):
421         * runtime/JSGlobalObject.h:
422         (JSGlobalObject):
423         (JSC::JSGlobalObject::JSGlobalObject):
424         (JSC):
425         (JSC::JSGlobalObject::hasOwnPropertyForWrite):
426         * runtime/JSSegmentedVariableObject.cpp: Added.
427         (JSC):
428         (JSC::JSSegmentedVariableObject::findRegisterIndex):
429         (JSC::JSSegmentedVariableObject::addRegisters):
430         (JSC::JSSegmentedVariableObject::visitChildren):
431         * runtime/JSSegmentedVariableObject.h: Added.
432         (JSC):
433         (JSSegmentedVariableObject):
434         (JSC::JSSegmentedVariableObject::registerAt):
435         (JSC::JSSegmentedVariableObject::assertRegisterIsInThisObject):
436         (JSC::JSSegmentedVariableObject::JSSegmentedVariableObject):
437         (JSC::JSSegmentedVariableObject::finishCreation):
438         * runtime/JSStaticScopeObject.cpp:
439         (JSC::JSStaticScopeObject::put):
440         (JSC::JSStaticScopeObject::putDirectVirtual):
441         (JSC::JSStaticScopeObject::getOwnPropertySlot):
442         * runtime/JSSymbolTableObject.cpp: Added.
443         (JSC):
444         (JSC::JSSymbolTableObject::destroy):
445         (JSC::JSSymbolTableObject::deleteProperty):
446         (JSC::JSSymbolTableObject::getOwnPropertyNames):
447         (JSC::JSSymbolTableObject::putDirectVirtual):
448         (JSC::JSSymbolTableObject::isDynamicScope):
449         * runtime/JSSymbolTableObject.h: Added.
450         (JSC):
451         (JSSymbolTableObject):
452         (JSC::JSSymbolTableObject::symbolTable):
453         (JSC::JSSymbolTableObject::JSSymbolTableObject):
454         (JSC::JSSymbolTableObject::finishCreation):
455         (JSC::symbolTableGet):
456         (JSC::symbolTablePut):
457         (JSC::symbolTablePutWithAttributes):
458         * runtime/JSVariableObject.cpp:
459         (JSC):
460         * runtime/JSVariableObject.h:
461         (JSVariableObject):
462         (JSC::JSVariableObject::JSVariableObject):
463         (JSC::JSVariableObject::finishCreation):
464         (JSC):
465         * runtime/WriteBarrier.h:
466
467 2012-06-06  Filip Pizlo  <fpizlo@apple.com>
468
469         DFG arguments access slow path should not crash if the arguments haven't been created
470         https://bugs.webkit.org/show_bug.cgi?id=88471
471
472         Reviewed by Gavin Barraclough.
473
474         * dfg/DFGCCallHelpers.h:
475         (JSC::DFG::CCallHelpers::setupArgumentsWithExecState):
476         (CCallHelpers):
477         * dfg/DFGOperations.cpp:
478         * dfg/DFGOperations.h:
479         * dfg/DFGSpeculativeJIT.h:
480         (JSC::DFG::SpeculativeJIT::callOperation):
481         * dfg/DFGSpeculativeJIT32_64.cpp:
482         (JSC::DFG::SpeculativeJIT::compile):
483         * dfg/DFGSpeculativeJIT64.cpp:
484         (JSC::DFG::SpeculativeJIT::compile):
485
486 2012-06-06  Michael Saboff  <msaboff@apple.com>
487
488         ENH: Add Logging to GC Marking Phase
489         https://bugs.webkit.org/show_bug.cgi?id=88364
490
491         Reviewed by Filip Pizlo.
492
493         Log GC marking to stderr or a file.  The logging in controlled
494         with the define ENABLE_OBJECT_MARK_LOGGING in wtf/Platform.h.
495         If DATA_LOG_TO_FILE in wtf/DataLog.cpp is set to 1, output is
496         logged to a file otherwise it is logged to stderr.
497
498         When logging is enabled, the GC is built single threaded since the
499         log output from the various threads isn't buffered and output in a
500         thread safe manner.
501
502         * heap/Heap.cpp:
503         (JSC::Heap::markRoots):
504         * heap/MarkStack.cpp:
505         (JSC::MarkStackThreadSharedData::resetChildren):
506         (JSC::MarkStackThreadSharedData::childVisitCount):
507         (JSC::MarkStackThreadSharedData::markingThreadMain):
508         (JSC::MarkStackThreadSharedData::markingThreadStartFunc):
509         (JSC::MarkStackThreadSharedData::MarkStackThreadSharedData):
510         (JSC::MarkStackThreadSharedData::reset):
511         * heap/MarkStack.h:
512         (MarkStackThreadSharedData):
513         (MarkStack):
514         (JSC::MarkStack::sharedData):
515         (JSC::MarkStack::resetChildCount):
516         (JSC::MarkStack::childCount):
517         (JSC::MarkStack::incrementChildCount):
518         * runtime/JSArray.cpp:
519         (JSC::JSArray::visitChildren):
520         * runtime/JSCell.cpp:
521         (JSC::JSCell::className):
522         * runtime/JSCell.h:
523         (JSCell):
524         (JSC::JSCell::visitChildren):
525         * runtime/JSString.cpp:
526         (JSC::JSString::visitChildren):
527         * runtime/JSString.h:
528         (JSString):
529         * runtime/Structure.h:
530         (JSC::MarkStack::internalAppend):
531
532 2012-06-06  Gavin Barraclough  <barraclough@apple.com>
533
534         Assigning to a static property should not change iteration order
535         https://bugs.webkit.org/show_bug.cgi?id=88401
536
537         Reviewed by Geoff Garen.
538
539         A specific iteration order is not defined by the spec, but test-262 somewhat tenuously
540         requires that it is at least stable, e.g. ch10/10.4/10.4.2/S10.4.2_A1.1_T1.js
541
542         Whilst it is not clear that this behavior really arises from the specification, it
543         would seem like common sense to conform to this.
544
545         The problem here is that we allow properties in the structure to shadow those in the
546         static table, and we iterate the properties in the structure first - which means that
547         as values of existing properties are modified, their iteration order changes too.
548
549         The easy fix is to iterate the properties from the static table first. This has a
550         further benefit, since it will mean that user added properties will come after those
551         present in the static table (respected the expected insertion-order).
552
553         * runtime/JSObject.cpp:
554         (JSC::JSObject::getOwnPropertyNames):
555             - Iterate static properties first.
556
557 2012-06-06  Andy Wingo  <wingo@igalia.com>
558
559         Ensure consistent order of evaluation in LLInt slow paths
560         https://bugs.webkit.org/show_bug.cgi?id=88409
561
562         Reviewed by Geoffrey Garen.
563
564         * llint/LLIntSlowPaths.cpp:
565         (slow_path_mul)
566         (slow_path_sub)
567         (slow_path_div)
568         (slow_path_mod)
569         (slow_path_lshift)
570         (slow_path_rshift)
571         (slow_path_urshift)
572         (slow_path_bitand)
573         (slow_path_bitor)
574         (slow_path_bitxor): Avoid calling toNumber, toInt32, or toUInt32
575         multiple times without intervening sequence points.  Fixes
576         fast/js/exception-sequencing-binops.html with GCC 4.7 on x86-64
577         Linux, which reordered evaluation of the arguments to fmod.
578
579 2012-06-06  Andy Wingo  <wingo@igalia.com>
580
581         [GTK] Enable the LLInt
582         https://bugs.webkit.org/show_bug.cgi?id=88315
583
584         Reviewed by Filip Pizlo.
585
586         * GNUmakefile.am: Add rules to generate LLIntDesiredOffsets.h and
587         LLIntAssembly.h.
588         * GNUmakefile.list.am: Add offlineasm and llint files to the
589         dist.  Add LLInt source files to the build.
590         * llint/LowLevelInterpreter.asm (crash): Generate a store of
591         0xbbadbeef to a register, not to a constant.  Otherwise, gas was
592         failing to assemble result.
593         * offlineasm/asm.rb (labelReference): Generate a
594         SYMBOL_STRING_RELOCATION instead of a SYMBOL_STRING, so that we go
595         through the PLT on ELF systems.
596
597 2012-06-06  Andy Wingo  <wingo@igalia.com>
598
599         REGRESSION (r106478): None of the Paper.js JavaScript examples work
600         https://bugs.webkit.org/show_bug.cgi?id=87158
601
602         Reviewed by Michael Saboff.
603
604         * bytecompiler/BytecodeGenerator.cpp:
605         (JSC::BytecodeGenerator::resolve): If we have to bail out to
606         dynamicResolve(), only skip static scopes from the head of the
607         scope chain.  Before, we were also skipping activations with
608         direct eval as well, which was incorrect.
609
610 2012-06-06  Dan Bernstein  <mitz@apple.com>
611
612         Reverted r119567, the fix for <http://webkit.org/b/88378>, because it broke the 32-bit build.
613
614         * dfg/DFGSpeculativeJIT.h:
615         (JSC::DFG::SpeculativeJIT::emitAllocateBasicJSObject):
616         * jit/JITInlineMethods.h:
617         (JSC::JIT::emitAllocateBasicJSObject):
618         * llint/LowLevelInterpreter.asm:
619         * runtime/JSGlobalData.h:
620         (JSGlobalData):
621         * runtime/JSGlobalThis.cpp:
622         (JSC::JSGlobalThis::setUnwrappedObject):
623         * runtime/JSObject.cpp:
624         (JSC::JSObject::visitChildren):
625         (JSC::JSObject::createInheritorID):
626         * runtime/JSObject.h:
627         (JSObject):
628         (JSC::JSObject::resetInheritorID):
629         (JSC):
630         (JSC::JSObject::offsetOfInheritorID):
631         (JSC::JSObject::inheritorID):
632
633 2012-06-05  Yuqiang Xian  <yuqiang.xian@intel.com>
634
635         Improve Math.round and Math.floor intrinsic
636         https://bugs.webkit.org/show_bug.cgi?id=88314
637
638         Reviewed by Filip Pizlo.
639
640         Currently we call a native function from the JIT code to complete the
641         "round" and "floor" operations. We could inline some fast paths
642         especially for those positive values on the platforms where floating
643         point truncation is supported.
644         This brings 3% gain on Kraken, especially 32% on audio-oscillator,
645         and slight win on SunSpider, measured on IA32.
646
647         * jit/ThunkGenerators.cpp:
648         (JSC::floorThunkGenerator):
649         (JSC):
650         (JSC::roundThunkGenerator):
651
652 2012-06-05  Gavin Barraclough  <barraclough@apple.com>
653
654         Remove JSObject::m_inheritorID
655         https://bugs.webkit.org/show_bug.cgi?id=88378
656
657         Reviewed by Geoff Garen.
658
659         This is rarely used, and not performance critical (the commonly accessed copy is cached on JSFunction),
660         and most objects don't need an inheritorID (this value is only used if the object is used as a prototype).
661         Instead use a private named value in the object's property storage.
662
663         * dfg/DFGSpeculativeJIT.h:
664         (JSC::DFG::SpeculativeJIT::emitAllocateBasicJSObject):
665             - No need m_inheritorID to initialize!
666         * jit/JITInlineMethods.h:
667         (JSC::JIT::emitAllocateBasicJSObject):
668             - No need m_inheritorID to initialize!
669         * llint/LowLevelInterpreter.asm:
670             - No need m_inheritorID to initialize!
671         * runtime/JSGlobalData.h:
672         (JSGlobalData):
673             - Added private name 'm_inheritorIDKey'.
674         * runtime/JSGlobalThis.cpp:
675         (JSC::JSGlobalThis::setUnwrappedObject):
676             - resetInheritorID is now passed a JSGlobalData&.
677         * runtime/JSObject.cpp:
678         (JSC::JSObject::visitChildren):
679             - No m_inheritorID to be marked.
680         (JSC::JSObject::createInheritorID):
681             - Store the newly created inheritorID in the property map.
682         * runtime/JSObject.h:
683         (JSC::JSObject::resetInheritorID):
684             - Remove the inheritorID from property storage.
685         (JSC::JSObject::inheritorID):
686             - Read the inheritorID from property storage.
687
688 2012-06-05  Filip Pizlo  <fpizlo@apple.com>
689
690         DFG CFG simplification should not attempt to deref nodes inside of an unreachable subgraph
691         https://bugs.webkit.org/show_bug.cgi?id=88362
692
693         Reviewed by Gavin Barraclough.
694
695         * dfg/DFGCFGSimplificationPhase.cpp:
696         (JSC::DFG::CFGSimplificationPhase::fixPhis):
697         (JSC::DFG::CFGSimplificationPhase::removePotentiallyDeadPhiReference):
698
699 2012-06-05  Mark Hahnenberg  <mhahnenberg@apple.com>
700
701         Entry into JSC should CRASH() if the Heap is busy
702         https://bugs.webkit.org/show_bug.cgi?id=88355
703
704         Reviewed by Geoffrey Garen.
705
706         Interpreter::execute() returns jsNull() right now if we try to enter it while 
707         the Heap is busy (e.g. with a collection), which is okay, but some code paths 
708         that call Interpreter::execute() allocate objects before checking if the Heap 
709         is busy. Attempting to execute JS code while the Heap is busy should not be 
710         allowed and should be enforced by a release-mode CRASH() to prevent vague, 
711         unhelpful backtraces later on if somebody makes a mistake. Normally, recursively 
712         executing JS code is okay, e.g. for evals, but it should not occur during a 
713         Heap allocation or collection because the Heap is not guaranteed to be in a 
714         consistent state (especially during collections). We are protected from 
715         executing JS on the same Heap concurrently on two separate threads because 
716         they must each take a JSLock first. However, we are not protected from reentrant 
717         execution of JS on the same thread because JSLock allows reentrancy. Therefore, 
718         we should fail early if we detect an entrance into JS code while the Heap is busy.
719
720         * heap/Heap.cpp: Changed Heap::collect so that it sets the m_operationInProgress field 
721         at the beginning of collection and then unsets it at the end so that it is set at all 
722         times throughout the duration of a collection rather than sporadically during various 
723         phases. There is no reason to unset during a collection because our collector does 
724         not currently support running additional JS between the phases of a collection.
725         (JSC::Heap::getConservativeRegisterRoots):
726         (JSC::Heap::markRoots):
727         (JSC::Heap::collect):
728         * interpreter/Interpreter.cpp:
729         (JSC::Interpreter::execute): Crash if the Heap is busy.
730         * runtime/Completion.cpp: Crash if the Heap is busy. We do it here before we call 
731         Interpreter::execute() because we do some allocation prior to calling execute() which 
732         could cause Heap corruption if, for example, that allocation caused a collection.
733         (JSC::evaluate):
734
735 2012-06-05  Dongwoo Im  <dw.im@samsung.com>
736
737         Add 'isProtocolHandlerRegistered' and 'unregisterProtocolHandler'.
738         https://bugs.webkit.org/show_bug.cgi?id=73176
739
740         Reviewed by Adam Barth.
741
742         Two more APIs are added in Custom Scheme Handler specification.
743         http://dev.w3.org/html5/spec/Overview.html#custom-handlers
744         One is 'isProtocolHandlerRegistered' to query whether the specific URL
745         is registered or not.
746         The other is 'unregisterProtocolHandler' to remove the registered URL.
747
748         * Configurations/FeatureDefines.xcconfig: Add a macro 'ENABLE_CUSTOM_SCHEME_HANDLER'.
749
750 2012-06-04  Filip Pizlo  <fpizlo@apple.com>
751
752         DFG CFG simplification should correct the variables at the head of the predecessor block
753         https://bugs.webkit.org/show_bug.cgi?id=88284
754
755         Reviewed by Geoffrey Garen.
756
757         * dfg/DFGCFGSimplificationPhase.cpp:
758         (JSC::DFG::CFGSimplificationPhase::mergeBlocks):
759
760 2012-06-04  Geoffrey Garen  <ggaren@apple.com>
761
762         Unreviewed.
763
764         Rolled out r119364 because it's still causing crashes (when running
765         v8-earley in release builds of DRT)
766
767         This time for sure!
768
769         * heap/Heap.cpp:
770         (JSC::Heap::collect):
771         * heap/MarkedBlock.cpp:
772         (JSC::MarkedBlock::sweep):
773         * heap/MarkedBlock.h:
774         (JSC::MarkedBlock::resetAllocator):
775         (JSC):
776         * heap/MarkedSpace.cpp:
777         (JSC::ResetAllocator::operator()):
778         (JSC):
779         (JSC::MarkedSpace::resetAllocators):
780         (JSC::MarkedSpace::sweepWeakSets):
781         * heap/MarkedSpace.h:
782         (MarkedSpace):
783         * heap/WeakBlock.cpp:
784         (JSC::WeakBlock::sweep):
785         * heap/WeakSet.cpp:
786         (JSC::WeakSet::sweep):
787         (JSC::WeakSet::tryFindAllocator):
788         * heap/WeakSet.h:
789         (JSC::WeakSet::shrink):
790
791 2012-06-04  Filip Pizlo  <fpizlo@apple.com>
792
793         DFG arguments simplification should have rationalized handling of TearOffArguments
794         https://bugs.webkit.org/show_bug.cgi?id=88206
795
796         Reviewed by Geoffrey Garen.
797         
798         - Accesses to the unmodified arguments register ought to have the same effect on
799           alias/escape analysis of arguments as accesses to the mutable arguments register.
800         
801         - The existence of TearOffArguments should not get in the way of arguments aliasing.
802         
803         - TearOffArguments should be eliminated if CreateArguments is eliminated.
804
805         * dfg/DFGArgumentsSimplificationPhase.cpp:
806         (JSC::DFG::ArgumentsSimplificationPhase::run):
807         (JSC::DFG::ArgumentsSimplificationPhase::observeBadArgumentsUse):
808
809 2012-06-04  Gavin Barraclough  <barraclough@apple.com>
810
811         Remove enabledProfilerReference
812         https://bugs.webkit.org/show_bug.cgi?id=88258
813
814         Reviewed by Michael Saboff.
815
816         Make the enabled profiler a member of JSGlobalData, and switch code that accesses it to do so directly
817         via the JSGlobalData, rather than holding a Profiler** reference to it. Do not pass the Profiler**
818         reference to JIT code. This patch does not change the stack layout on entry into JIT code (passing an
819         unused void* instead), since this is an intrusive change better handled in a separate patch.
820
821         * interpreter/Interpreter.cpp:
822         (JSC::Interpreter::throwException):
823         (JSC::Interpreter::execute):
824         (JSC::Interpreter::executeCall):
825         (JSC::Interpreter::executeConstruct):
826         (JSC::Interpreter::privateExecute):
827         * jit/JITCode.h:
828         (JSC::JITCode::execute):
829             - Don't pass Profiler** to JIT code.
830         * jit/JITOpcodes.cpp:
831         (JSC::JIT::emit_op_profile_will_call):
832         (JSC::JIT::emit_op_profile_did_call):
833         * jit/JITOpcodes32_64.cpp:
834         (JSC::JIT::emit_op_profile_will_call):
835         (JSC::JIT::emit_op_profile_did_call):
836         * jit/JITStubs.cpp:
837         (JSC):
838         (JSC::ctiTrampoline):
839         (JSC::ctiVMThrowTrampoline):
840         (JSC::ctiOpThrowNotCaught):
841         (JSC::JITThunks::JITThunks):
842         (JSC::DEFINE_STUB_FUNCTION):
843             - For ARM_THUMB2, rename ENABLE_PROFILER_REFERENCE_OFFSET to FIRST_STACK_ARGUMENT (which is how it is being used).
844             - For MIPS, remove ENABLE_PROFILER_REFERENCE_OFFSET.
845         * jit/JITStubs.h:
846         (JITStackFrame):
847         (JSC):
848             - Renamed enabledProfilerReference to unusedX.
849         * llint/LLIntSlowPaths.cpp:
850         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
851         * llint/LowLevelInterpreter.asm:
852         * profiler/Profiler.cpp:
853         (JSC):
854         (JSC::Profiler::startProfiling):
855         (JSC::Profiler::stopProfiling):
856         * profiler/Profiler.h:
857         (Profiler):
858             - Removed s_sharedEnabledProfilerReference, enabledProfilerReference().
859         * runtime/JSGlobalData.cpp:
860         (JSC::JSGlobalData::JSGlobalData):
861         * runtime/JSGlobalData.h:
862         (JSC):
863         (JSC::JSGlobalData::enabledProfiler):
864         (JSGlobalData):
865             - Added m_enabledProfiler, enabledProfiler().
866         * runtime/JSGlobalObject.cpp:
867         (JSC::JSGlobalObject::~JSGlobalObject):
868
869 2012-06-04  Filip Pizlo  <fpizlo@apple.com>
870
871         get_argument_by_val should be profiled everywhere
872         https://bugs.webkit.org/show_bug.cgi?id=88205
873
874         Reviewed by Geoffrey Garen.
875
876         * jit/JITOpcodes32_64.cpp:
877         (JSC::JIT::emitSlow_op_get_argument_by_val):
878         * llint/LLIntSlowPaths.cpp:
879         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
880
881 2012-06-04  Filip Pizlo  <fpizlo@apple.com>
882
883         DFG arguments simplification takes unkindly to direct accesses to the arguments register
884         https://bugs.webkit.org/show_bug.cgi?id=88261
885
886         Reviewed by Geoffrey Garen.
887         
888         Fixed arguments simplification for direct accesses to the arguments register, which may
889         arise if CSE had not run. Fixed CSE so that it does run prior to arguments simplification,
890         by making it a full-fledged member of the fixpoint. Fixed other issues in arguments
891         simplification, like realizing that it needs to bail if there is a direct assignment to
892         the arguments register, and failing to turn CreateArguments into PhantomArguments. Also
893         fixed CSE's handling of store elimination of captured locals in the presence of a
894         GetMyArgumentByVal (or one of its friends), and fixed CSE to correctly fixup variables at
895         tail if the Flush it removes is the last operation on a local in a basic block.
896
897         * bytecode/CodeBlock.cpp:
898         (JSC::CodeBlock::dump):
899         * dfg/DFGArgumentsSimplificationPhase.cpp:
900         (JSC::DFG::ArgumentsSimplificationPhase::run):
901         (JSC::DFG::ArgumentsSimplificationPhase::isOKToOptimize):
902         * dfg/DFGCSEPhase.cpp:
903         (JSC::DFG::CSEPhase::run):
904         (JSC::DFG::CSEPhase::setLocalStoreElimination):
905         (JSC::DFG::CSEPhase::performNodeCSE):
906         (CSEPhase):
907         * dfg/DFGDriver.cpp:
908         (JSC::DFG::compile):
909
910 2012-06-04  Anders Carlsson  <andersca@apple.com>
911
912         Fix a struct/class mismatch.
913
914         * heap/Handle.h:
915         (Handle):
916
917 2012-06-04  David Kilzer  <ddkilzer@apple.com>
918
919         BUILD FIX: FeatureDefines.xcconfig should match across projects
920
921         * Configurations/FeatureDefines.xcconfig:
922         - Add missing ENABLE_LEGACY_CSS_VENDOR_PREFIXES.
923
924 2012-06-02  Geoffrey Garen  <ggaren@apple.com>
925
926         Weak pointer finalization should be lazy
927         https://bugs.webkit.org/show_bug.cgi?id=87599
928
929         Reviewed by Sam Weinig.
930
931         This time for sure!
932
933         * heap/Heap.cpp:
934         (JSC::Heap::collect): Don't sweep eagerly -- we'll sweep lazily instead.
935
936         * heap/MarkedBlock.cpp:
937         (JSC::MarkedBlock::sweep): Sweep our weak set before we sweep our other
938         destructors -- this is our last chance to run weak set finalizers before
939         we recycle our memory.
940
941         * heap/MarkedBlock.h:
942         (JSC::MarkedBlock::resetAllocator):
943         * heap/MarkedSpace.cpp:
944         (JSC::MarkedSpace::resetAllocators):
945         * heap/MarkedSpace.h:
946         (JSC::MarkedSpace::resetAllocators): Don't force allocator reset anymore.
947         It will happen automatically when a weak set is swept. It's simpler to
948         have only one canonical way for this to happen, and it wasn't buying
949         us anything to do it eagerly.
950
951         * heap/WeakBlock.cpp:
952         (JSC::WeakBlock::sweep): Don't short-circuit a sweep unless we know
953         the sweep would be a no-op. If even one finalizer is pending, we need to
954         run it, since we won't get another chance.
955
956         * heap/WeakSet.cpp:
957         (JSC::WeakSet::sweep): This loop can be simpler now that
958         WeakBlock::sweep() does what we mean.
959
960         Reset our allocator after a sweep because this is the optimal time to
961         start trying to recycle old weak pointers.
962
963         (JSC::WeakSet::tryFindAllocator): Don't sweep when searching for an
964         allocator because we've swept already, and forcing a new sweep would be
965         wasteful.
966
967         * heap/WeakSet.h:
968         (JSC::WeakSet::shrink): Be sure to reset our allocator after a shrink
969         because the shrink may have removed the block the allocator was going to
970         allocate out of.
971
972 2012-06-02  Filip Pizlo  <fpizlo@apple.com>
973
974         If the DFG bytecode parser detects that op_method_check has gone polymorphic, it
975         shouldn't revert all the way to GetById/GetByIdFlush
976         https://bugs.webkit.org/show_bug.cgi?id=88176
977
978         Reviewed by Geoffrey Garen.
979         
980         Refactored the code so that the op_method_check case of the parser gracefully falls
981         through to all of the goodness of the normal op_get_by_id case.
982
983         * dfg/DFGByteCodeParser.cpp:
984         (ByteCodeParser):
985         (JSC::DFG::ByteCodeParser::handleGetById):
986         (DFG):
987         (JSC::DFG::ByteCodeParser::parseBlock):
988
989 2012-06-02  Filip Pizlo  <fpizlo@apple.com>
990
991         DFG CSE should be able to eliminate unnecessary flushes of arguments and captured variables
992         https://bugs.webkit.org/show_bug.cgi?id=87929
993
994         Reviewed by Geoffrey Garen.
995         
996         Slight speed-up on V8. Big win (up to 50%) on programs that inline very small functions.
997         
998         This required a bunch of changes:
999         
1000         - The obvious change is making CSE essentially ignore whether or not the set of
1001           operations between the Flush and the SetLocal can exit, and instead focus on whether or
1002           not that set of operations can clobber the world or access local variables. This code
1003           is now refactored to return a set of flags indicating any of these events, and the CSE
1004           decides what to do based on those flags. If the set of operations is non-clobbering
1005           and non-accessing, then the Flush is turned into a Phantom on the child of the
1006           SetLocal. This expands the liveness of the relevant variable but virtually guarantees
1007           that it will be register allocated and not flushed to the stack. So, yeah, this patch
1008           is a lot of work to save a few stores to the stack.
1009         
1010         - Previously, CheckArgumentsNotCreated was optimized "lazily" in that you only knew if
1011           it was a no-op if you were holding onto a CFA abstract state. But this would make the
1012           CSE act pessimistically, since it doesn't use the CFA. Hence, this patch changes the
1013           constant folding phase into something more broad; it now fixes up
1014           CheckArgumentsNotCreated nodes by turning them into phantoms if it knows that they are
1015           no-ops.
1016         
1017         - Arguments simplification was previously relying on this very strange PhantomArguments
1018           node, which had two different meanings: for normal execution it meant the empty value
1019           but for OSR exit it meant that the arguments should be reified. This produces problems
1020           when set SetLocals to the captured arguments registers are CSE'd away, since we'd be
1021           triggering reification of arguments without having initialized the arguments registers
1022           to empty. The cleanest solution was to fix PhantomArguments to have one meaning:
1023           namely, arguments reification on OSR exit. Hence, this patch changes arguments
1024           simplification to change SetLocal of CreateArguments on the arguments registers to be
1025           a SetLocal of Empty.
1026         
1027         - Argument value recoveries were previously derived from the value source of the
1028           arguments at the InlineStart. But that relies on all SetLocals to arguments having
1029           been flushed. It's possible that we could have elided the SetLocal to the arguments
1030           at the callsite because there were subsequent SetLocals to the arguments inside of the
1031           callee, in which case the InlineStart would get the wrong information. Hence, this
1032           patch changes argument value recovery computation to operate over the ArgumentPositions
1033           directly.
1034         
1035         - But that doesn't actually work, because previously, there was no way to link an
1036           InlineStart back to the corresponding ArgumentPositions, at least not without some
1037           ugliness. So this patch instates the rule that the m_argumentPositions vector consists
1038           of disjoint subsequences such that each subsequence corresponds to an inline callsite
1039           and can be identified by its first index, and within each subsequence are the
1040           ArgumentPositions of all of the arguments ordered by argument index. This required
1041           flipping the order in which ArgumentPositions are added to the vector, and giving
1042           InlineStart an operand that indicates the start of that inline callsite's
1043           ArgumentPosition subsequence.
1044         
1045         - This patch also revealed a nasty bug in the reification of arguments in inline call
1046           frames on OSR exit. Since the reification was happening after the values of virtual
1047           registers were recovered, the value recoveries of the inline arguments were wrong.
1048           Hence using operationCreateInlinedArguments is wrong. For example a value recovery
1049           might say that you have to box a double, but if we had already boxed it then boxing
1050           it a second time will result in garbage. The specific case of this bug was this patch
1051           uncovered was that now it is possible for an inline call frame to not have any valid
1052           value recoveries for any inline arguments, if the optimization elides all argument
1053           flushes, while at the same time optimizing away arguments creation. Then OSR exit
1054           would try to recover the arguments using the inline call frame, which had bogus
1055           information, and humorous crashes would ensue. This patch fixes this issue by moving
1056           arguments reification to after call frame reification, so that arguments reification
1057           can always use operationCreateArguments instead of operationCreateInlinedArguments.
1058         
1059         - This patch may turn a Flush into a Phantom. That's kind of the whole point. But that
1060           broke forward speculation checks, which knew to look for a Flush prior to a SetLocal
1061           but didn't know that there could alternatively be a Phantom in place of the Flush.
1062           This patch fixes that by augmenting the forward speculation check logic.
1063         
1064         - Finally, in the process of having fun with all of the above, I realized that my DFG
1065           validation was not actually running on every phase like I had originally designed it
1066           to. In fact it was only running just after bytecode parsing. I initially tried to
1067           make it run in every phase but found that this causes some tests to timeout
1068           (specifically the evil fuzzing ones), so I decided on a compromise where: (i) in
1069           release mode validation never runs, (ii) in debug mode validation will run just
1070           after parsing and just before the backend, and (iii) it's possible with a simple
1071           switch to enable validation to run on every phase.
1072         
1073         Luckily all of the above issues were already covered by the 77 or so DFG-specific
1074         layout tests. Hence, this patch does not introduce any new tests despite being so
1075         meaty.
1076
1077         * dfg/DFGAbstractState.cpp:
1078         (JSC::DFG::AbstractState::execute):
1079         * dfg/DFGArgumentPosition.h:
1080         (JSC::DFG::ArgumentPosition::prediction):
1081         (JSC::DFG::ArgumentPosition::doubleFormatState):
1082         (JSC::DFG::ArgumentPosition::shouldUseDoubleFormat):
1083         (ArgumentPosition):
1084         * dfg/DFGArgumentsSimplificationPhase.cpp:
1085         (JSC::DFG::ArgumentsSimplificationPhase::run):
1086         * dfg/DFGByteCodeParser.cpp:
1087         (JSC::DFG::ByteCodeParser::handleInlining):
1088         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
1089         * dfg/DFGCSEPhase.cpp:
1090         (JSC::DFG::CSEPhase::SetLocalStoreEliminationResult::SetLocalStoreEliminationResult):
1091         (SetLocalStoreEliminationResult):
1092         (JSC::DFG::CSEPhase::setLocalStoreElimination):
1093         (JSC::DFG::CSEPhase::performNodeCSE):
1094         * dfg/DFGCommon.h:
1095         * dfg/DFGConstantFoldingPhase.cpp:
1096         (JSC::DFG::ConstantFoldingPhase::run):
1097         * dfg/DFGDriver.cpp:
1098         (JSC::DFG::compile):
1099         * dfg/DFGNode.h:
1100         (Node):
1101         (JSC::DFG::Node::hasArgumentPositionStart):
1102         (JSC::DFG::Node::argumentPositionStart):
1103         * dfg/DFGOSRExitCompiler32_64.cpp:
1104         (JSC::DFG::OSRExitCompiler::compileExit):
1105         * dfg/DFGOSRExitCompiler64.cpp:
1106         (JSC::DFG::OSRExitCompiler::compileExit):
1107         * dfg/DFGPhase.cpp:
1108         (DFG):
1109         * dfg/DFGPhase.h:
1110         (Phase):
1111         * dfg/DFGSpeculativeJIT.cpp:
1112         (JSC::DFG::SpeculativeJIT::compile):
1113         * dfg/DFGSpeculativeJIT.h:
1114         (JSC::DFG::SpeculativeJIT::forwardSpeculationCheck):
1115         * dfg/DFGSpeculativeJIT32_64.cpp:
1116         (JSC::DFG::SpeculativeJIT::compile):
1117         * dfg/DFGSpeculativeJIT64.cpp:
1118         (JSC::DFG::SpeculativeJIT::compile):
1119
1120 2012-06-02  Geoffrey Garen  <ggaren@apple.com>
1121
1122         DOM string cache should hash pointers, not characters
1123         https://bugs.webkit.org/show_bug.cgi?id=88175
1124
1125         Reviewed by Phil Pizlo and Sam Weinig.
1126
1127         * heap/Weak.h:
1128         (JSC::weakAdd):
1129         (JSC::weakRemove): Made these function templates slightly more generic
1130         to accommodate new client types.
1131
1132 2012-06-01  Filip Pizlo  <fpizlo@apple.com>
1133
1134         DFG CFA should know that PutByVal can clobber the world
1135         https://bugs.webkit.org/show_bug.cgi?id=88155
1136
1137         Reviewed by Gavin Barraclough.
1138
1139         * dfg/DFGAbstractState.cpp:
1140         (JSC::DFG::AbstractState::execute):
1141
1142 2012-06-01  Filip Pizlo  <fpizlo@apple.com>
1143
1144         DFG CFA should mark basic blocks as having constants if local accesses yield constants
1145         https://bugs.webkit.org/show_bug.cgi?id=88153
1146
1147         Reviewed by Gavin Barraclough.
1148
1149         * dfg/DFGAbstractState.cpp:
1150         (JSC::DFG::AbstractState::execute):
1151
1152 2012-06-01  Filip Pizlo  <fpizlo@apple.com>
1153
1154         DFG arguments simplification phase uses a node.codeOrigin after appending a node
1155         https://bugs.webkit.org/show_bug.cgi?id=88151
1156
1157         Reviewed by Geoffrey Garen.
1158         
1159         The right thing to do is to save the CodeOrigin before appending to the graph.
1160
1161         * dfg/DFGArgumentsSimplificationPhase.cpp:
1162         (JSC::DFG::ArgumentsSimplificationPhase::run):
1163
1164 2012-06-01  Filip Pizlo  <fpizlo@apple.com>
1165
1166         DFG should not emit unnecessary speculation checks when performing an int32 to double conversion on
1167         a value that is proved to be a number, predicted to be an int32, but not proved to be an int32
1168         https://bugs.webkit.org/show_bug.cgi?id=88146
1169
1170         Reviewed by Gavin Barraclough.
1171
1172         * dfg/DFGSpeculativeJIT.cpp:
1173         (JSC::DFG::SpeculativeJIT::compileInt32ToDouble):
1174
1175 2012-06-01  Filip Pizlo  <fpizlo@apple.com>
1176
1177         DFG constant folding search for the last local access skips the immediately previous local access
1178         https://bugs.webkit.org/show_bug.cgi?id=88141
1179
1180         Reviewed by Michael Saboff.
1181         
1182         If you use a loop in the style of:
1183
1184         for (i = start; i--;)
1185
1186         then you need to remember that the first value of 'i' that the loop body will see is 'start - 1'.
1187         Hence the following is probably wrong:
1188         
1189         for (i = start - 1; i--;)
1190
1191         * dfg/DFGConstantFoldingPhase.cpp:
1192         (JSC::DFG::ConstantFoldingPhase::run):
1193
1194 2012-06-01  Filip Pizlo  <fpizlo@apple.com>
1195
1196         DFG constant folding should be OK with GetLocal of captured variables having a constant
1197         https://bugs.webkit.org/show_bug.cgi?id=88137
1198
1199         Reviewed by Gavin Barraclough.
1200
1201         * dfg/DFGConstantFoldingPhase.cpp:
1202         (JSC::DFG::ConstantFoldingPhase::run):
1203
1204 2012-05-31  Mark Hahnenberg  <mhahnenberg@apple.com>
1205
1206         JSGlobalObject does not mark m_privateNameStructure
1207         https://bugs.webkit.org/show_bug.cgi?id=88023
1208
1209         Rubber stamped by Gavin Barraclough.
1210
1211         * runtime/JSGlobalObject.cpp:
1212         (JSC::JSGlobalObject::visitChildren): We need to mark this so it doesn't get 
1213         inadvertently garbage collected.
1214
1215 2012-05-31  Erik Arvidsson  <arv@chromium.org>
1216
1217         Make DOM Exceptions Errors
1218         https://bugs.webkit.org/show_bug.cgi?id=85078
1219
1220         Reviewed by Oliver Hunt.
1221
1222         WebIDL mandates that exceptions should have Error.prototype on its prototype chain.
1223
1224         For JSC we have access to the Error.prototype from the binding code.
1225
1226         For V8 we set a field in the WrapperTypeInfo and when the constructor function is created we
1227         set the prototype as needed.
1228
1229         Updated test: fast/dom/DOMException/prototype-object.html
1230
1231         * JavaScriptCore.xcodeproj/project.pbxproj:
1232         * runtime/JSGlobalObject.cpp:
1233         (JSC::JSGlobalObject::reset):
1234         * runtime/JSGlobalObject.h:
1235         (JSC):
1236         (JSGlobalObject):
1237         (JSC::JSGlobalObject::errorPrototype):
1238
1239 2012-05-31  Andy Wingo  <wingo@igalia.com>
1240
1241         Fix reference to unset variable in debug mode
1242         https://bugs.webkit.org/show_bug.cgi?id=87981
1243
1244         Reviewed by Geoffrey Garen.
1245
1246         * runtime/JSONObject.cpp (Stringifier::Holder::Holder):
1247         Initialize m_size in debug mode, as we check it later in an assert.
1248
1249 2012-05-30  Mark Hahnenberg  <mhahnenberg@apple.com>
1250
1251         Heap should sweep incrementally
1252         https://bugs.webkit.org/show_bug.cgi?id=85429
1253
1254         We shouldn't have to wait for the opportunistic GC timer to fire in order 
1255         to call object destructors. Instead, we should incrementally sweep some 
1256         subset of the blocks requiring sweeping periodically. We tie this sweeping 
1257         to a timer rather than to collections because we want to reclaim this memory 
1258         even if we stop allocating. This way, our memory usage scales smoothly with 
1259         actual use, regardless of whether we've recently done an opportunistic GC or not.
1260
1261         Reviewed by Geoffrey Garen.
1262
1263         * CMakeLists.txt:
1264         * GNUmakefile.list.am:
1265         * JavaScriptCore.gypi:
1266         * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
1267         * JavaScriptCore.xcodeproj/project.pbxproj:
1268         * Target.pri:
1269         * heap/Heap.cpp:
1270         (JSC::Heap::Heap):
1271         (JSC::Heap::collect): We no longer sweep during a full sweep. We only shrink now,
1272         which we will switch over to being done during incremental sweeping too as soon as
1273         all finalizers can be run lazily (and, by extension, incrementally). 
1274         (JSC::Heap::sweeper):
1275         (JSC):
1276         * heap/Heap.h:
1277         (JSC):
1278         (Heap):
1279         * heap/IncrementalSweeper.cpp: Added.
1280         (JSC):
1281         (JSC::IncrementalSweeper::timerDidFire): The IncrementalSweeper works very similarly to 
1282         GCActivityCallback. It is tied to a run-loop based timer that fires periodically based 
1283         on how long the previous sweep increment took to run. The IncrementalSweeper doesn't do 
1284         anything if the platform doesn't support CoreFoundation.
1285         (JSC::IncrementalSweeper::IncrementalSweeper):
1286         (JSC::IncrementalSweeper::~IncrementalSweeper):
1287         (JSC::IncrementalSweeper::create):
1288         (JSC::IncrementalSweeper::scheduleTimer):
1289         (JSC::IncrementalSweeper::cancelTimer):
1290         (JSC::IncrementalSweeper::doSweep): Iterates over the snapshot of the MarkedSpace taken 
1291         during the last collection, checking to see which blocks need sweeping. If it successfully 
1292         gets to the end of the blocks that need sweeping then it cancels the timer.
1293         (JSC::IncrementalSweeper::startSweeping): We take a snapshot of the Heap and store it in 
1294         a Vector that the incremental sweep will iterate over. We also reset our index into this Vector.
1295         * heap/IncrementalSweeper.h: Added.
1296         (JSC):
1297         (IncrementalSweeper):
1298         * heap/MarkedBlock.h:
1299         (JSC::MarkedBlock::needsSweeping): If a block is in the Marked state it needs sweeping 
1300         to be usable and to run any destructors that need to be run.
1301
1302 2012-05-30  Patrick Gansterer  <paroga@webkit.org>
1303
1304         [WINCE] Fix JSString after r115516.
1305         https://bugs.webkit.org/show_bug.cgi?id=87892
1306
1307         Reviewed by Geoffrey Garen.
1308
1309         r115516 splitted JSString into two classes, with addition nested classes.
1310         Add a workaround for the WinCE compiler since it can't resolve the friend class
1311         declerations corretly and denies the access to protected members of JSString.
1312
1313         * runtime/JSString.h:
1314         (JSC::JSRopeString::RopeBuilder::append):
1315         (JSC::JSRopeString::append):
1316         (JSRopeString):
1317
1318 2012-05-30  Oliver Hunt  <oliver@apple.com>
1319
1320         Really provide error information with the inspector disabled
1321         https://bugs.webkit.org/show_bug.cgi?id=87910
1322
1323         Reviewed by Filip Pizlo.
1324
1325         Don't bother checking for anything other than pre-existing error info.
1326         In the absence of complete line number information you'll only get the
1327         line a function starts on, but at least it's something.
1328
1329         * interpreter/Interpreter.cpp:
1330         (JSC::Interpreter::throwException):
1331
1332 2012-05-30  Filip Pizlo  <fpizlo@apple.com>
1333
1334         LLInt broken on x86-32 with JIT turned off
1335         https://bugs.webkit.org/show_bug.cgi?id=87906
1336
1337         Reviewed by Geoffrey Garen.
1338         
1339         Fixed the code to not clobber registers that contain important things, like the call frame.
1340
1341         * llint/LowLevelInterpreter32_64.asm:
1342
1343 2012-05-30  Filip Pizlo  <fpizlo@apple.com>
1344
1345         ScriptDebugServer wants sourceIDs that are non-zero because that's what HashMaps want, so JSC should placate it
1346         https://bugs.webkit.org/show_bug.cgi?id=87887
1347
1348         Reviewed by Darin Adler.
1349         
1350         Better fix - we now never call SourceProvider::asID() if SourceProvider* is 0.
1351
1352         * parser/Nodes.h:
1353         (JSC::ScopeNode::sourceID):
1354         * parser/SourceCode.h:
1355         (JSC::SourceCode::providerID):
1356         (SourceCode):
1357         * parser/SourceProvider.h:
1358         (SourceProvider):
1359         (JSC::SourceProvider::asID):
1360         * runtime/Executable.h:
1361         (JSC::ScriptExecutable::sourceID):
1362
1363 2012-05-30  Filip Pizlo  <fpizlo@apple.com>
1364
1365         ScriptDebugServer wants sourceIDs that are non-zero because that's what HashMaps want, so JSC should placate it
1366         https://bugs.webkit.org/show_bug.cgi?id=87887
1367
1368         Reviewed by Geoffrey Garen.
1369
1370         * parser/SourceProvider.h:
1371         (JSC::SourceProvider::asID):
1372
1373 2012-05-30  Oliver Hunt  <oliver@apple.com>
1374
1375         DFG does not correctly handle exceptions caught in the LLInt
1376         https://bugs.webkit.org/show_bug.cgi?id=87885
1377
1378         Reviewed by Filip Pizlo.
1379
1380         Make the DFG use genericThrow, rather than reimplementing a small portion of it.
1381         Also make the LLInt slow paths validate that their PC is correct.
1382
1383         * dfg/DFGOperations.cpp:
1384         * llint/LLIntSlowPaths.cpp:
1385         (LLInt):
1386
1387 2012-05-29  Filip Pizlo  <fpizlo@apple.com>
1388
1389         DFG CFA should infer types and values of captured variables
1390         https://bugs.webkit.org/show_bug.cgi?id=87813
1391
1392         Reviewed by Gavin Barraclough.
1393         
1394         Slight speed-up in V8/earley-boyer (~1%).
1395
1396         * bytecode/CodeBlock.h:
1397         (JSC::CodeBlock::argumentsAreCaptured):
1398         (JSC::CodeBlock::argumentIsCaptured):
1399         (CodeBlock):
1400         * dfg/DFGAbstractState.cpp:
1401         (DFG):
1402         (JSC::DFG::AbstractState::beginBasicBlock):
1403         (JSC::DFG::AbstractState::initialize):
1404         (JSC::DFG::AbstractState::endBasicBlock):
1405         (JSC::DFG::AbstractState::execute):
1406         (JSC::DFG::AbstractState::clobberWorld):
1407         (JSC::DFG::AbstractState::clobberStructures):
1408         (JSC::DFG::AbstractState::mergeStateAtTail):
1409         (JSC::DFG::AbstractState::merge):
1410         (JSC::DFG::AbstractState::mergeToSuccessors):
1411         * dfg/DFGAbstractState.h:
1412         (JSC::DFG::AbstractState::variables):
1413         (AbstractState):
1414         * dfg/DFGSpeculativeJIT32_64.cpp:
1415         (JSC::DFG::SpeculativeJIT::compile):
1416         * dfg/DFGSpeculativeJIT64.cpp:
1417         (JSC::DFG::SpeculativeJIT::compile):
1418
1419 2012-05-30  Patrick Gansterer  <paroga@webkit.org>
1420
1421         Unreviewed. Build fix for !ENABLE(JIT) after r117823.
1422
1423         * bytecode/CodeBlock.cpp:
1424         (JSC::CodeBlock::dump):
1425
1426 2012-05-30  Sheriff Bot  <webkit.review.bot@gmail.com>
1427
1428         Unreviewed, rolling out r118868.
1429         http://trac.webkit.org/changeset/118868
1430         https://bugs.webkit.org/show_bug.cgi?id=87828
1431
1432         introduced ~20 crashes on Mac and Qt bots (Requested by pizlo_
1433         on #webkit).
1434
1435         * heap/Heap.cpp:
1436         (JSC::Heap::collect):
1437         * heap/MarkedBlock.cpp:
1438         (JSC::MarkedBlock::sweep):
1439         * heap/MarkedBlock.h:
1440         (JSC::MarkedBlock::sweepWeakSet):
1441         (JSC):
1442         * heap/MarkedSpace.cpp:
1443         (JSC::SweepWeakSet::operator()):
1444         (JSC):
1445         (JSC::MarkedSpace::sweepWeakSets):
1446         * heap/MarkedSpace.h:
1447         (MarkedSpace):
1448
1449 2012-05-29  Geoffrey Garen  <ggaren@apple.com>
1450
1451         Rolled back in r118646, now that
1452         https://bugs.webkit.org/show_bug.cgi?id=87784 is fixed.
1453
1454         http://trac.webkit.org/changeset/118646
1455         https://bugs.webkit.org/show_bug.cgi?id=87599
1456
1457         * heap/Heap.cpp:
1458         (JSC::Heap::collect):
1459         * heap/MarkedBlock.cpp:
1460         (JSC::MarkedBlock::sweep):
1461         * heap/MarkedBlock.h:
1462         (JSC):
1463         * heap/MarkedSpace.cpp:
1464         (JSC):
1465         * heap/MarkedSpace.h:
1466         (MarkedSpace):
1467
1468 2012-05-29  Filip Pizlo  <fpizlo@apple.com>
1469
1470         DFG should keep captured variables alive until the (inline) return.
1471         https://bugs.webkit.org/show_bug.cgi?id=87205
1472
1473         Reviewed by Gavin Barraclough.
1474         
1475         Changes the way we do flushing for captured variables and arguments. Instead of flushing
1476         each SetLocal immediately, we flush at kill points. So a SetLocal will cause a Flush of
1477         whatever was live in the variable previously, and a return will cause a Flush of all
1478         captured variables and all arguments.
1479
1480         * dfg/DFGByteCodeParser.cpp:
1481         (JSC::DFG::ByteCodeParser::setDirect):
1482         (JSC::DFG::ByteCodeParser::set):
1483         (JSC::DFG::ByteCodeParser::setLocal):
1484         (JSC::DFG::ByteCodeParser::getArgument):
1485         (JSC::DFG::ByteCodeParser::setArgument):
1486         (JSC::DFG::ByteCodeParser::findArgumentPositionForArgument):
1487         (ByteCodeParser):
1488         (JSC::DFG::ByteCodeParser::findArgumentPositionForLocal):
1489         (JSC::DFG::ByteCodeParser::findArgumentPosition):
1490         (JSC::DFG::ByteCodeParser::flush):
1491         (JSC::DFG::ByteCodeParser::flushDirect):
1492         (JSC::DFG::ByteCodeParser::flushArgumentsAndCapturedVariables):
1493         (JSC::DFG::ByteCodeParser::handleInlining):
1494         (JSC::DFG::ByteCodeParser::parseBlock):
1495         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
1496         * dfg/DFGCSEPhase.cpp:
1497         (JSC::DFG::CSEPhase::setLocalStoreElimination):
1498         (JSC::DFG::CSEPhase::performNodeCSE):
1499         * dfg/DFGSpeculativeJIT.cpp:
1500         (JSC::DFG::SpeculativeJIT::compile):
1501         * dfg/DFGSpeculativeJIT.h:
1502         (JSC::DFG::SpeculativeJIT::forwardSpeculationCheck):
1503
1504 2012-05-29  Geoffrey Garen  <ggaren@apple.com>
1505
1506         WeakGCMap should be lazy-finalization-safe
1507         https://bugs.webkit.org/show_bug.cgi?id=87784
1508
1509         Reviewed by Darin Adler.
1510
1511         * runtime/WeakGCMap.h:
1512         (JSC::WeakGCMap::get): Since this is a map of raw WeakImpl pointers, and
1513         not Weak<T>, we need to verify manually that the WeakImpl is live before
1514         we return its payload.
1515
1516 2012-05-29  Mark Hahnenberg  <mhahnenberg@apple.com>
1517
1518         CopiedSpace::doneCopying could start another collection
1519         https://bugs.webkit.org/show_bug.cgi?id=86538
1520
1521         Reviewed by Geoffrey Garen.
1522
1523         It's possible that if we don't have anything at the head of to-space 
1524         after a collection and the BlockAllocator doesn't have any fresh blocks 
1525         to give us right now we could start another collection while still in 
1526         the middle of the first collection when we call CopiedSpace::addNewBlock(). 
1527
1528         One way to resolve this would be to have Heap::shouldCollect() check that 
1529         m_operationInProgress is NoOperation. This would prevent the path in 
1530         getFreshBlock() that starts the collection if we're already in the middle of one.
1531
1532         I could not come up with a test case to reproduce this crash on ToT.
1533
1534         * heap/Heap.h:
1535         (JSC::Heap::shouldCollect): We shouldn't collect if we're already in the middle
1536         of a collection, i.e. the current operation should be NoOperation.
1537
1538 2012-05-29  David Barr  <davidbarr@chromium.org>
1539
1540         Introduce ENABLE_CSS_IMAGE_RESOLUTION compile flag
1541         https://bugs.webkit.org/show_bug.cgi?id=87685
1542
1543         Reviewed by Eric Seidel.
1544
1545         Add a configuration option for CSS image-resolution support, disabling it by default.
1546
1547         * Configurations/FeatureDefines.xcconfig:
1548
1549 2012-05-28  Sheriff Bot  <webkit.review.bot@gmail.com>
1550
1551         Unreviewed, rolling out r118646.
1552         http://trac.webkit.org/changeset/118646
1553         https://bugs.webkit.org/show_bug.cgi?id=87691
1554
1555         broke V8 raytrace benchmark (Requested by pizlo_ on #webkit).
1556
1557         * heap/Heap.cpp:
1558         (JSC::Heap::collect):
1559         * heap/MarkedBlock.cpp:
1560         (JSC::MarkedBlock::sweep):
1561         * heap/MarkedBlock.h:
1562         (JSC::MarkedBlock::sweepWeakSet):
1563         (JSC):
1564         * heap/MarkedSpace.cpp:
1565         (JSC::SweepWeakSet::operator()):
1566         (JSC):
1567         (JSC::MarkedSpace::sweepWeakSets):
1568         * heap/MarkedSpace.h:
1569         (MarkedSpace):
1570
1571 2012-05-28  Filip Pizlo  <fpizlo@apple.com>
1572
1573         DFG should not generate code for code that the CFA proves to be unreachable
1574         https://bugs.webkit.org/show_bug.cgi?id=87682
1575
1576         Reviewed by Sam Weinig.
1577         
1578         This also fixes a small performance bug where CFA was not marking blocks
1579         as having constants (and hence not triggering constant folding) if the only
1580         constants were on GetLocals.
1581         
1582         And fixing that bug revealed another bug: constant folding was assuming that
1583         a GetLocal must be the first access to a local in a basic block. This isn't
1584         true. The first access may be a Flush. This patch fixes that issue using the
1585         safest approach possible, since we don't need to be clever for something that
1586         only happens in one of our benchmarks.
1587
1588         * dfg/DFGAbstractState.cpp:
1589         (JSC::DFG::AbstractState::execute):
1590         * dfg/DFGConstantFoldingPhase.cpp:
1591         (JSC::DFG::ConstantFoldingPhase::run):
1592         * dfg/DFGJITCompiler.h:
1593         (JSC::DFG::JITCompiler::noticeOSREntry):
1594         * dfg/DFGSpeculativeJIT.cpp:
1595         (JSC::DFG::SpeculativeJIT::compile):
1596
1597 2012-05-28  Carlos Garcia Campos  <cgarcia@igalia.com>
1598
1599         Unreviewed. Fix make distcheck.
1600
1601         * GNUmakefile.list.am: Add missing header file.
1602
1603 2012-05-27  Geoffrey Garen  <ggaren@apple.com>
1604
1605         Weak pointer finalization should be lazy
1606         https://bugs.webkit.org/show_bug.cgi?id=87599
1607
1608         Reviewed by Darin Adler.
1609
1610         * heap/Heap.cpp:
1611         (JSC::Heap::collect): Don't force immediate finalization -- it will
1612         happen lazily.
1613
1614         * heap/MarkedBlock.cpp:
1615         (JSC::MarkedBlock::sweep): Sweep a block's weak set when sweeping the
1616         block. The weak set may not have been swept yet, and this is our last
1617         chance to run weak finalizers before we recycle the memory they reference.
1618
1619         * heap/MarkedBlock.h:
1620         * heap/MarkedSpace.cpp:
1621         (JSC::MarkedBlock::sweepWeakSets):
1622         * heap/MarkedSpace.h:
1623         (JSC::MarkedSpace::sweepWeakSets): Nixed sweepWeakSets because it's unused
1624         now.
1625
1626 2012-05-26  Geoffrey Garen  <ggaren@apple.com>
1627
1628         WebKit should be lazy-finalization-safe (esp. the DOM) v2
1629         https://bugs.webkit.org/show_bug.cgi?id=87581
1630
1631         Reviewed by Oliver Hunt.
1632
1633         * heap/MarkedBlock.cpp:
1634         (JSC::MarkedBlock::callDestructor):
1635         * heap/WeakBlock.h:
1636         * heap/WeakSetInlines.h:
1637         (JSC::WeakBlock::finalize): Since we don't guarantee destruction order,
1638         it's not valid to access GC pointers like the Structure pointer during
1639         finalization. We NULL out the structure pointer in debug builds to try
1640         to make this programming mistake more obvious.
1641
1642         * API/JSCallbackConstructor.cpp:
1643         (JSC::JSCallbackConstructor::destroy):
1644         * API/JSCallbackObject.cpp:
1645         (JSC::::destroy):
1646         (JSC::JSCallbackObjectData::finalize):
1647         * runtime/Arguments.cpp:
1648         (JSC::Arguments::destroy):
1649         * runtime/DateInstance.cpp:
1650         (JSC::DateInstance::destroy):
1651         * runtime/Error.cpp:
1652         (JSC::StrictModeTypeErrorFunction::destroy):
1653         * runtime/Executable.cpp:
1654         (JSC::ExecutableBase::destroy):
1655         (JSC::NativeExecutable::destroy):
1656         (JSC::ScriptExecutable::destroy):
1657         (JSC::EvalExecutable::destroy):
1658         (JSC::ProgramExecutable::destroy):
1659         (JSC::FunctionExecutable::destroy):
1660         * runtime/JSGlobalObject.cpp:
1661         (JSC::JSGlobalObject::destroy):
1662         * runtime/JSPropertyNameIterator.cpp:
1663         (JSC::JSPropertyNameIterator::destroy):
1664         * runtime/JSStaticScopeObject.cpp:
1665         (JSC::JSStaticScopeObject::destroy):
1666         * runtime/JSString.cpp:
1667         (JSC::JSString::destroy):
1668         * runtime/JSVariableObject.cpp:
1669         (JSC::JSVariableObject::destroy):
1670         * runtime/NameInstance.cpp:
1671         (JSC::NameInstance::destroy):
1672         * runtime/RegExp.cpp:
1673         (JSC::RegExp::destroy):
1674         * runtime/RegExpConstructor.cpp:
1675         (JSC::RegExpConstructor::destroy):
1676         * runtime/Structure.cpp:
1677         (JSC::Structure::destroy):
1678         * runtime/StructureChain.cpp:
1679         (JSC::StructureChain::destroy): Use static_cast instead of jsCast because
1680         jsCast does Structure-based validation, and our Structure is not guaranteed
1681         to be alive when we get finalized.
1682
1683 2012-05-22  Filip Pizlo  <fpizlo@apple.com>
1684
1685         DFG CSE should eliminate redundant WeakJSConstants
1686         https://bugs.webkit.org/show_bug.cgi?id=87179
1687
1688         Reviewed by Gavin Barraclough.
1689         
1690         Merged r118141 from dfgopt.
1691
1692         * dfg/DFGCSEPhase.cpp:
1693         (JSC::DFG::CSEPhase::weakConstantCSE):
1694         (CSEPhase):
1695         (JSC::DFG::CSEPhase::performNodeCSE):
1696         * dfg/DFGNode.h:
1697         (JSC::DFG::Node::weakConstant):
1698
1699 2012-05-22  Filip Pizlo  <fpizlo@apple.com>
1700
1701         DFG CSE should do redundant store elimination
1702         https://bugs.webkit.org/show_bug.cgi?id=87161
1703
1704         Reviewed by Oliver Hunt.
1705         
1706         Merge r118138 from dfgopt.
1707         
1708         This patch adds redundant store elimination. For example, consider this
1709         code:
1710         
1711         o.x = 42;
1712         o.x = 84;
1713         
1714         If o.x is speculated to be a well-behaved field, the first assignment is
1715         unnecessary, since the second just overwrites it. We would like to
1716         eliminate the first assignment in these cases. The need for this
1717         optimization arises mostly from stores that our runtime requires. For
1718         example:
1719         
1720         o = {f:1, g:2, h:3};
1721         
1722         This will have four assignments to the structure for the newly created
1723         object - one assignment for the empty structure, one for {f}, one for
1724         {f, g}, and one for {f, g, h}. We would like to only have the last of
1725         those assigments in this case.
1726         
1727         Intriguingly, doing so for captured variables breaks the way arguments
1728         simplification used to work. Consider that prior to either arguments
1729         simplification or store elimination we will have IR that looks like:
1730         
1731         a: SetLocal(r0, Empty)
1732         b: SetLocal(r1, Empty)
1733         c: GetLocal(r0)
1734         d: CreateArguments(@c)
1735         e: SetLocal(r0, @d)
1736         f: SetLocal(r1, @d)
1737         
1738         Then redundant store elimination will eliminate the stores that
1739         initialize the arguments registers to Empty, but then arguments
1740         simplification eliminates the stores that initialize the arguments to
1741         the newly created arguments - and at this point we no longer have any
1742         stores to the arguments register, leading to hilarious crashes. This
1743         patch therefore changes arguments simplification to replace
1744         CreateArguments with JSConstant(Empty) rather than eliminating the
1745         SetLocals. But this revealed bugs where arguments simplification was
1746         being overzealous, so I fixed those bugs.
1747         
1748         This is a minor speed-up on V8/early and a handful of other tests.
1749
1750         * bytecode/CodeBlock.h:
1751         (JSC::CodeBlock::uncheckedActivationRegister):
1752         * dfg/DFGAbstractState.cpp:
1753         (JSC::DFG::AbstractState::execute):
1754         * dfg/DFGArgumentsSimplificationPhase.cpp:
1755         (JSC::DFG::ArgumentsSimplificationPhase::run):
1756         (JSC::DFG::ArgumentsSimplificationPhase::observeBadArgumentsUse):
1757         (JSC::DFG::ArgumentsSimplificationPhase::observeBadArgumentsUses):
1758         (JSC::DFG::ArgumentsSimplificationPhase::observeProperArgumentsUse):
1759         * dfg/DFGCSEPhase.cpp:
1760         (JSC::DFG::CSEPhase::globalVarStoreElimination):
1761         (CSEPhase):
1762         (JSC::DFG::CSEPhase::putStructureStoreElimination):
1763         (JSC::DFG::CSEPhase::putByOffsetStoreElimination):
1764         (JSC::DFG::CSEPhase::setLocalStoreElimination):
1765         (JSC::DFG::CSEPhase::setReplacement):
1766         (JSC::DFG::CSEPhase::eliminate):
1767         (JSC::DFG::CSEPhase::performNodeCSE):
1768         * dfg/DFGGraph.h:
1769         (JSC::DFG::Graph::uncheckedActivationRegisterFor):
1770         (Graph):
1771         * dfg/DFGNode.h:
1772         (JSC::DFG::Node::isPhantomArguments):
1773         (Node):
1774         (JSC::DFG::Node::hasConstant):
1775         (JSC::DFG::Node::valueOfJSConstant):
1776         (JSC::DFG::Node::hasStructureTransitionData):
1777         * dfg/DFGNodeType.h:
1778         (DFG):
1779         * dfg/DFGPredictionPropagationPhase.cpp:
1780         (JSC::DFG::PredictionPropagationPhase::propagate):
1781         * dfg/DFGSpeculativeJIT.cpp:
1782         (JSC::DFG::SpeculativeJIT::computeValueRecoveryFor):
1783         * dfg/DFGSpeculativeJIT32_64.cpp:
1784         (JSC::DFG::SpeculativeJIT::compile):
1785         * dfg/DFGSpeculativeJIT64.cpp:
1786         (JSC::DFG::SpeculativeJIT::compile):
1787
1788 2012-05-21  Filip Pizlo  <fpizlo@apple.com>
1789
1790         DFG ConvertThis should just be a CheckStructure if the structure is known
1791         https://bugs.webkit.org/show_bug.cgi?id=87057
1792
1793         Reviewed by Gavin Barraclough.
1794         
1795         Merged r118021 from dfgopt.
1796         
1797         This gives ValueProfile the ability to track singleton values - i.e. profiling
1798         sites that always see the same value.
1799         
1800         That is then used to profile the structure in op_convert_this.
1801         
1802         This is then used to optimize op_convert_this into a CheckStructure if the
1803         structure is always the same.
1804         
1805         That then results in better CSE in inlined code that uses 'this', since
1806         previously we couldn't CSE accesses on 'this' from different inline call frames.
1807         
1808         Also fixed a bug where we were unnecessarily flushing 'this'.
1809
1810         * bytecode/CodeBlock.cpp:
1811         (JSC::CodeBlock::dump):
1812         (JSC::CodeBlock::stronglyVisitStrongReferences):
1813         * bytecode/LazyOperandValueProfile.cpp:
1814         (JSC::CompressedLazyOperandValueProfileHolder::computeUpdatedPredictions):
1815         * bytecode/LazyOperandValueProfile.h:
1816         (CompressedLazyOperandValueProfileHolder):
1817         * bytecode/Opcode.h:
1818         (JSC):
1819         (JSC::padOpcodeName):
1820         * bytecode/ValueProfile.h:
1821         (JSC::ValueProfileBase::ValueProfileBase):
1822         (JSC::ValueProfileBase::dump):
1823         (JSC::ValueProfileBase::computeUpdatedPrediction):
1824         (ValueProfileBase):
1825         * bytecompiler/BytecodeGenerator.cpp:
1826         (JSC::BytecodeGenerator::BytecodeGenerator):
1827         * dfg/DFGByteCodeParser.cpp:
1828         (JSC::DFG::ByteCodeParser::setArgument):
1829         (JSC::DFG::ByteCodeParser::parseBlock):
1830         * jit/JITOpcodes.cpp:
1831         (JSC::JIT::emit_op_convert_this):
1832         (JSC::JIT::emitSlow_op_convert_this):
1833         * jit/JITOpcodes32_64.cpp:
1834         (JSC::JIT::emit_op_convert_this):
1835         (JSC::JIT::emitSlow_op_convert_this):
1836         * llint/LLIntSlowPaths.cpp:
1837         (JSC::LLInt::LLINT_SLOW_PATH_DECL):
1838         * llint/LowLevelInterpreter32_64.asm:
1839         * llint/LowLevelInterpreter64.asm:
1840         * runtime/JSValue.h:
1841         (JSValue):
1842         * runtime/Structure.h:
1843         (JSC::JSValue::structureOrUndefined):
1844         (JSC):
1845
1846 2012-05-24  Tim Horton  <timothy_horton@apple.com>
1847
1848         Add feature defines for web-facing parts of CSS Regions and Exclusions
1849         https://bugs.webkit.org/show_bug.cgi?id=87442
1850         <rdar://problem/10887709>
1851
1852         Reviewed by Dan Bernstein.
1853
1854         * Configurations/FeatureDefines.xcconfig:
1855
1856 2012-05-24  Geoffrey Garen  <ggaren@apple.com>
1857
1858         WebKit should be lazy-finalization-safe (esp. the DOM)
1859         https://bugs.webkit.org/show_bug.cgi?id=87456
1860
1861         Reviewed by Filip Pizlo.
1862
1863         Lazy finalization adds one twist to weak pointer use:
1864
1865                 A HashMap of weak pointers may contain logically null entries.
1866                 (Weak pointers behave as-if null once their payloads die.)
1867                 Insertion must not assume that a pre-existing entry is
1868                 necessarily valid, and iteration must not assume that all
1869                 entries can be dereferenced.
1870
1871         (Previously, I thought that it also added a second twist:
1872
1873                 A demand-allocated weak pointer may replace a dead payload
1874                 before the payload's finalizer runs. In that case, when the
1875                 payload's finalizer runs, the payload has already been
1876                 overwritten, and the finalizer should not clear the payload,
1877                 which now points to something new.
1878
1879         But that's not the case here, since we cancel the old payload's
1880         finalizer when we over-write it. I've added ASSERTs to verify this
1881         assumption, in case it ever changes.)
1882
1883         * API/JSClassRef.cpp:
1884         (OpaqueJSClass::prototype): No need to specify null; that's the default.
1885
1886         * API/JSWeakObjectMapRefPrivate.cpp: Use remove, since take() is gone.
1887
1888         * heap/PassWeak.h:
1889         (WeakImplAccessor::was): This is no longer a debug-only function, since
1890         it's required to reason about lazily finalized pointers.
1891
1892         * heap/Weak.h:
1893         (JSC::weakAdd):
1894         (JSC::weakRemove):
1895         (JSC::weakClear): Added these helper functions for the common idioms of
1896         what clients want to do in their weak pointer finalizers.
1897
1898         * jit/JITStubs.cpp:
1899         (JSC::JITThunks::hostFunctionStub): Use the new idioms. Otherwise, we
1900         would return NULL for a "zombie" executable weak pointer that was waiting
1901         for finalization (item (2)), and finalizing a dead executable weak pointer
1902         would potentially destroy a new, live one (item (1)).
1903
1904         * runtime/RegExpCache.cpp:
1905         (JSC::RegExpCache::lookupOrCreate):
1906         (JSC::RegExpCache::finalize): Ditto.
1907
1908         (JSC::RegExpCache::invalidateCode): Check for null while iterating. (See
1909         item (2).)
1910
1911         * runtime/Structure.cpp:
1912         (JSC::StructureTransitionTable::contains):
1913         (JSC::StructureTransitionTable::add): Use get and set instead of add and
1914         contains, since add and contains are not compatible with lazy finalization.
1915
1916         * runtime/WeakGCMap.h:
1917         (WeakGCMap):
1918         (JSC::WeakGCMap::clear):
1919         (JSC::WeakGCMap::remove): Removed a bunch of code that was incompatible with
1920         lazy finalization because I didn't feel like making it compatible, and I had
1921         no way to test it.
1922
1923 2012-05-24  Filip Pizlo  <fpizlo@apple.com>
1924
1925         REGRESSION (r118013-r118031): Loops/Reloads under www.yahoo.com, quits after three tries with error
1926         https://bugs.webkit.org/show_bug.cgi?id=87327
1927
1928         Reviewed by Geoffrey Garen.
1929         
1930         If you use AbstractValue::filter(StructureSet) to test subset relationships between TOP and a
1931         set containing >=2 elements, you're going to have a bad time.
1932         
1933         That's because AbstractValue considers a set with >=2 elements to be equivalent to TOP, in order
1934         to save space and speed up convergence. So filtering has no effect in this case, which made
1935         the code think that the abstract value was proving that the structure check was unnecessary.
1936         The correct thing to do is to use isSubsetOf() on the StructureAbstractValue, which does the
1937         right thingies for TOP and >=2 elements.
1938
1939         * dfg/DFGAbstractState.cpp:
1940         (JSC::DFG::AbstractState::execute):
1941         * dfg/DFGSpeculativeJIT32_64.cpp:
1942         (JSC::DFG::SpeculativeJIT::compile):
1943         * dfg/DFGSpeculativeJIT64.cpp:
1944         (JSC::DFG::SpeculativeJIT::compile):
1945
1946 2012-05-24  Filip Pizlo  <fpizlo@apple.com>
1947
1948         new test fast/js/dfg-arguments-mixed-alias.html fails on JSVALUE32_64
1949         https://bugs.webkit.org/show_bug.cgi?id=87378
1950
1951         Reviewed by Gavin Barraclough.
1952         
1953         - Captured variable tracking forgot did not consistently handle arguments, leading to OSR
1954           badness.
1955         
1956         - Nodes capable of exiting were tracked in a non-monotonic way, leading to compiler errors.
1957
1958         * dfg/DFGByteCodeParser.cpp:
1959         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
1960         * dfg/DFGCSEPhase.cpp:
1961         (JSC::DFG::CSEPhase::CSEPhase):
1962         (CSEPhase):
1963         (JSC::DFG::performCSE):
1964         * dfg/DFGCSEPhase.h:
1965         (DFG):
1966         * dfg/DFGCommon.h:
1967         * dfg/DFGDriver.cpp:
1968         (JSC::DFG::compile):
1969         * dfg/DFGGraph.cpp:
1970         (JSC::DFG::Graph::resetExitStates):
1971         (DFG):
1972         * dfg/DFGGraph.h:
1973         (Graph):
1974         * dfg/DFGPhase.h:
1975         (DFG):
1976         (JSC::DFG::runPhase):
1977
1978 2012-05-24  Geoffrey Garen  <ggaren@apple.com>
1979
1980         Made WeakSet per-block instead of per-heap
1981         https://bugs.webkit.org/show_bug.cgi?id=87401
1982
1983         Reviewed by Oliver Hunt.
1984
1985         This allows us fast access to the set of all weak pointers for a block,
1986         which is a step toward lazy finalization.
1987
1988         No performance change.
1989
1990         * heap/Heap.cpp:
1991         (JSC::Heap::Heap):
1992         (JSC::Heap::lastChanceToFinalize): Removed the per-heap weak set, since
1993         it's per-block now.
1994
1995         (JSC::Heap::markRoots): Delegate weak set visiting to the marked space,
1996         since it knows how to iterate all blocks.
1997
1998         (JSC::Heap::collect): Moved the reaping outside of markRoots, since it
1999         doesn't mark anything.
2000
2001         Make sure to reset allocators after shrinking, since shrinking may
2002         deallocate the current allocator.
2003
2004         * heap/Heap.h:
2005         (Heap): No more per-heap weak set, since it's per-block now.
2006
2007         * heap/MarkedBlock.cpp:
2008         (JSC::MarkedBlock::MarkedBlock):
2009         * heap/MarkedBlock.h:
2010         (MarkedBlock):
2011         (JSC::MarkedBlock::lastChanceToFinalize): Migrated finalization logic
2012         here from the heap, so the heap doesn't need to know about our internal
2013         data structures like our weak set.
2014
2015         (JSC::MarkedBlock::heap):
2016         (JSC::MarkedBlock::weakSet):
2017         (JSC::MarkedBlock::shrink):
2018         (JSC::MarkedBlock::resetAllocator):
2019         (JSC::MarkedBlock::visitWeakSet):
2020         (JSC::MarkedBlock::reapWeakSet):
2021         (JSC::MarkedBlock::sweepWeakSet):
2022         * heap/MarkedSpace.cpp:
2023         (JSC::VisitWeakSet::VisitWeakSet):
2024         (JSC::VisitWeakSet::operator()):
2025         (VisitWeakSet):
2026         (JSC):
2027         (JSC::ReapWeakSet::operator()):
2028         (JSC::SweepWeakSet::operator()):
2029         (JSC::LastChanceToFinalize::operator()):
2030         (JSC::MarkedSpace::lastChanceToFinalize):
2031         (JSC::ResetAllocator::operator()):
2032         (JSC::MarkedSpace::resetAllocators):
2033         (JSC::MarkedSpace::visitWeakSets):
2034         (JSC::MarkedSpace::reapWeakSets):
2035         (JSC::MarkedSpace::sweepWeakSets):
2036         (JSC::Shrink::operator()):
2037         (JSC::MarkedSpace::shrink):
2038         * heap/MarkedSpace.h:
2039         (MarkedSpace): Make sure to account for our weak sets when sweeping,
2040         shrinking, etc.
2041
2042         * heap/WeakSet.cpp:
2043         (JSC):
2044         * heap/WeakSet.h:
2045         (WeakSet):
2046         (JSC::WeakSet::heap):
2047         (JSC):
2048         (JSC::WeakSet::lastChanceToFinalize):
2049         (JSC::WeakSet::visit):
2050         (JSC::WeakSet::reap):
2051         (JSC::WeakSet::shrink):
2052         (JSC::WeakSet::resetAllocator): Inlined some things since they're called
2053         once per block now instead of once per heap.
2054
2055         * heap/WeakSetInlines.h:
2056         (JSC::WeakSet::allocate): Use the per-block weak set since there is no
2057         per-heap weak set anymore.
2058
2059 2012-05-24  Gavin Barraclough  <barraclough@apple.com>
2060
2061         Fix arm build
2062
2063         Rubber stamped by Geoff Garen
2064
2065         * dfg/DFGGPRInfo.h:
2066         (GPRInfo):
2067
2068 2012-05-24  Gavin Barraclough  <barraclough@apple.com>
2069
2070         Move cacheFlush from ExecutableAllocator to Assembler classes
2071         https://bugs.webkit.org/show_bug.cgi?id=87420
2072
2073         Reviewed by Oliver Hunt.
2074
2075         Makes more sense there, & remove a pile of #ifdefs.
2076
2077         * assembler/ARMAssembler.cpp:
2078         (JSC):
2079         (JSC::ARMAssembler::cacheFlush):
2080         * assembler/ARMAssembler.h:
2081         (ARMAssembler):
2082         (JSC::ARMAssembler::cacheFlush):
2083         * assembler/ARMv7Assembler.h:
2084         (JSC::ARMv7Assembler::relinkJump):
2085         (JSC::ARMv7Assembler::cacheFlush):
2086         (ARMv7Assembler):
2087         (JSC::ARMv7Assembler::setInt32):
2088         (JSC::ARMv7Assembler::setUInt7ForLoad):
2089         * assembler/AbstractMacroAssembler.h:
2090         (JSC::AbstractMacroAssembler::cacheFlush):
2091         * assembler/LinkBuffer.h:
2092         (JSC::LinkBuffer::performFinalization):
2093         * assembler/MIPSAssembler.h:
2094         (JSC::MIPSAssembler::relinkJump):
2095         (JSC::MIPSAssembler::relinkCall):
2096         (JSC::MIPSAssembler::repatchInt32):
2097         (JSC::MIPSAssembler::cacheFlush):
2098         (MIPSAssembler):
2099         * assembler/SH4Assembler.h:
2100         (JSC::SH4Assembler::repatchCompact):
2101         (JSC::SH4Assembler::cacheFlush):
2102         (SH4Assembler):
2103         * assembler/X86Assembler.h:
2104         (X86Assembler):
2105         (JSC::X86Assembler::cacheFlush):
2106         * jit/ExecutableAllocator.cpp:
2107         (JSC):
2108         * jit/ExecutableAllocator.h:
2109         (ExecutableAllocator):
2110
2111 2012-05-24  John Mellor  <johnme@chromium.org>
2112
2113         Font Boosting: Add compile flag and runtime setting
2114         https://bugs.webkit.org/show_bug.cgi?id=87394
2115
2116         Reviewed by Adam Barth.
2117
2118         Add ENABLE_FONT_BOOSTING.
2119
2120         * Configurations/FeatureDefines.xcconfig:
2121
2122 2012-05-24  Allan Sandfeld Jensen  <allan.jensen@nokia.com>
2123
2124         cti_vm_throw gets kicked out by gcc 4.6 -flto
2125         https://bugs.webkit.org/show_bug.cgi?id=56088
2126
2127         Reviewed by Darin Adler.
2128
2129         Add REFERENCED_FROM_ASM to functions only referenced from assembler.
2130
2131         * dfg/DFGOperations.cpp:
2132         * jit/HostCallReturnValue.h:
2133         * jit/JITStubs.h:
2134         * jit/ThunkGenerators.cpp:
2135
2136 2012-05-24  Filip Pizlo  <fpizlo@apple.com>
2137
2138         Incorrect merge of r117542 from dfg opt branch in r118323 is leading to fast/js/dfg-arguments-osr-exit.html failing
2139         https://bugs.webkit.org/show_bug.cgi?id=87350
2140
2141         Reviewed by Maciej Stachowiak.
2142         
2143         The dfgopt branch introduced the notion of a local variable being killed because it was aliased
2144         to the Arguments object as in cases like:
2145         
2146         var a = arguments;
2147         return a.length;
2148         
2149         This required changes to OSR exit handling - if the variable is dead but aliased to arguments, then
2150         OSR exit should reify the arguments. But meanwhile, in tip of tree we introduced special handling for
2151         dead variables on OSR exit. When the two were merged in r118323, the structure of the if/else branches
2152         ended up being such that we would treat dead arguments variables as totally dead as opposed to treating
2153         them as variables that need arguments reification.
2154         
2155         This fixes the structure of the relevant if/else block so that variables that are dead-but-arguments
2156         end up being treated as reified arguments objects, while variables that are dead but not aliased to
2157         arguments are treated as tip of tree would have treated them (initialize to Undefined).
2158
2159         * dfg/DFGSpeculativeJIT.cpp:
2160         (JSC::DFG::SpeculativeJIT::compile):
2161
2162 2012-05-24  Csaba Osztrogonác  <ossy@webkit.org>
2163
2164         Unreviewed 32 bit buildfix after r118325.
2165
2166         * dfg/DFGSpeculativeJIT32_64.cpp:
2167         (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal): Use ASSERT_UNUSED instead ASSERT.
2168
2169 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2170
2171         DFG operationTearOffActivation should return after handling the null activation case
2172         https://bugs.webkit.org/show_bug.cgi?id=87348
2173         <rdar://problem/11522295>
2174
2175         Reviewed by Oliver Hunt.
2176
2177         * dfg/DFGOperations.cpp:
2178
2179 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2180
2181         Unreviewed, merge the arguments fix in r118138 to get bots green.
2182
2183         * dfg/DFGArgumentsSimplificationPhase.cpp:
2184         (JSC::DFG::ArgumentsSimplificationPhase::observeBadArgumentsUse):
2185
2186 2012-05-20  Filip Pizlo  <fpizlo@apple.com>
2187
2188         DFG CFA should record if a node can OSR exit
2189         https://bugs.webkit.org/show_bug.cgi?id=86905
2190
2191         Reviewed by Oliver Hunt.
2192         
2193         Merged r117931 from dfgopt.
2194         
2195         Adds a NodeFlag that denotes nodes that are known to not have OSR exits.
2196         This ought to aid any backwards analyses that need to know when a
2197         backward flow merge might happen due to a side exit.
2198         
2199         Also added assertions into speculationCheck() that ensure that we did not
2200         mark a node as non-exiting and then promptly compile in an exit. This
2201         helped catch some minor bugs where we were doing unnecessary speculation
2202         checks.
2203         
2204         This is a perf-neutral change. The speculation checks that this removes
2205         were not on hot paths of major benchmarks.
2206
2207         * bytecode/PredictedType.h:
2208         (JSC):
2209         (JSC::isAnyPrediction):
2210         * dfg/DFGAbstractState.cpp:
2211         (JSC::DFG::AbstractState::execute):
2212         * dfg/DFGAbstractState.h:
2213         (JSC::DFG::AbstractState::speculateInt32Unary):
2214         (AbstractState):
2215         (JSC::DFG::AbstractState::speculateNumberUnary):
2216         (JSC::DFG::AbstractState::speculateBooleanUnary):
2217         (JSC::DFG::AbstractState::speculateInt32Binary):
2218         (JSC::DFG::AbstractState::speculateNumberBinary):
2219         * dfg/DFGNode.h:
2220         (JSC::DFG::Node::mergeFlags):
2221         (JSC::DFG::Node::filterFlags):
2222         (Node):
2223         (JSC::DFG::Node::setCanExit):
2224         (JSC::DFG::Node::canExit):
2225         * dfg/DFGNodeFlags.cpp:
2226         (JSC::DFG::nodeFlagsAsString):
2227         * dfg/DFGNodeFlags.h:
2228         (DFG):
2229         * dfg/DFGSpeculativeJIT.cpp:
2230         (JSC::DFG::SpeculativeJIT::SpeculativeJIT):
2231         (JSC::DFG::SpeculativeJIT::checkArgumentTypes):
2232         (JSC::DFG::SpeculativeJIT::compileValueToInt32):
2233         * dfg/DFGSpeculativeJIT.h:
2234         (JSC::DFG::SpeculativeJIT::speculationCheck):
2235         (JSC::DFG::SpeculativeJIT::forwardSpeculationCheck):
2236         (JSC::DFG::SpeculativeJIT::terminateSpeculativeExecution):
2237         (SpeculativeJIT):
2238         * dfg/DFGSpeculativeJIT32_64.cpp:
2239         (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
2240         (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
2241         (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
2242         (JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
2243         (JSC::DFG::SpeculativeJIT::compile):
2244         * dfg/DFGSpeculativeJIT64.cpp:
2245         (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
2246         (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
2247         (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
2248         (JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
2249         (JSC::DFG::SpeculativeJIT::compile):
2250
2251 2012-05-20  Filip Pizlo  <fpizlo@apple.com>
2252
2253         DFG should not do unnecessary indirections when storing to objects
2254         https://bugs.webkit.org/show_bug.cgi?id=86959
2255
2256         Reviewed by Oliver Hunt.
2257         
2258         Merged r117819 from dfgopt.
2259
2260         * dfg/DFGByteCodeParser.cpp:
2261         (JSC::DFG::ByteCodeParser::parseBlock):
2262         * dfg/DFGCSEPhase.cpp:
2263         (JSC::DFG::CSEPhase::getByOffsetLoadElimination):
2264         * dfg/DFGSpeculativeJIT32_64.cpp:
2265         (JSC::DFG::SpeculativeJIT::compile):
2266         * dfg/DFGSpeculativeJIT64.cpp:
2267         (JSC::DFG::SpeculativeJIT::compile):
2268
2269 2012-05-17  Filip Pizlo  <fpizlo@apple.com>
2270
2271         DFG should optimize aliased uses of the Arguments object of the current call frame
2272         https://bugs.webkit.org/show_bug.cgi?id=86552
2273
2274         Reviewed by Geoff Garen.
2275         
2276         Merged r117542 and r117543 from dfgopt.
2277         
2278         Performs must-alias and escape analysis on uses of CreateArguments, and if
2279         a variable is must-aliased to CreateArguments and does not escape, then we
2280         turn all uses of that variable into direct arguments accesses.
2281         
2282         36% speed-up on V8/earley leading to a 2.3% speed-up overall in V8.
2283
2284         * bytecode/CodeBlock.h:
2285         (JSC::CodeBlock::uncheckedArgumentsRegister):
2286         * bytecode/ValueRecovery.h:
2287         (JSC::ValueRecovery::argumentsThatWereNotCreated):
2288         (ValueRecovery):
2289         (JSC::ValueRecovery::dump):
2290         * dfg/DFGAbstractState.cpp:
2291         (JSC::DFG::AbstractState::execute):
2292         * dfg/DFGAdjacencyList.h:
2293         (AdjacencyList):
2294         (JSC::DFG::AdjacencyList::removeEdgeFromBag):
2295         * dfg/DFGArgumentsSimplificationPhase.cpp:
2296         (JSC::DFG::ArgumentsSimplificationPhase::run):
2297         (ArgumentsSimplificationPhase):
2298         (JSC::DFG::ArgumentsSimplificationPhase::observeBadArgumentsUse):
2299         (JSC::DFG::ArgumentsSimplificationPhase::observeBadArgumentsUses):
2300         (JSC::DFG::ArgumentsSimplificationPhase::observeProperArgumentsUse):
2301         (JSC::DFG::ArgumentsSimplificationPhase::isOKToOptimize):
2302         (JSC::DFG::ArgumentsSimplificationPhase::removeArgumentsReferencingPhantomChild):
2303         * dfg/DFGAssemblyHelpers.h:
2304         (JSC::DFG::AssemblyHelpers::argumentsRegisterFor):
2305         (AssemblyHelpers):
2306         * dfg/DFGByteCodeParser.cpp:
2307         (JSC::DFG::ByteCodeParser::parseBlock):
2308         * dfg/DFGCFGSimplificationPhase.cpp:
2309         (JSC::DFG::CFGSimplificationPhase::removePotentiallyDeadPhiReference):
2310         * dfg/DFGGPRInfo.h:
2311         (GPRInfo):
2312         * dfg/DFGGraph.cpp:
2313         (JSC::DFG::Graph::collectGarbage):
2314         (DFG):
2315         * dfg/DFGGraph.h:
2316         (Graph):
2317         (JSC::DFG::Graph::executableFor):
2318         (JSC::DFG::Graph::argumentsRegisterFor):
2319         (JSC::DFG::Graph::uncheckedArgumentsRegisterFor):
2320         (JSC::DFG::Graph::clobbersWorld):
2321         * dfg/DFGNode.h:
2322         (JSC::DFG::Node::hasHeapPrediction):
2323         * dfg/DFGNodeType.h:
2324         (DFG):
2325         * dfg/DFGOSRExitCompiler.cpp:
2326         * dfg/DFGOSRExitCompiler.h:
2327         (JSC::DFG::OSRExitCompiler::OSRExitCompiler):
2328         (OSRExitCompiler):
2329         * dfg/DFGOSRExitCompiler32_64.cpp:
2330         (JSC::DFG::OSRExitCompiler::compileExit):
2331         * dfg/DFGOSRExitCompiler64.cpp:
2332         (JSC::DFG::OSRExitCompiler::compileExit):
2333         * dfg/DFGOperations.cpp:
2334         * dfg/DFGPredictionPropagationPhase.cpp:
2335         (JSC::DFG::PredictionPropagationPhase::propagate):
2336         * dfg/DFGSpeculativeJIT.cpp:
2337         (JSC::DFG::ValueSource::dump):
2338         (JSC::DFG::SpeculativeJIT::compile):
2339         (JSC::DFG::SpeculativeJIT::computeValueRecoveryFor):
2340         * dfg/DFGSpeculativeJIT.h:
2341         * dfg/DFGSpeculativeJIT32_64.cpp:
2342         (JSC::DFG::SpeculativeJIT::compile):
2343         * dfg/DFGSpeculativeJIT64.cpp:
2344         (JSC::DFG::SpeculativeJIT::compile):
2345         * dfg/DFGVariableAccessData.h:
2346         (JSC::DFG::VariableAccessData::VariableAccessData):
2347         (JSC::DFG::VariableAccessData::mergeIsArgumentsAlias):
2348         (VariableAccessData):
2349         (JSC::DFG::VariableAccessData::isArgumentsAlias):
2350         * jit/JITOpcodes.cpp:
2351         (JSC::JIT::emitSlow_op_get_argument_by_val):
2352
2353 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2354
2355         DFGCapabilities should not try to get an arguments register from code blocks that don't have one
2356         https://bugs.webkit.org/show_bug.cgi?id=87332
2357
2358         Reviewed by Andy Estes.
2359
2360         * dfg/DFGCapabilities.h:
2361         (JSC::DFG::canInlineOpcode):
2362
2363 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2364
2365         DFG should have sparse conditional constant propagation
2366         https://bugs.webkit.org/show_bug.cgi?id=86580
2367
2368         Reviewed by Oliver Hunt.
2369         
2370         Merged r117370 from dfgopt.
2371         
2372         This enhances CFA so that if it suspects at any point during the fixpoint that a
2373         branch will only go one way, then it only propagates in that one way.
2374         
2375         This vastly increases the opportunities for CFG simplification. For example, it
2376         enables us to evaporate this loop:
2377         
2378         for (var i = 0; i < 1; ++i) doThings(i);
2379         
2380         As a result, it uncovered loads of bugs in the CFG simplifier. In particular:
2381         
2382         - Phi fixup was assuming that all Phis worth fixing up are shouldGenerate().
2383           That's not true; we also fixup Phis that are dead.
2384           
2385         - GetLocal fixup was assuming that it's only necessary to rewire links to a
2386           GetLocal, and that the GetLocal's own links don't need to be rewired. Untrue,
2387           because the GetLocal may not be rewirable (first block has no GetLocal for r42
2388           but second block does have a GetLocal), in which case it will refer to a Phi
2389           in the second block. We need it to refer to a Phi from the first block to
2390           ensure that subsequent transformations work.
2391           
2392         - Tail operand fixup was ignoring the fact that Phis in successors may contain
2393           references to the children of our tail variables. Hence, successor Phi child
2394           substitution needs to use the original second block variable table as its
2395           prior, rather than trying to reconstruct the prior later (since by that point
2396           the children of the second block's tail variables will have been fixed up, so
2397           we will not know what the prior would have been).
2398
2399         * dfg/DFGAbstractState.cpp:
2400         (JSC::DFG::AbstractState::beginBasicBlock):
2401         (JSC::DFG::AbstractState::endBasicBlock):
2402         (JSC::DFG::AbstractState::reset):
2403         (JSC::DFG::AbstractState::execute):
2404         (JSC::DFG::AbstractState::mergeToSuccessors):
2405         * dfg/DFGAbstractState.h:
2406         (JSC::DFG::AbstractState::branchDirectionToString):
2407         (AbstractState):
2408         * dfg/DFGCFGSimplificationPhase.cpp:
2409         (JSC::DFG::CFGSimplificationPhase::run):
2410         (JSC::DFG::CFGSimplificationPhase::removePotentiallyDeadPhiReference):
2411         (JSC::DFG::CFGSimplificationPhase::OperandSubstitution::OperandSubstitution):
2412         (OperandSubstitution):
2413         (JSC::DFG::CFGSimplificationPhase::skipGetLocal):
2414         (JSC::DFG::CFGSimplificationPhase::recordPossibleIncomingReference):
2415         (CFGSimplificationPhase):
2416         (JSC::DFG::CFGSimplificationPhase::fixTailOperand):
2417         (JSC::DFG::CFGSimplificationPhase::mergeBlocks):
2418         * dfg/DFGGraph.h:
2419         (JSC::DFG::Graph::changeEdge):
2420
2421 2012-05-23  Ojan Vafai  <ojan@chromium.org>
2422
2423         add back the ability to disable flexbox
2424         https://bugs.webkit.org/show_bug.cgi?id=87147
2425
2426         Reviewed by Tony Chang.
2427
2428         * Configurations/FeatureDefines.xcconfig:
2429
2430 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2431
2432         Unreviewed, fix Windows build.
2433
2434         * bytecode/CodeBlock.h:
2435         * dfg/DFGCapabilities.h:
2436         (JSC::DFG::canCompileOpcode):
2437         (JSC::DFG::canCompileOpcodes):
2438         * dfg/DFGCommon.h:
2439         (DFG):
2440
2441 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2442
2443         DFG should optimize inlined uses of arguments.length and arguments[i]
2444         https://bugs.webkit.org/show_bug.cgi?id=86327
2445
2446         Reviewed by Gavin Barraclough.
2447         
2448         Merged r117017 from dfgopt.
2449         
2450         Turns inlined uses of arguments.length into a constant.
2451         
2452         Turns inlined uses of arguments[constant] into a direct reference to the
2453         argument.
2454         
2455         Big win on micro-benchmarks. Not yet a win on V8 because the hot uses of
2456         arguments.length and arguments[i] are aliased. I'll leave the aliasing
2457         optimizations to a later patch.
2458
2459         * CMakeLists.txt:
2460         * GNUmakefile.list.am:
2461         * JavaScriptCore.xcodeproj/project.pbxproj:
2462         * Target.pri:
2463         * bytecode/DFGExitProfile.h:
2464         (FrequentExitSite):
2465         (JSC::DFG::FrequentExitSite::FrequentExitSite):
2466         (JSC::DFG::QueryableExitProfile::hasExitSite):
2467         (QueryableExitProfile):
2468         * dfg/DFGAbstractState.cpp:
2469         (JSC::DFG::AbstractState::execute):
2470         * dfg/DFGArgumentsSimplificationPhase.cpp: Added.
2471         (DFG):
2472         (ArgumentsSimplificationPhase):
2473         (JSC::DFG::ArgumentsSimplificationPhase::ArgumentsSimplificationPhase):
2474         (JSC::DFG::ArgumentsSimplificationPhase::run):
2475         (JSC::DFG::performArgumentsSimplification):
2476         * dfg/DFGArgumentsSimplificationPhase.h: Added.
2477         (DFG):
2478         * dfg/DFGAssemblyHelpers.cpp:
2479         (JSC::DFG::AssemblyHelpers::executableFor):
2480         (DFG):
2481         * dfg/DFGAssemblyHelpers.h:
2482         (AssemblyHelpers):
2483         * dfg/DFGByteCodeParser.cpp:
2484         (JSC::DFG::ByteCodeParser::parseBlock):
2485         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2486         * dfg/DFGCSEPhase.cpp:
2487         (JSC::DFG::CSEPhase::getLocalLoadElimination):
2488         (JSC::DFG::CSEPhase::performNodeCSE):
2489         * dfg/DFGDriver.cpp:
2490         (JSC::DFG::compile):
2491         * dfg/DFGGraph.h:
2492         (JSC::DFG::Graph::Graph):
2493         (JSC::DFG::Graph::executableFor):
2494         (Graph):
2495         (JSC::DFG::Graph::clobbersWorld):
2496         * dfg/DFGNode.h:
2497         (JSC::DFG::Node::convertToConstant):
2498         (JSC::DFG::Node::convertToGetLocalUnlinked):
2499         (Node):
2500         (JSC::DFG::Node::unlinkedLocal):
2501         * dfg/DFGNodeType.h:
2502         (DFG):
2503         * dfg/DFGOSRExit.cpp:
2504         (JSC::DFG::OSRExit::considerAddingAsFrequentExitSiteSlow):
2505         * dfg/DFGPredictionPropagationPhase.cpp:
2506         (JSC::DFG::PredictionPropagationPhase::propagate):
2507         * dfg/DFGSpeculativeJIT32_64.cpp:
2508         (JSC::DFG::SpeculativeJIT::compile):
2509         * dfg/DFGSpeculativeJIT64.cpp:
2510         (JSC::DFG::SpeculativeJIT::compile):
2511
2512 2012-05-13  Filip Pizlo  <fpizlo@apple.com>
2513
2514         DFG should be able to optimize foo.apply(bar, arguments)
2515         https://bugs.webkit.org/show_bug.cgi?id=86306
2516
2517         Reviewed by Gavin Barraclough.
2518         
2519         Merge r116912 from dfgopt.
2520         
2521         Enables compilation of op_jneq_ptr and some forms of op_call_varargs.
2522         
2523         Also includes a bunch of bug fixes that were made necessary by the increased
2524         pressure on the CFG simplifier.
2525         
2526         This is a 1-2% win on V8.
2527
2528         * bytecode/CodeBlock.cpp:
2529         (JSC::CodeBlock::printCallOp):
2530         (JSC::CodeBlock::CodeBlock):
2531         (JSC::ProgramCodeBlock::canCompileWithDFGInternal):
2532         (JSC::EvalCodeBlock::canCompileWithDFGInternal):
2533         (JSC::FunctionCodeBlock::canCompileWithDFGInternal):
2534         * bytecode/CodeBlock.h:
2535         (CodeBlock):
2536         (JSC::CodeBlock::canCompileWithDFG):
2537         (JSC::CodeBlock::canCompileWithDFGState):
2538         (ProgramCodeBlock):
2539         (EvalCodeBlock):
2540         (FunctionCodeBlock):
2541         * dfg/DFGAbstractState.cpp:
2542         (JSC::DFG::AbstractState::execute):
2543         * dfg/DFGByteCodeParser.cpp:
2544         (JSC::DFG::ByteCodeParser::parseBlock):
2545         (JSC::DFG::ByteCodeParser::processPhiStack):
2546         (JSC::DFG::ByteCodeParser::parse):
2547         * dfg/DFGCFGSimplificationPhase.cpp:
2548         (JSC::DFG::CFGSimplificationPhase::run):
2549         (JSC::DFG::CFGSimplificationPhase::fixPossibleGetLocal):
2550         (JSC::DFG::CFGSimplificationPhase::fixTailOperand):
2551         (JSC::DFG::CFGSimplificationPhase::mergeBlocks):
2552         * dfg/DFGCSEPhase.cpp:
2553         (JSC::DFG::CSEPhase::getLocalLoadElimination):
2554         (CSEPhase):
2555         (JSC::DFG::CSEPhase::setReplacement):
2556         (JSC::DFG::CSEPhase::performNodeCSE):
2557         * dfg/DFGCapabilities.cpp:
2558         (JSC::DFG::debugFail):
2559         (DFG):
2560         (JSC::DFG::canHandleOpcodes):
2561         (JSC::DFG::canCompileOpcodes):
2562         (JSC::DFG::canInlineOpcodes):
2563         * dfg/DFGCapabilities.h:
2564         (JSC::DFG::canCompileOpcode):
2565         (JSC::DFG::canInlineOpcode):
2566         (DFG):
2567         (JSC::DFG::canCompileOpcodes):
2568         (JSC::DFG::canCompileEval):
2569         (JSC::DFG::canCompileProgram):
2570         (JSC::DFG::canCompileFunctionForCall):
2571         (JSC::DFG::canCompileFunctionForConstruct):
2572         * dfg/DFGCommon.h:
2573         * dfg/DFGGraph.cpp:
2574         (JSC::DFG::Graph::dump):
2575         * dfg/DFGNodeType.h:
2576         (DFG):
2577         * dfg/DFGPredictionPropagationPhase.cpp:
2578         (JSC::DFG::PredictionPropagationPhase::propagate):
2579         * dfg/DFGSpeculativeJIT32_64.cpp:
2580         (JSC::DFG::SpeculativeJIT::compile):
2581         * dfg/DFGSpeculativeJIT64.cpp:
2582         (JSC::DFG::SpeculativeJIT::emitCall):
2583         (JSC::DFG::SpeculativeJIT::compile):
2584         * dfg/DFGValidate.cpp:
2585         (Validate):
2586         (JSC::DFG::Validate::validate):
2587         (JSC::DFG::Validate::checkOperand):
2588         (JSC::DFG::Validate::reportValidationContext):
2589         * jit/JIT.cpp:
2590         (JSC::JIT::emitOptimizationCheck):
2591         (JSC::JIT::privateCompileSlowCases):
2592         (JSC::JIT::privateCompile):
2593         * jit/JIT.h:
2594         * jit/JITArithmetic.cpp:
2595         (JSC::JIT::compileBinaryArithOp):
2596         * jit/JITPropertyAccess.cpp:
2597         (JSC::JIT::privateCompilePutByIdTransition):
2598         * jit/JITPropertyAccess32_64.cpp:
2599         (JSC::JIT::privateCompilePutByIdTransition):
2600         * tools/CodeProfile.cpp:
2601         (JSC::CodeProfile::sample):
2602
2603 2012-05-23  Geoffrey Garen  <ggaren@apple.com>
2604
2605         Refactored WeakBlock to use malloc, clarify behavior
2606         https://bugs.webkit.org/show_bug.cgi?id=87318
2607
2608         Reviewed by Filip Pizlo.
2609
2610         We want to use malloc so we can make these smaller than 4KB,
2611         since an individual MarkedBlock will usually have fewer than
2612         4KB worth of weak pointers.
2613
2614         * heap/Heap.cpp:
2615         (JSC::Heap::markRoots): Renamed visitLiveWeakImpls to visit, since
2616         we no longer need to distinguish from "visitDeadWeakImpls".
2617
2618         Renamed "visitDeadWeakImpls" to "reap" because we're not actually
2619         doing any visiting -- we're just tagging things as dead.
2620
2621         * heap/WeakBlock.cpp:
2622         (JSC::WeakBlock::create):
2623         (JSC::WeakBlock::destroy):
2624         (JSC::WeakBlock::WeakBlock): Malloc!
2625
2626         (JSC::WeakBlock::visit):
2627         (JSC::WeakBlock::reap): Renamed as above.
2628
2629         * heap/WeakBlock.h:
2630         (WeakBlock): Reduced to 3KB, as explained above.
2631
2632         * heap/WeakSet.cpp:
2633         (JSC::WeakSet::visit):
2634         (JSC::WeakSet::reap):
2635         * heap/WeakSet.h:
2636         (WeakSet): Updated for renames, and to match WebKit style.
2637
2638 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2639
2640         Use after free in JSC::DFG::ByteCodeParser::processPhiStack
2641         https://bugs.webkit.org/show_bug.cgi?id=87312
2642         <rdar://problem/11518848>
2643
2644         Reviewed by Oliver Hunt.
2645
2646         * dfg/DFGByteCodeParser.cpp:
2647         (JSC::DFG::ByteCodeParser::processPhiStack):
2648         (JSC::DFG::ByteCodeParser::parse):
2649
2650 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2651
2652         It should be possible to make C function calls from DFG code on ARM in debug mode
2653         https://bugs.webkit.org/show_bug.cgi?id=87313
2654
2655         Reviewed by Gavin Barraclough.
2656
2657         * dfg/DFGSpeculativeJIT.h:
2658         (SpeculativeJIT):
2659
2660 2012-05-11  Filip Pizlo  <fpizlo@apple.com>
2661
2662         DFG should be able to inline functions that use arguments reflectively
2663         https://bugs.webkit.org/show_bug.cgi?id=86132
2664
2665         Reviewed by Oliver Hunt.
2666         
2667         Merged r116838 from dfgopt.
2668         
2669         This turns on inlining of functions that use arguments reflectively, but it
2670         does not do any of the obvious optimizations that this exposes. I'll save that
2671         for another patch - the important thing for now is that this contains all of
2672         the plumbing necessary to make this kind of inlining sound even in bizarro
2673         cases like an inline callee escaping the arguments object to parts of the
2674         inline caller where the arguments are otherwise dead. Or even more fun cases
2675         like where you've inlined to an inline stack that is three-deep, and the
2676         function on top of the inline stack reflectively accesses the arguments of a
2677         function that is in the middle of the inline stack. Any subsequent
2678         optimizations that we do for the obvious cases of arguments usage in inline
2679         functions will have to take care not to break the baseline functionality that
2680         this patch plumbs together.
2681
2682         * bytecode/CodeBlock.cpp:
2683         (JSC::CodeBlock::printCallOp):
2684         (JSC::CodeBlock::dump):
2685         * bytecode/CodeBlock.h:
2686         * dfg/DFGAssemblyHelpers.h:
2687         (JSC::DFG::AssemblyHelpers::argumentsRegisterFor):
2688         (AssemblyHelpers):
2689         * dfg/DFGByteCodeParser.cpp:
2690         (InlineStackEntry):
2691         (JSC::DFG::ByteCodeParser::handleCall):
2692         (JSC::DFG::ByteCodeParser::handleInlining):
2693         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2694         (JSC::DFG::ByteCodeParser::parse):
2695         * dfg/DFGCCallHelpers.h:
2696         (JSC::DFG::CCallHelpers::setupArgumentsWithExecState):
2697         (CCallHelpers):
2698         * dfg/DFGCapabilities.h:
2699         (JSC::DFG::canInlineOpcode):
2700         * dfg/DFGDriver.cpp:
2701         (JSC::DFG::compile):
2702         * dfg/DFGFixupPhase.cpp:
2703         (JSC::DFG::FixupPhase::fixupNode):
2704         * dfg/DFGOperations.cpp:
2705         * dfg/DFGOperations.h:
2706         * dfg/DFGSpeculativeJIT.h:
2707         (JSC::DFG::SpeculativeJIT::callOperation):
2708         * dfg/DFGSpeculativeJIT32_64.cpp:
2709         (JSC::DFG::SpeculativeJIT::compile):
2710         * dfg/DFGSpeculativeJIT64.cpp:
2711         (JSC::DFG::SpeculativeJIT::compile):
2712         * interpreter/CallFrame.cpp:
2713         (JSC):
2714         (JSC::CallFrame::someCodeBlockForPossiblyInlinedCode):
2715         * interpreter/CallFrame.h:
2716         (ExecState):
2717         (JSC::ExecState::someCodeBlockForPossiblyInlinedCode):
2718         * interpreter/Interpreter.cpp:
2719         (JSC::Interpreter::retrieveArgumentsFromVMCode):
2720         * runtime/Arguments.cpp:
2721         (JSC::Arguments::tearOff):
2722         (JSC):
2723         (JSC::Arguments::tearOffForInlineCallFrame):
2724         * runtime/Arguments.h:
2725         (Arguments):
2726         (JSC::Arguments::create):
2727         (JSC::Arguments::finishCreation):
2728         (JSC):
2729
2730 2012-05-23  Filip Pizlo  <fpizlo@apple.com>
2731
2732         Every OSR exit on ARM results in a crash
2733         https://bugs.webkit.org/show_bug.cgi?id=87307
2734
2735         Reviewed by Geoffrey Garen.
2736
2737         * dfg/DFGThunks.cpp:
2738         (JSC::DFG::osrExitGenerationThunkGenerator):
2739
2740 2012-05-23  Geoffrey Garen  <ggaren@apple.com>
2741
2742         Refactored heap tear-down to use normal value semantics (i.e., destructors)
2743         https://bugs.webkit.org/show_bug.cgi?id=87302
2744
2745         Reviewed by Oliver Hunt.
2746
2747         This is a step toward incremental DOM finalization.
2748
2749         * heap/CopiedSpace.cpp:
2750         (JSC::CopiedSpace::~CopiedSpace):
2751         * heap/CopiedSpace.h:
2752         (CopiedSpace): Just use our destructor, instead of relying on the heap
2753         to send us a special message at a special time.
2754
2755         * heap/Heap.cpp:
2756         (JSC::Heap::Heap): Use OwnPtr for m_markListSet because this is not Sparta.
2757
2758         (JSC::Heap::~Heap): No need for delete or freeAllBlocks because normal
2759         destructors do this work automatically now.
2760
2761         (JSC::Heap::lastChanceToFinalize): Just call lastChanceToFinalize on our
2762         sub-objects, and assume it does the right thing. This improves encapsulation,
2763         so we can add items requiring finalization to our sub-objects.
2764
2765         * heap/Heap.h: Moved m_blockAllocator to get the right destruction order.
2766
2767         * heap/MarkedSpace.cpp:
2768         (Take):
2769         (JSC):
2770         (JSC::Take::Take):
2771         (JSC::Take::operator()):
2772         (JSC::Take::returnValue): Moved to the top of the file so it can be used
2773         in another function.
2774
2775         (JSC::MarkedSpace::~MarkedSpace): Delete all outstanding memory, like a good
2776         destructor should.
2777
2778         (JSC::MarkedSpace::lastChanceToFinalize): Moved some code here from the heap,
2779         since it pertains to our internal implementation details.
2780
2781         * heap/MarkedSpace.h:
2782         (MarkedSpace):
2783         * heap/WeakBlock.cpp:
2784         (JSC::WeakBlock::lastChanceToFinalize):
2785         * heap/WeakBlock.h:
2786         (WeakBlock):
2787         * heap/WeakSet.cpp:
2788         (JSC::WeakSet::lastChanceToFinalize):
2789         * heap/WeakSet.h:
2790         (WeakSet): Stop using a special freeAllBlocks() callback and just implement
2791         lastChanceToFinalize.
2792
2793 2011-05-22  Geoffrey Garen  <ggaren@apple.com>
2794
2795         Encapsulated some calculations for whether portions of the heap are empty
2796         https://bugs.webkit.org/show_bug.cgi?id=87210
2797
2798         Reviewed by Gavin Barraclough.
2799
2800         This is a step toward incremental DOM finalization.
2801
2802         * heap/Heap.cpp:
2803         (JSC::Heap::~Heap): Explicitly call freeAllBlocks() instead of relying
2804         implicitly on all blocks thinking they're empty. In future, we may
2805         choose to tear down the heap without first setting all data structures
2806         to "empty".
2807
2808         * heap/MarkedBlock.h:
2809         (JSC::MarkedBlock::isEmpty):
2810         (JSC::MarkedBlock::gatherDirtyCells): Renamed markCountIsZero to isEmpty,
2811         in preparation for making it check for outstanding finalizers in addition
2812         to marked cells.
2813
2814         * heap/MarkedSpace.cpp:
2815         (Take):
2816         (JSC::Take::Take):
2817         (JSC::Take::operator()):
2818         (JSC::Take::returnValue):
2819         (JSC::MarkedSpace::shrink):
2820         (JSC::MarkedSpace::freeAllBlocks): Refactored the "Take" functor to support
2821         a conditional isEmpty check, so it dould be shared by shrink() and freeAllBlocks().
2822
2823         * heap/WeakBlock.cpp:
2824         (JSC::WeakBlock::WeakBlock):
2825         (JSC::WeakBlock::visitLiveWeakImpls):
2826         (JSC::WeakBlock::visitDeadWeakImpls):
2827         * heap/WeakBlock.h:
2828         (WeakBlock):
2829         (JSC::WeakBlock::isEmpty):
2830         * heap/WeakSet.cpp:
2831         (JSC::WeakSet::sweep):
2832         (JSC::WeakSet::shrink): Use isEmpty(), in preparation for changes in
2833         its implementation.
2834
2835 2012-05-23  Oswald Buddenhagen  <oswald.buddenhagen@nokia.com>
2836
2837         [Qt] Remove references to $$QT_SOURCE_TREE
2838
2839         With a modularized Qt, it's ambigious. What we really want is qtbase,
2840         which qtcore is a proxy for (we assume it will always live in qtbase).
2841
2842         Reviewed by Tor Arne Vestbø.
2843
2844         * JavaScriptCore.pri:
2845         * Target.pri:
2846
2847 2012-05-09  Filip Pizlo  <fpizlo@apple.com>
2848
2849         DFG should allow inlining in case of certain arity mismatches
2850         https://bugs.webkit.org/show_bug.cgi?id=86059
2851
2852         Reviewed by Geoff Garen.
2853         
2854         Merge r116620 from dfgopt.
2855
2856         * dfg/DFGByteCodeParser.cpp:
2857         (JSC::DFG::ByteCodeParser::handleInlining):
2858
2859 2012-05-08  Filip Pizlo  <fpizlo@apple.com>
2860
2861         DFG variable capture analysis should work even if the variables arose through inlining
2862         https://bugs.webkit.org/show_bug.cgi?id=85945
2863
2864         Reviewed by Oliver Hunt.
2865         
2866         Merged r116555 from dfgopt.
2867         
2868         This just changes how the DFG queries whether a variable is captured. It does not
2869         change any user-visible behavior.
2870         
2871         As part of this change, I further solidified the policy that the CFA behaves in an
2872         undefined way for captured locals and queries about their values will not yield
2873         reliable results. This will likely be changed in the future, but for now it makes
2874         sense.
2875         
2876         One fun part about this change is that it recognizes that the same variable may
2877         be both captured and not, at the same time, because their live interval spans
2878         inlining boundaries. This only happens in the case of arguments to functions that
2879         capture their arguments, and this change treats them with just the right touch of
2880         conservatism: they will be treated as if captured by the caller as well as the 
2881         callee.
2882         
2883         Finally, this also adds captured variable reasoning to the InlineCallFrame, which
2884         I thought might be useful for later tooling.
2885         
2886         This is perf-neutral, since it does it does not make the DFG take advantage of this
2887         new functionality in any way. In particular, it is still the case that the DFG will
2888         not inline functions that use arguments reflectively or that create activations.
2889
2890         * bytecode/CodeBlock.h:
2891         (CodeBlock):
2892         (JSC::CodeBlock::needsActivation):
2893         (JSC::CodeBlock::argumentIsCaptured):
2894         (JSC::CodeBlock::localIsCaptured):
2895         (JSC::CodeBlock::isCaptured):
2896         * bytecode/CodeOrigin.h:
2897         (InlineCallFrame):
2898         * dfg/DFGAbstractState.cpp:
2899         (JSC::DFG::AbstractState::initialize):
2900         (JSC::DFG::AbstractState::endBasicBlock):
2901         (JSC::DFG::AbstractState::execute):
2902         (JSC::DFG::AbstractState::merge):
2903         * dfg/DFGByteCodeParser.cpp:
2904         (JSC::DFG::ByteCodeParser::newVariableAccessData):
2905         (JSC::DFG::ByteCodeParser::getLocal):
2906         (JSC::DFG::ByteCodeParser::setLocal):
2907         (JSC::DFG::ByteCodeParser::getArgument):
2908         (JSC::DFG::ByteCodeParser::setArgument):
2909         (JSC::DFG::ByteCodeParser::flushArgument):
2910         (JSC::DFG::ByteCodeParser::parseBlock):
2911         (JSC::DFG::ByteCodeParser::processPhiStack):
2912         (JSC::DFG::ByteCodeParser::fixVariableAccessPredictions):
2913         (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
2914         * dfg/DFGCFGSimplificationPhase.cpp:
2915         (CFGSimplificationPhase):
2916         (JSC::DFG::CFGSimplificationPhase::keepOperandAlive):
2917         (JSC::DFG::CFGSimplificationPhase::fixPossibleGetLocal):
2918         (JSC::DFG::CFGSimplificationPhase::fixTailOperand):
2919         * dfg/DFGCommon.h:
2920         * dfg/DFGFixupPhase.cpp:
2921         (JSC::DFG::FixupPhase::fixupNode):
2922         * dfg/DFGGraph.cpp:
2923         (JSC::DFG::Graph::nameOfVariableAccessData):
2924         * dfg/DFGGraph.h:
2925         (JSC::DFG::Graph::needsActivation):
2926         (JSC::DFG::Graph::usesArguments):
2927         * dfg/DFGPredictionPropagationPhase.cpp:
2928         (JSC::DFG::PredictionPropagationPhase::doRoundOfDoubleVoting):
2929         * dfg/DFGSpeculativeJIT.cpp:
2930         (JSC::DFG::SpeculativeJIT::compile):
2931         * dfg/DFGSpeculativeJIT32_64.cpp:
2932         (JSC::DFG::SpeculativeJIT::compile):
2933         * dfg/DFGSpeculativeJIT64.cpp:
2934         (JSC::DFG::SpeculativeJIT::compile):
2935         * dfg/DFGVariableAccessData.h:
2936         (JSC::DFG::VariableAccessData::VariableAccessData):
2937         (JSC::DFG::VariableAccessData::mergeIsCaptured):
2938         (VariableAccessData):
2939         (JSC::DFG::VariableAccessData::isCaptured):
2940
2941 2012-05-08  Filip Pizlo  <fpizlo@apple.com>
2942
2943         DFG should support op_get_argument_by_val and op_get_arguments_length
2944         https://bugs.webkit.org/show_bug.cgi?id=85911
2945
2946         Reviewed by Oliver Hunt.
2947         
2948         Merged r116467 from dfgopt.
2949         
2950         This adds a simple and relatively conservative implementation of op_get_argument_by_val
2951         and op_get_arguments_length. We can optimize these later. For now it's great to have
2952         the additional coverage.
2953         
2954         This patch appears to be perf-neutral.
2955
2956         * dfg/DFGAbstractState.cpp:
2957         (JSC::DFG::AbstractState::execute):
2958         * dfg/DFGAssemblyHelpers.h:
2959         (JSC::DFG::AssemblyHelpers::addressFor):
2960         (JSC::DFG::AssemblyHelpers::tagFor):
2961         (JSC::DFG::AssemblyHelpers::payloadFor):
2962         * dfg/DFGByteCodeParser.cpp:
2963         (JSC::DFG::ByteCodeParser::parseBlock):
2964         * dfg/DFGCapabilities.h:
2965         (JSC::DFG::canCompileOpcode):
2966         (JSC::DFG::canInlineOpcode):
2967         * dfg/DFGNode.h:
2968         (JSC::DFG::Node::hasHeapPrediction):
2969         * dfg/DFGNodeType.h:
2970         (DFG):
2971         * dfg/DFGOperations.cpp:
2972         * dfg/DFGOperations.h:
2973         * dfg/DFGPredictionPropagationPhase.cpp:
2974         (JSC::DFG::PredictionPropagationPhase::propagate):
2975         * dfg/DFGSpeculativeJIT.h:
2976         (JSC::DFG::SpeculativeJIT::callOperation):
2977         (SpeculativeJIT):
2978         * dfg/DFGSpeculativeJIT32_64.cpp:
2979         (JSC::DFG::SpeculativeJIT::compile):
2980         * dfg/DFGSpeculativeJIT64.cpp:
2981         (JSC::DFG::SpeculativeJIT::compile):
2982         * jit/JITOpcodes.cpp:
2983         (JSC::JIT::emit_op_get_argument_by_val):
2984         * jit/JITOpcodes32_64.cpp:
2985         (JSC::JIT::emit_op_get_argument_by_val):
2986         * llint/LowLevelInterpreter32_64.asm:
2987         * llint/LowLevelInterpreter64.asm:
2988
2989 2012-05-07  Filip Pizlo  <fpizlo@apple.com>
2990
2991         DFG should support op_tear_off_arguments
2992         https://bugs.webkit.org/show_bug.cgi?id=85847
2993
2994         Reviewed by Michael Saboff.
2995         
2996         Merged r116378 from dfgopt.
2997
2998         * dfg/DFGAbstractState.cpp:
2999         (JSC::DFG::AbstractState::execute):
3000         * dfg/DFGByteCodeParser.cpp:
3001         (JSC::DFG::ByteCodeParser::parseBlock):
3002         * dfg/DFGCapabilities.h:
3003         (JSC::DFG::canCompileOpcode):
3004         (JSC::DFG::canInlineOpcode):
3005         * dfg/DFGNodeType.h:
3006         (DFG):
3007         * dfg/DFGOperations.cpp:
3008         * dfg/DFGOperations.h:
3009         * dfg/DFGPredictionPropagationPhase.cpp:
3010         (JSC::DFG::PredictionPropagationPhase::propagate):
3011         * dfg/DFGSpeculativeJIT.h:
3012         (SpeculativeJIT):
3013         (JSC::DFG::SpeculativeJIT::callOperation):
3014         * dfg/DFGSpeculativeJIT32_64.cpp:
3015         (JSC::DFG::SpeculativeJIT::compile):
3016         * dfg/DFGSpeculativeJIT64.cpp:
3017         (JSC::DFG::SpeculativeJIT::compile):
3018
3019 2012-05-22  Mark Hahnenberg  <mhahnenberg@apple.com>
3020
3021         CopiedSpace::contains doesn't check for oversize blocks
3022         https://bugs.webkit.org/show_bug.cgi?id=87180
3023
3024         Reviewed by Geoffrey Garen.
3025
3026         When doing a conservative scan we use CopiedSpace::contains to determine if a particular 
3027         address points into the CopiedSpace. Currently contains() only checks if the address 
3028         points to a block in to-space, which means that pointers to oversize blocks may not get scanned. 
3029
3030         * heap/CopiedSpace.cpp:
3031         (JSC::CopiedSpace::tryAllocateOversize):
3032         (JSC::CopiedSpace::tryReallocateOversize):
3033         (JSC::CopiedSpace::doneFillingBlock):
3034         (JSC::CopiedSpace::doneCopying):
3035         * heap/CopiedSpace.h: Refactored CopiedSpace so that all blocks (oversize and to-space) are 
3036         in a single hash set and bloom filter for membership testing.
3037         (CopiedSpace):
3038         * heap/CopiedSpaceInlineMethods.h:
3039         (JSC::CopiedSpace::contains): We check for the normal block first. Since the oversize blocks are
3040         only page aligned, rather than block aligned, we have to re-mask the ptr to check if it's in 
3041         CopiedSpace. Also added a helper function of the same name that takes a CopiedBlock* and checks
3042         if it's in CopiedSpace so that check isn't typed out twice.
3043         (JSC):
3044         (JSC::CopiedSpace::startedCopying):
3045         (JSC::CopiedSpace::addNewBlock):
3046
3047 2012-05-22  Geoffrey Garen  <ggaren@apple.com>
3048
3049         CopiedBlock and MarkedBlock should have proper value semantics (i.e., destructors)
3050         https://bugs.webkit.org/show_bug.cgi?id=87172
3051
3052         Reviewed by Oliver Hunt and Phil Pizlo.
3053
3054         This enables MarkedBlock to own non-trivial sub-objects that require
3055         destruction. It also fixes a FIXME about casting a CopiedBlock to a
3056         MarkedBlock at destroy time.
3057
3058         CopiedBlock and MarkedBlock now accept an allocation chunk at create
3059         time and return it at destroy time. Their client is expected to
3060         allocate, recycle, and destroy these chunks.
3061
3062         * heap/BlockAllocator.cpp:
3063         (JSC::BlockAllocator::releaseFreeBlocks):
3064         (JSC::BlockAllocator::blockFreeingThreadMain): Don't call MarkedBlock::destroy
3065         because we expect that to be called before a block is put on our free
3066         list now. Do manually deallocate our allocation chunk because that's
3067         our job now.
3068
3069         * heap/BlockAllocator.h:
3070         (BlockAllocator):
3071         (JSC::BlockAllocator::allocate): Allocate never fails now. This is a
3072         cleaner abstraction because only one object does all the VM allocation
3073         and deallocation. Caching is an implementation detail.
3074
3075         (JSC::BlockAllocator::deallocate): We take an allocation chunk argument
3076         instead of a block because we now expect the block to have been destroyed 
3077         before we recycle its memory. For convenience, we still use the HeapBlock
3078         class as our linked list node. This is OK because HeapBlock is a POD type.
3079
3080         * heap/CopiedBlock.h:
3081         (CopiedBlock):
3082         (JSC::CopiedBlock::create):
3083         (JSC::CopiedBlock::destroy):
3084         (JSC::CopiedBlock::CopiedBlock): Added proper create and destroy functions,
3085         to match MarkedBlock.
3086
3087         * heap/CopiedSpace.cpp:
3088         (JSC::CopiedSpace::tryAllocateOversize):
3089         (JSC::CopiedSpace::tryReallocateOversize):
3090         (JSC::CopiedSpace::doneCopying):
3091         (JSC::CopiedSpace::getFreshBlock):
3092         (JSC::CopiedSpace::freeAllBlocks):
3093         * heap/CopiedSpaceInlineMethods.h:
3094         (JSC::CopiedSpace::recycleBlock): Make sure to call destroy before
3095         returning a block to the BlockAllocator. Otherwise, our destructors
3096         won't run. (If we get this wrong now, we'll get a compile error.)
3097
3098         * heap/HeapBlock.h:
3099         (JSC::HeapBlock::HeapBlock): const!
3100
3101         * heap/MarkedAllocator.cpp:
3102         (JSC::MarkedAllocator::allocateBlock): No need to distinguish between
3103         create and recycle -- MarkedBlock always accepts memory allocated by
3104         its client now.
3105
3106         * heap/MarkedBlock.cpp:
3107         (JSC::MarkedBlock::create): Don't allocate memory -- we assume that we're
3108         passed already-allocated memory, to clarify the responsibility for VM
3109         recycling.
3110
3111         (JSC::MarkedBlock::destroy): Do run our destructor before giving back
3112         our VM -- that is the whole point of this patch.
3113
3114         (JSC::MarkedBlock::MarkedBlock):
3115         * heap/MarkedBlock.h:
3116         (MarkedBlock):
3117         * heap/MarkedSpace.cpp: const!
3118
3119         (JSC::MarkedSpace::freeBlocks): Make sure to call destroy before
3120         returning a block to the BlockAllocator. Otherwise, our destructors
3121         won't run. (If we get this wrong now, we'll get a compile error.)
3122
3123 == Rolled over to ChangeLog-2012-05-22 ==