9a48dc50405c33dfc9754a0d45b3ed2caebd0180
[WebKit-https.git] / Source / JavaScriptCore / ChangeLog
1 2015-03-16  Ryosuke Niwa  <rniwa@webkit.org>
2
3         Enable ES6 classes by default
4         https://bugs.webkit.org/show_bug.cgi?id=142774
5
6         Reviewed by Gavin Barraclough.
7
8         Enabled the feature and unskipped tests.
9
10         * Configurations/FeatureDefines.xcconfig:
11         * tests/stress/class-syntax-no-loop-tdz.js:
12         * tests/stress/class-syntax-no-tdz-in-catch.js:
13         * tests/stress/class-syntax-no-tdz-in-conditional.js:
14         * tests/stress/class-syntax-no-tdz-in-loop-no-inline-super.js:
15         * tests/stress/class-syntax-no-tdz-in-loop.js:
16         * tests/stress/class-syntax-no-tdz.js:
17         * tests/stress/class-syntax-tdz-in-catch.js:
18         * tests/stress/class-syntax-tdz-in-conditional.js:
19         * tests/stress/class-syntax-tdz-in-loop.js:
20         * tests/stress/class-syntax-tdz.js:
21
22 2015-03-16  Joseph Pecoraro  <pecoraro@apple.com>
23
24         Web Inspector: Better Console Previews for Arrays / Small Objects
25         https://bugs.webkit.org/show_bug.cgi?id=142322
26
27         Reviewed by Timothy Hatcher.
28
29         * inspector/InjectedScriptSource.js:
30         Create deep valuePreviews for simple previewable objects,
31         such as arrays with 5 values, or basic objects with
32         3 properties.
33
34 2015-03-16  Ryosuke Niwa  <rniwa@webkit.org>
35
36         Add support for default constructor
37         https://bugs.webkit.org/show_bug.cgi?id=142388
38
39         Reviewed by Filip Pizlo.
40
41         Added the support for default constructors. They're generated by ClassExprNode::emitBytecode
42         via BuiltinExecutables::createDefaultConstructor.
43
44         UnlinkedFunctionExecutable now has the ability to override SourceCode provided by the owner
45         executable. We can't make store SourceCode in UnlinkedFunctionExecutable since CodeCache can use
46         the same UnlinkedFunctionExecutable to generate code blocks for multiple functions.
47
48         Parser now has the ability to treat any function expression as a constructor of the kind specified
49         by m_defaultConstructorKind member variable.
50
51         * builtins/BuiltinExecutables.cpp:
52         (JSC::BuiltinExecutables::createDefaultConstructor): Added.
53         (JSC::BuiltinExecutables::createExecutableInternal): Generalized from createBuiltinExecutable.
54         Parse default constructors as normal non-builtin functions. Override SourceCode in the unlinked
55         function executable since the Miranda function's code is definitely not in the owner executable's
56         source code. That's the whole point.
57         * builtins/BuiltinExecutables.h:
58         (UnlinkedFunctionExecutable::createBuiltinExecutable): Added. Wraps createExecutableInternal.
59         * bytecode/UnlinkedCodeBlock.cpp:
60         (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
61         (JSC::UnlinkedFunctionExecutable::linkInsideExecutable):
62         (JSC::UnlinkedFunctionExecutable::linkGlobalCode):
63         * bytecode/UnlinkedCodeBlock.h:
64         (JSC::UnlinkedFunctionExecutable::create):
65         (JSC::UnlinkedFunctionExecutable::symbolTable): Deleted.
66         * bytecompiler/BytecodeGenerator.cpp:
67         (JSC::BytecodeGenerator::emitNewDefaultConstructor): Added.
68         * bytecompiler/BytecodeGenerator.h:
69         * bytecompiler/NodesCodegen.cpp:
70         (JSC::ClassExprNode::emitBytecode): Generate the default constructor if needed.
71         * parser/Parser.cpp:
72         (JSC::Parser<LexerType>::Parser):
73         (JSC::Parser<LexerType>::parseFunctionInfo): Override ownerClassKind and assume the function as
74         a constructor if we're parsing a default constructor.
75         (JSC::Parser<LexerType>::parseClass): Allow omission of the class constructor.
76         * parser/Parser.h:
77         (JSC::parse):
78
79 2015-03-16  Alex Christensen  <achristensen@webkit.org>
80
81         Progress towards CMake on Mac
82         https://bugs.webkit.org/show_bug.cgi?id=142747
83
84         Reviewed by Chris Dumez.
85
86         * CMakeLists.txt:
87         Include AugmentableInspectorController.h in CMake build.
88
89 2015-03-16  Csaba Osztrogonác  <ossy@webkit.org>
90
91         [ARM] Enable generating idiv instructions if it is supported
92         https://bugs.webkit.org/show_bug.cgi?id=142725
93
94         Reviewed by Michael Saboff.
95
96         * assembler/ARMAssembler.h: Added sdiv and udiv implementation for ARM Traditional instruction set.
97         (JSC::ARMAssembler::sdiv):
98         (JSC::ARMAssembler::udiv):
99         * assembler/ARMv7Assembler.h: Use HAVE(ARM_IDIV_INSTRUCTIONS) instead of CPU(APPLE_ARMV7S).
100         * assembler/AbstractMacroAssembler.h:
101         (JSC::isARMv7IDIVSupported):
102         (JSC::optimizeForARMv7IDIVSupported):
103         (JSC::isARMv7s): Renamed to isARMv7IDIVSupported().
104         (JSC::optimizeForARMv7s): Renamed to optimizeForARMv7IDIVSupported().
105         * dfg/DFGFixupPhase.cpp:
106         (JSC::DFG::FixupPhase::fixupNode):
107         * dfg/DFGSpeculativeJIT.cpp:
108         (JSC::DFG::SpeculativeJIT::compileArithDiv):
109         (JSC::DFG::SpeculativeJIT::compileArithMod):
110
111 2015-03-15  Filip Pizlo  <fpizlo@apple.com>
112
113         DFG::PutStackSinkingPhase should eliminate GetStacks that have an obviously known source, and emit GetStacks when the stack's value is needed and none is deferred
114         https://bugs.webkit.org/show_bug.cgi?id=141624
115
116         Reviewed by Geoffrey Garen.
117
118         Not eliminating GetStacks was an obvious omission from the original PutStackSinkingPhase.
119         Previously, we would treat GetStacks conservatively and assume that the stack slot
120         escaped. That's pretty dumb, since a GetStack is a local load of the stack. This change
121         makes GetStack a no-op from the standpoint of this phase's deferral analysis. At the end
122         we either keep the GetStack (if there was no concrete deferral) or we replace it with an
123         identity over the value that would have been stored by the deferred PutStack. Note that
124         this might be a Phi that the phase creates, so this is strictly stronger than what GCSE
125         could do.
126         
127         But this change revealed the fact that this phase never correctly handled side effects in
128         case that we had done a GetStack, then a side-effect, and then found ourselves wanting the
129         value on the stack due to (for example) a Phi on a deferred PutStack and that GetStack.
130         Basically, it's only correct to use the SSA converter's incoming value mapping if we have
131         a concrete deferral - since anything but a concrete deferral may imply that the value has
132         been clobbered.
133         
134         This has no performance change. I believe that the bug was previously benign because we
135         have so few operations that clobber the stack anymore, and most of those get used in a
136         very idiomatic way. The GetStack elimination will be very useful for the varargs
137         simplification that is part of bug 141174.
138         
139         This includes a test for the case that Speedometer hit, plus tests for the other cases I
140         thought of once I realized the deeper issue.
141
142         * dfg/DFGPutStackSinkingPhase.cpp:
143         * tests/stress/get-stack-identity-due-to-sinking.js: Added.
144         (foo):
145         (bar):
146         * tests/stress/get-stack-mapping-with-dead-get-stack.js: Added.
147         (bar):
148         (foo):
149         * tests/stress/get-stack-mapping.js: Added.
150         (bar):
151         (foo):
152         * tests/stress/weird-put-stack-varargs.js: Added.
153         (baz):
154         (foo):
155         (fuzz):
156         (bar):
157
158 2015-03-16  Joseph Pecoraro  <pecoraro@apple.com>
159
160         Update Map/Set to treat -0 and 0 as the same value
161         https://bugs.webkit.org/show_bug.cgi?id=142709
162
163         Reviewed by Csaba Osztrogonác.
164
165         * runtime/MapData.h:
166         (JSC::MapDataImpl<Entry>::KeyType::KeyType):
167         No longer special case -0. It will be treated as the same as 0.
168
169 2015-03-15  Joseph Pecoraro  <pecoraro@apple.com>
170
171         Web Inspector: Better handle displaying -0
172         https://bugs.webkit.org/show_bug.cgi?id=142708
173
174         Reviewed by Timothy Hatcher.
175
176         Modeled after a blink change:
177
178         Patch by <aandrey@chromium.org>
179         DevTools: DevTools: Show -0 for negative zero in console
180         https://src.chromium.org/viewvc/blink?revision=162605&view=revision
181
182         * inspector/InjectedScriptSource.js:
183         When creating a description string, or preview value string
184         for -0, be sure the string is "-0" and not "0".
185
186 2015-03-14  Ryosuke Niwa  <rniwa@webkit.org>
187
188         parseClass should popScope after pushScope
189         https://bugs.webkit.org/show_bug.cgi?id=142689
190
191         Reviewed by Benjamin Poulain.
192
193         Pop the parser scope as needed.
194
195         * parser/Parser.cpp:
196         (JSC::Parser<LexerType>::parseClass):
197
198 2015-03-14  Dean Jackson  <dino@apple.com>
199
200         Feature flag for Animations Level 2
201         https://bugs.webkit.org/show_bug.cgi?id=142699
202         <rdar://problem/20165097>
203
204         Reviewed by Brent Fulgham.
205
206         Add ENABLE_CSS_ANIMATIONS_LEVEL_2 and a runtime flag animationTriggersEnabled.
207
208         * Configurations/FeatureDefines.xcconfig:
209
210 2015-03-14  Commit Queue  <commit-queue@webkit.org>
211
212         Unreviewed, rolling out r181487.
213         https://bugs.webkit.org/show_bug.cgi?id=142695
214
215         Caused Speedometer/Full.html to fail (Requested by smfr on
216         #webkit).
217
218         Reverted changeset:
219
220         "DFG::PutStackSinkingPhase should eliminate GetStacks that
221         have an obviously known source"
222         https://bugs.webkit.org/show_bug.cgi?id=141624
223         http://trac.webkit.org/changeset/181487
224
225 2015-03-14  Michael Saboff  <msaboff@apple.com>
226
227         ES6: Add binary and octal literal support
228         https://bugs.webkit.org/show_bug.cgi?id=142681
229
230         Reviewed by Ryosuke Niwa.
231
232         Added a binary literal parser function, parseBinary(), to Lexer patterned after the octal parser.
233         Refactored the parseBinary, parseOctal and parseDecimal to use a constant size for the number of
234         characters to try and handle directly. Factored out the shifting past any prefix to be handled by
235         the caller. Added binary and octal parsing to toDouble() via helper functions.
236
237         * parser/Lexer.cpp:
238         (JSC::Lexer<T>::parseHex):
239         (JSC::Lexer<T>::parseBinary):
240         (JSC::Lexer<T>::parseOctal):
241         (JSC::Lexer<T>::parseDecimal):
242         (JSC::Lexer<T>::lex):
243         * parser/Lexer.h:
244         * parser/ParserTokens.h:
245         * runtime/JSGlobalObjectFunctions.cpp:
246         (JSC::jsBinaryIntegerLiteral):
247         (JSC::jsOctalIntegerLiteral):
248         (JSC::toDouble):
249
250 2015-03-13  Alex Christensen  <achristensen@webkit.org>
251
252         Progress towards CMake on Mac.
253         https://bugs.webkit.org/show_bug.cgi?id=142680
254
255         Reviewed by Gyuyoung Kim.
256
257         * PlatformMac.cmake:
258         Generate TracingDtrace.h based on project.pbxproj.
259
260 2015-03-13  Filip Pizlo  <fpizlo@apple.com>
261
262         Object allocation sinking phase shouldn't re-decorate previously sunken allocations on each fixpoint operation
263         https://bugs.webkit.org/show_bug.cgi?id=142686
264
265         Reviewed by Oliver Hunt.
266         
267         Just because promoteHeapAccess() notifies us of an effect to a heap location in a node doesn't
268         mean that we should handle it as if it was for one of our sinking candidates. Instead we should
269         prune based on m_sinkCandidates.
270         
271         This fixes a benign bug where we would generate a lot of repeated IR for some pathological
272         tests.
273
274         * dfg/DFGObjectAllocationSinkingPhase.cpp:
275         (JSC::DFG::ObjectAllocationSinkingPhase::promoteSunkenFields):
276
277 2015-03-13  Eric Carlson  <eric.carlson@apple.com>
278
279         [Mac] Enable WIRELESS_PLAYBACK_TARGET
280         https://bugs.webkit.org/show_bug.cgi?id=142635
281
282         Reviewed by Darin Adler.
283
284         * Configurations/FeatureDefines.xcconfig:
285
286 2015-03-13  Ryosuke Niwa  <rniwa@webkit.org>
287
288         Class constructor should throw TypeError when "called"
289         https://bugs.webkit.org/show_bug.cgi?id=142566
290
291         Reviewed by Michael Saboff.
292
293         Added ConstructorKind::None to denote code that doesn't belong to an ES6 class.
294         This allows BytecodeGenerator to emit code to throw TypeError when generating code block
295         to call ES6 class constructors.
296
297         Most of changes are about increasing the number of bits to store ConstructorKind from one
298         bit to two bits.
299
300         * bytecode/UnlinkedCodeBlock.cpp:
301         (JSC::generateFunctionCodeBlock):
302         (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
303         (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
304         * bytecode/UnlinkedCodeBlock.h:
305         (JSC::ExecutableInfo::ExecutableInfo):
306         (JSC::ExecutableInfo::needsActivation):
307         (JSC::ExecutableInfo::usesEval):
308         (JSC::ExecutableInfo::isStrictMode):
309         (JSC::ExecutableInfo::isConstructor):
310         (JSC::ExecutableInfo::isBuiltinFunction):
311         (JSC::ExecutableInfo::constructorKind):
312         (JSC::UnlinkedFunctionExecutable::constructorKind):
313         (JSC::UnlinkedCodeBlock::constructorKind):
314         (JSC::UnlinkedFunctionExecutable::constructorKindIsDerived): Deleted.
315         (JSC::UnlinkedCodeBlock::constructorKindIsDerived): Deleted.
316         * bytecompiler/BytecodeGenerator.cpp:
317         (JSC::BytecodeGenerator::generate): Don't emit bytecode when we had already emitted code
318         to throw TypeError.
319         (JSC::BytecodeGenerator::BytecodeGenerator): Emit code to throw TypeError when generating
320         code to call.
321         (JSC::BytecodeGenerator::emitReturn):
322         * bytecompiler/BytecodeGenerator.h:
323         (JSC::BytecodeGenerator::constructorKind):
324         (JSC::BytecodeGenerator::constructorKindIsDerived): Deleted.
325         * bytecompiler/NodesCodegen.cpp:
326         (JSC::ThisNode::emitBytecode):
327         (JSC::FunctionCallValueNode::emitBytecode):
328         * parser/Nodes.cpp:
329         (JSC::FunctionBodyNode::FunctionBodyNode):
330         * parser/Nodes.h:
331         * parser/Parser.cpp:
332         (JSC::Parser<LexerType>::parseFunctionInfo): Renamed the incoming function argument to
333         ownerClassKind. Set constructorKind to Base or Derived only if we're parsing a constructor.
334         (JSC::Parser<LexerType>::parseFunctionDeclaration):
335         (JSC::Parser<LexerType>::parseClass): Don't parse static methods using MethodMode since that
336         would result in BytecodeGenerator erroneously treating static method named "constructor" as
337         a class constructor.
338         (JSC::Parser<LexerType>::parsePropertyMethod):
339         (JSC::Parser<LexerType>::parsePrimaryExpression):
340         * parser/Parser.h:
341         * parser/ParserModes.h:
342         * runtime/Executable.h:
343         (JSC::EvalExecutable::executableInfo):
344         (JSC::ProgramExecutable::executableInfo):
345
346 2015-03-13  Filip Pizlo  <fpizlo@apple.com>
347
348         DFG::PutStackSinkingPhase should eliminate GetStacks that have an obviously known source
349         https://bugs.webkit.org/show_bug.cgi?id=141624
350
351         Reviewed by Oliver Hunt.
352         
353         This was an obvious omission from the original PutStackSinkingPhase. Previously, we would treat
354         GetStacks conservatively and assume that the stack slot escaped. That's pretty dumb, since a
355         GetStack is a local load of the stack. This change makes GetStack a no-op from the standpoint of
356         this phase's deferral analysis. At the end we either keep the GetStack (if there was no concrete
357         deferral) or we replace it with an identity over the value that would have been stored by the
358         deferred PutStack. Note that this might be a Phi that the phase creates, so this is strictly
359         stronger than what GCSE could do.
360         
361         This is probably not a speed-up now, but it will be very useful for the varargs simplification
362         done in bug 141174.
363
364         * dfg/DFGPutStackSinkingPhase.cpp:
365
366 2015-03-12  Geoffrey Garen  <ggaren@apple.com>
367
368         Prohibit GC while sweeping
369         https://bugs.webkit.org/show_bug.cgi?id=142638
370
371         Reviewed by Andreas Kling.
372
373         I noticed in https://bugs.webkit.org/show_bug.cgi?id=142636 that a GC
374         could trigger a sweep which could trigger another GC. Yo Dawg.
375
376         I tried to figure out whether this could cause problems or not and it
377         made me cross-eyed.
378
379         (Some clients like to report extra memory cost during deallocation as a
380         way to indicate that the GC now owns something exclusively. It's
381         arguably a bug to communicate with the GC in this way, but we shouldn't
382         do crazy when this happens.)
383
384         This patch makes explicit the fact that we don't allow GC while sweeping.
385
386         Usually, sweeping implicitly defers GC by virtue of happening during
387         allocation. But not always.
388
389         * heap/Heap.cpp:
390         (JSC::Heap::collectAllGarbage): Defer GC while sweeping due to an
391         explicit GC request.
392
393         (JSC::Heap::didFinishCollection): Make sure that zombifying sweep
394         defers GC by not returning to the non-GC state until we're all done.
395
396         * heap/IncrementalSweeper.cpp:
397         (JSC::IncrementalSweeper::sweepNextBlock): Defer GC while sweeping due
398         to a timer.
399
400 2015-03-13  Mark Lam  <mark.lam@apple.com>
401
402         Replace TCSpinLock with a new WTF::SpinLock based on WTF::Atomic.
403         <https://webkit.org/b/142674>
404
405         Reviewed by Filip Pizlo.
406
407         * API/JSValue.mm:
408         (handerForStructTag):
409         * API/JSWrapperMap.mm:
410         * dfg/DFGCommon.cpp:
411         (JSC::DFG::startCrashing):
412         (JSC::DFG::isCrashing):
413         - Changed to use a StaticSpinLock since that's what this code was trying to do
414           anyway.
415         * heap/CopiedBlock.h:
416         (JSC::CopiedBlock::CopiedBlock):
417         * heap/CopiedSpace.cpp:
418         (JSC::CopiedSpace::CopiedSpace):
419         * heap/CopiedSpace.h:
420         * heap/GCThreadSharedData.cpp:
421         (JSC::GCThreadSharedData::GCThreadSharedData):
422         * heap/GCThreadSharedData.h:
423         * heap/ListableHandler.h:
424         (JSC::ListableHandler::List::List):
425         * parser/SourceProvider.cpp:
426         * profiler/ProfilerDatabase.cpp:
427         (JSC::Profiler::Database::addDatabaseToAtExit):
428         (JSC::Profiler::Database::removeDatabaseFromAtExit):
429         (JSC::Profiler::Database::removeFirstAtExitDatabase):
430
431 2015-03-13  Ryosuke Niwa  <rniwa@webkit.org>
432
433         BytecodeGenerator needs to be re-entrant to support miranda functions
434         https://bugs.webkit.org/show_bug.cgi?id=142627
435
436         Reviewed by Filip Pizlo.
437
438         Made CodeCache::getGlobalCodeBlock and CodeCache::getFunctionExecutableFromGlobalCode re-entrant
439         by not keeping AddResult while invoking BytecodeGenerator::generate.
440
441         This is needed to support Miranda functions since they need to be lazily initialized.
442
443         * runtime/CodeCache.cpp:
444         (JSC::CodeCache::getGlobalCodeBlock):
445         (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
446         * runtime/CodeCache.h:
447         (JSC::CodeCacheMap::findCacheAndUpdateAge): Extracted from add.
448         (JSC::CodeCacheMap::addCache): Extracted from add.
449         (JSC::CodeCacheMap::add): Deleted.
450
451 2015-03-13  Mark Lam  <mark.lam@apple.com>
452
453         Introduce WTF::Atomic to wrap std::atomic for a friendlier CAS.
454         <https://webkit.org/b/142661>
455
456         Reviewed by Filip Pizlo.
457
458         Changed CodeBlock, and the DFG's crashLock to use WTF::Atomic instead of
459         std::atomic.
460
461         * bytecode/CodeBlock.cpp:
462         (JSC::CodeBlock::CodeBlock):
463         (JSC::CodeBlock::visitAggregate):
464         * bytecode/CodeBlock.h:
465         * dfg/DFGCommon.cpp:
466         (JSC::DFG::startCrashing):
467
468 2015-03-12  Mark Lam  <mark.lam@apple.com>
469
470         Change the DFG crashLock to use std::atomic.
471         <https://webkit.org/b/142649>
472
473         Reviewed by Filip Pizlo.
474
475         * dfg/DFGCommon.cpp:
476         (JSC::DFG::startCrashing):
477         (JSC::DFG::isCrashing):
478
479 2015-03-12  Filip Pizlo  <fpizlo@apple.com>
480
481         Bytecode liveness analysis should have more lambdas and fewer sets
482         https://bugs.webkit.org/show_bug.cgi?id=142647
483
484         Reviewed by Mark Lam.
485         
486         In bug 141174 I'll need to identify all of the bytecode kill sites. This requires hooking into
487         the bytecode analysis' stepOverFunction method, except in such a way that we observe uses that
488         are not in outs. This refactors stepOverFunction so that you can pass it use/def functors that
489         can either be used to propagate outs (as we do right now) or to additionally detect kills or
490         whatever else.
491         
492         In order to achieve this, the liveness analysis was moved off of maintaining uses/defs
493         bitvectors. This wasn't helping the abstraction and was probably inefficient. The new code
494         should be a bit faster since we don't have to clear uses/defs bitvectors on each instruction. On
495         the other hand, being able to intercept each use means that our code for exception handlers is
496         no longer a bitwise-merge; it requires finding set bits. Fortunately, this code only kicks in
497         for instructions inside a try, and its performance is O(live at catch), so that's probably not
498         bad.
499
500         * bytecode/BytecodeLivenessAnalysis.cpp:
501         (JSC::indexForOperand):
502         (JSC::stepOverInstruction):
503         (JSC::computeLocalLivenessForBytecodeOffset):
504         (JSC::BytecodeLivenessAnalysis::computeFullLiveness):
505         (JSC::setForOperand): Deleted.
506         * bytecode/BytecodeUseDef.h:
507         (JSC::computeUsesForBytecodeOffset):
508         (JSC::computeDefsForBytecodeOffset):
509         * bytecode/CodeBlock.cpp:
510
511 2015-03-12  Ryosuke Niwa  <rniwa@webkit.org>
512
513         "this" should be in TDZ until super is called in the constructor of a derived class
514         https://bugs.webkit.org/show_bug.cgi?id=142527
515
516         Reviewed by Mark Hahnenberg.
517
518         DFG and FTL implementations co-authored by Filip Pizlo.
519
520         In ES6 class syntax, "this" register must be in the "temporal dead zone" (TDZ) and throw ReferenceError until
521         super() is called inside the constructor of a derived class.
522
523         Added op_check_tdz, a new OP code, which throws a reference error when the first operand is an empty value
524         to all tiers of JIT and LLint. The op code throws in the slow path on the basis that a TDZ error should be
525         a programming error and not a part of the programs' normal control flow. In DFG, this op code is represented
526         by a no-op must-generate node CheckNotEmpty modeled after CheckCell.
527
528         Also made the constructor of a derived class assign the empty value to "this" register rather than undefined
529         so that ThisNode can emit the op_check_tdz to check the initialized-ness of "this" in such a constructor.
530
531         * bytecode/BytecodeList.json: Added op_check_tdz.
532         * bytecode/BytecodeUseDef.h:
533         (JSC::computeUsesForBytecodeOffset): Ditto.
534         (JSC::computeDefsForBytecodeOffset): Ditto.
535         * bytecode/CodeBlock.cpp:
536         (JSC::CodeBlock::dumpBytecode): Ditto.
537         * bytecode/ExitKind.cpp:
538         (JSC::exitKindToString): Added TDZFailure.
539         * bytecode/ExitKind.h: Ditto.
540         * bytecompiler/BytecodeGenerator.cpp:
541         (JSC::BytecodeGenerator::BytecodeGenerator): Assign the empty value to "this" register to indicate it's in TDZ.
542         (JSC::BytecodeGenerator::emitTDZCheck): Added.
543         (JSC::BytecodeGenerator::emitReturn): Emit the TDZ check since "this" can still be in TDZ if super() was never
544         called. e.g. class B extends A { constructor() { } }
545         * bytecompiler/BytecodeGenerator.h:
546         * bytecompiler/NodesCodegen.cpp:
547         (JSC::ThisNode::emitBytecode): Always emit the TDZ check if we're inside the constructor of a derived class.
548         We can't omit this check even if the result was ignored per spec.
549         * dfg/DFGAbstractInterpreterInlines.h:
550         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects): Previously, empty value could never appear
551         in a local variable. This is no longer true so generalize this code. Also added the support for CheckNotEmpty.
552         Like CheckCell, we phantomize this DFG node in the constant folding phase if the type of the operand is already
553         found to be not empty. Otherwise filter out SpecEmpty.
554         * dfg/DFGByteCodeParser.cpp:
555         (JSC::DFG::ByteCodeParser::parseBlock): Added op_check_tdz.
556         * dfg/DFGCapabilities.cpp:
557         (JSC::DFG::capabilityLevel): op_check_tdz can be compiled and inlined.
558         * dfg/DFGClobberize.h:
559         (JSC::DFG::clobberize): CheckNotEmpty doesn't read or write values.
560         * dfg/DFGConstantFoldingPhase.cpp:
561         (JSC::DFG::ConstantFoldingPhase::foldConstants): Convert CheckNotEmpty to a phantom if non-emptiness had already
562         been proven for the operand prior to this node.
563         * dfg/DFGDoesGC.cpp:
564         (JSC::DFG::doesGC): CheckNotEmpty does not trigger GC.
565         * dfg/DFGFixupPhase.cpp:
566         (JSC::DFG::FixupPhase::fixupNode): CheckNotEmpty is a no-op in the fixup phase.
567         * dfg/DFGNodeType.h: CheckNotEmpty cannot be removed even if the result was ignored. See ThisNode::emitBytecode.
568         * dfg/DFGPredictionPropagationPhase.cpp:
569         (JSC::DFG::PredictionPropagationPhase::propagate): CheckNotEmpty doesn't return any value.
570         * dfg/DFGSafeToExecute.h:
571         (JSC::DFG::safeToExecute): CheckNotEmpty doesn't load from heap so it's safe.
572         * dfg/DFGSpeculativeJIT32_64.cpp:
573         (JSC::DFG::SpeculativeJIT::compile): Speculative the operand to be not empty. OSR exit if the speculation fails.
574         * dfg/DFGSpeculativeJIT64.cpp:
575         (JSC::DFG::SpeculativeJIT::compile): Ditto.
576         * ftl/FTLCapabilities.cpp:
577         (JSC::FTL::canCompile): CheckNotEmpty can be compiled in FTL.
578         * ftl/FTLLowerDFGToLLVM.cpp:
579         (JSC::FTL::LowerDFGToLLVM::compileNode): Calls compileCheckNotEmpty for CheckNotEmpty.
580         (JSC::FTL::LowerDFGToLLVM::compileCheckNotEmpty): OSR exit with "TDZFailure" if the operand is not empty.
581         * jit/JIT.cpp:
582         (JSC::JIT::privateCompileMainPass): Added op_check_tdz.
583         (JSC::JIT::privateCompileSlowCases): Ditto.
584         * jit/JIT.h:
585         * jit/JITOpcodes.cpp:
586         (JSC::JIT::emit_op_check_tdz): Implements op_check_tdz in Baseline JIT.
587         (JSC::JIT::emitSlow_op_check_tdz): Ditto.
588         * jit/JITOpcodes32_64.cpp:
589         (JSC::JIT::emit_op_check_tdz): Ditto.
590         (JSC::JIT::emitSlow_op_check_tdz): Ditto.
591         * llint/LowLevelInterpreter32_64.asm: Implements op_check_tdz in LLint.
592         * llint/LowLevelInterpreter64.asm: Ditto.
593         * runtime/CommonSlowPaths.cpp:
594         (JSC::SLOW_PATH_DECL): Throws a reference error for op_check_tdz. Shared by LLint and Baseline JIT.
595         * runtime/CommonSlowPaths.h:
596         * tests/stress/class-syntax-no-loop-tdz.js: Added.
597         * tests/stress/class-syntax-no-tdz-in-catch.js: Added.
598         * tests/stress/class-syntax-no-tdz-in-conditional.js: Added.
599         * tests/stress/class-syntax-no-tdz-in-loop-no-inline-super.js: Added.
600         * tests/stress/class-syntax-no-tdz-in-loop.js: Added.
601         * tests/stress/class-syntax-no-tdz.js: Added.
602         * tests/stress/class-syntax-tdz-in-catch.js: Added.
603         * tests/stress/class-syntax-tdz-in-conditional.js: Added.
604         * tests/stress/class-syntax-tdz-in-loop.js: Added.
605         * tests/stress/class-syntax-tdz.js: Added.
606
607 2015-03-12  Yusuke Suzuki  <utatane.tea@gmail.com>
608
609         Integrate MapData into JSMap and JSSet
610         https://bugs.webkit.org/show_bug.cgi?id=142556
611
612         Reviewed by Filip Pizlo.
613
614         This patch integrates MapData into JSMap and JSSet.
615         This removes 2 object allocation per one JSMap / JSSet.
616
617         MapDataImpl is specialized into MapData and SetData.
618         In the case of SetData, it does not have the dummy values
619         previously stored in the MapDataImpl. So the storage size of SetData
620         becomes the half of the previous implementation.
621
622         And now MapData and SetData are completely integrated into JSMap and JSSet,
623         these structures are not exposed to the other code even in WebCore world.
624
625         And at the same time, this patch fixes missing destroy functions
626         in JSMapIterator and JSSetIterator.
627         They are needed because MapData::const_iterator is a non-trivial destructor.
628
629         * CMakeLists.txt:
630         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
631         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
632         * JavaScriptCore.xcodeproj/project.pbxproj:
633         * runtime/JSMap.cpp:
634         (JSC::JSMap::destroy):
635         (JSC::JSMap::visitChildren):
636         (JSC::JSMap::copyBackingStore):
637         (JSC::JSMap::has):
638         (JSC::JSMap::size):
639         (JSC::JSMap::get):
640         (JSC::JSMap::set):
641         (JSC::JSMap::clear):
642         (JSC::JSMap::remove):
643         (JSC::JSMap::finishCreation): Deleted.
644         * runtime/JSMap.h:
645         (JSC::JSMap::Entry::key):
646         (JSC::JSMap::Entry::value):
647         (JSC::JSMap::Entry::visitChildren):
648         (JSC::JSMap::Entry::setKey):
649         (JSC::JSMap::Entry::setKeyWithoutWriteBarrier):
650         (JSC::JSMap::Entry::setValue):
651         (JSC::JSMap::Entry::clear):
652         (JSC::JSMap::begin):
653         (JSC::JSMap::end):
654         (JSC::JSMap::JSMap):
655         (JSC::JSMap::mapData): Deleted.
656         * runtime/JSMapIterator.cpp:
657         (JSC::JSMapIterator::finishCreation):
658         (JSC::JSMapIterator::destroy):
659         (JSC::JSMapIterator::visitChildren):
660         * runtime/JSMapIterator.h:
661         (JSC::JSMapIterator::JSMapIterator):
662         * runtime/JSSet.cpp:
663         (JSC::JSSet::destroy):
664         (JSC::JSSet::visitChildren):
665         (JSC::JSSet::copyBackingStore):
666         (JSC::JSSet::has):
667         (JSC::JSSet::size):
668         (JSC::JSSet::add):
669         (JSC::JSSet::clear):
670         (JSC::JSSet::remove):
671         (JSC::JSSet::finishCreation): Deleted.
672         * runtime/JSSet.h:
673         (JSC::JSSet::Entry::key):
674         (JSC::JSSet::Entry::value):
675         (JSC::JSSet::Entry::visitChildren):
676         (JSC::JSSet::Entry::setKey):
677         (JSC::JSSet::Entry::setKeyWithoutWriteBarrier):
678         (JSC::JSSet::Entry::setValue):
679         (JSC::JSSet::Entry::clear):
680         (JSC::JSSet::begin):
681         (JSC::JSSet::end):
682         (JSC::JSSet::JSSet):
683         (JSC::JSSet::mapData): Deleted.
684         * runtime/JSSetIterator.cpp:
685         (JSC::JSSetIterator::finishCreation):
686         (JSC::JSSetIterator::visitChildren):
687         (JSC::JSSetIterator::destroy):
688         * runtime/JSSetIterator.h:
689         (JSC::JSSetIterator::JSSetIterator):
690         * runtime/MapConstructor.cpp:
691         (JSC::constructMap):
692         * runtime/MapData.h:
693         (JSC::MapDataImpl::const_iterator::key):
694         (JSC::MapDataImpl::const_iterator::value):
695         (JSC::MapDataImpl::size):
696         (JSC::MapDataImpl<Entry>::MapDataImpl):
697         (JSC::MapDataImpl<Entry>::clear):
698         (JSC::MapDataImpl<Entry>::KeyType::KeyType):
699         (JSC::MapDataImpl<Entry>::const_iterator::internalIncrement):
700         (JSC::MapDataImpl<Entry>::const_iterator::ensureSlot):
701         (JSC::MapDataImpl<Entry>::const_iterator::const_iterator):
702         (JSC::MapDataImpl<Entry>::const_iterator::~const_iterator):
703         (JSC::MapDataImpl<Entry>::const_iterator::operator):
704         (JSC::=):
705         (JSC::MapData::const_iterator::key): Deleted.
706         (JSC::MapData::const_iterator::value): Deleted.
707         (JSC::MapData::create): Deleted.
708         (JSC::MapData::createStructure): Deleted.
709         (JSC::MapData::size): Deleted.
710         (JSC::MapData::clear): Deleted.
711         (JSC::MapData::KeyType::KeyType): Deleted.
712         (JSC::MapData::const_iterator::internalIncrement): Deleted.
713         (JSC::MapData::const_iterator::ensureSlot): Deleted.
714         (JSC::MapData::const_iterator::const_iterator): Deleted.
715         (JSC::MapData::const_iterator::~const_iterator): Deleted.
716         (JSC::MapData::const_iterator::operator*): Deleted.
717         (JSC::MapData::const_iterator::end): Deleted.
718         (JSC::MapData::const_iterator::operator!=): Deleted.
719         (JSC::MapData::const_iterator::operator==): Deleted.
720         * runtime/MapDataInlines.h: Renamed from Source/JavaScriptCore/runtime/MapData.cpp.
721         (JSC::MapDataImpl<Entry>::find):
722         (JSC::MapDataImpl<Entry>::contains):
723         (JSC::MapDataImpl<Entry>::add):
724         (JSC::MapDataImpl<Entry>::set):
725         (JSC::MapDataImpl<Entry>::get):
726         (JSC::MapDataImpl<Entry>::remove):
727         (JSC::MapDataImpl<Entry>::replaceAndPackBackingStore):
728         (JSC::MapDataImpl<Entry>::replaceBackingStore):
729         (JSC::MapDataImpl<Entry>::ensureSpaceForAppend):
730         (JSC::MapDataImpl<Entry>::visitChildren):
731         (JSC::MapDataImpl<Entry>::copyBackingStore):
732         * runtime/MapPrototype.cpp:
733         (JSC::getMap):
734         (JSC::mapProtoFuncClear):
735         (JSC::mapProtoFuncDelete):
736         (JSC::mapProtoFuncForEach):
737         (JSC::mapProtoFuncGet):
738         (JSC::mapProtoFuncHas):
739         (JSC::mapProtoFuncSet):
740         (JSC::mapProtoFuncSize):
741         (JSC::getMapData): Deleted.
742         * runtime/SetPrototype.cpp:
743         (JSC::getSet):
744         (JSC::setProtoFuncAdd):
745         (JSC::setProtoFuncClear):
746         (JSC::setProtoFuncDelete):
747         (JSC::setProtoFuncForEach):
748         (JSC::setProtoFuncHas):
749         (JSC::setProtoFuncSize):
750         (JSC::getMapData): Deleted.
751         * runtime/VM.cpp:
752         (JSC::VM::VM):
753         * runtime/VM.h:
754
755 2015-03-12  Mark Lam  <mark.lam@apple.com>
756
757         Use std::atomic for CodeBlock::m_visitAggregateHasBeenCalled.
758         <https://webkit.org/b/142640>
759
760         Reviewed by Mark Hahnenberg.
761
762         We used to spin our own compare and swap on a uint8_t.  Now that we can
763         use C++11, let's use std::atomic instead.
764
765         * bytecode/CodeBlock.cpp:
766         (JSC::CodeBlock::visitAggregate):
767         - The CAS here needs std::memory_order_acquire ordering because it
768           requires lock acquisition semantics to visit the CodeBlock.
769
770         * bytecode/CodeBlock.h:
771         (JSC::CodeBlockSet::mark):
772         * heap/CodeBlockSet.cpp:
773         (JSC::CodeBlockSet::clearMarksForFullCollection):
774         (JSC::CodeBlockSet::clearMarksForEdenCollection):
775         - These can go with relaxed ordering because they are all done before
776           the GC starts parallel marking.
777
778 2015-03-12  Csaba Osztrogonác  <ossy@webkit.org>
779
780         [cmake] Fix the incremental build issue revealed by r181419
781         https://bugs.webkit.org/show_bug.cgi?id=142613
782
783         Reviewed by Carlos Garcia Campos.
784
785         * CMakeLists.txt:
786
787 2015-03-11  Ryosuke Niwa  <rniwa@webkit.org>
788
789         "static" should not be a reserved keyword in non-strict mode even when ES6 class is enabled
790         https://bugs.webkit.org/show_bug.cgi?id=142600
791
792         Reviewed by Mark Lam.
793
794         Make "static" RESERVED_IF_STRICT and manually detect it in parseClass.
795
796         No new tests. This is already checked by js/reserved-words.html and js/keywords-and-reserved_words.html
797
798         * parser/Keywords.table:
799         * parser/Parser.cpp:
800         (JSC::Parser<LexerType>::parseClass):
801         * parser/ParserTokens.h:
802
803 2015-03-11  Geoffrey Garen  <ggaren@apple.com>
804
805         Many users of Heap::reportExtraMemory* are wrong, causing lots of memory growth
806         https://bugs.webkit.org/show_bug.cgi?id=142593
807
808         Reviewed by Andreas Kling.
809
810         Adopt deprecatedReportExtraMemory as a short-term fix for runaway
811         memory growth in these cases where we have not adopted
812         reportExtraMemoryVisited.
813
814         Long-term, we should use reportExtraMemoryAllocated+reportExtraMemoryVisited.
815         That's tracked by https://bugs.webkit.org/show_bug.cgi?id=142595.
816
817         * API/JSBase.cpp:
818         (JSReportExtraMemoryCost):
819         * runtime/SparseArrayValueMap.cpp:
820         (JSC::SparseArrayValueMap::add):
821
822 2015-03-11  Geoffrey Garen  <ggaren@apple.com>
823
824         Refactored the JSC::Heap extra cost API for clarity and to make some known bugs more obvious
825         https://bugs.webkit.org/show_bug.cgi?id=142589
826
827         Reviewed by Andreas Kling.
828
829         * API/JSBase.cpp:
830         (JSReportExtraMemoryCost): Added a FIXME to annotate a known bug.
831
832         * bytecode/CodeBlock.cpp:
833         (JSC::CodeBlock::CodeBlock):
834         (JSC::CodeBlock::visitAggregate):
835         * bytecode/CodeBlock.h:
836         (JSC::CodeBlock::setJITCode): Updated for rename.
837
838         * heap/Heap.cpp:
839         (JSC::Heap::Heap):
840         (JSC::Heap::reportExtraMemoryAllocatedSlowCase):
841         (JSC::Heap::deprecatedReportExtraMemorySlowCase): Renamed our reporting
842         APIs to clarify their relationship to each other: One must report extra
843         memory at the time of allocation, and at the time the GC visits it.
844
845         (JSC::Heap::extraMemorySize):
846         (JSC::Heap::size):
847         (JSC::Heap::capacity):
848         (JSC::Heap::sizeAfterCollect):
849         (JSC::Heap::willStartCollection): Updated for renames. Added explicit
850         API for deprecated users who can't use our best API.
851  
852         (JSC::Heap::reportExtraMemoryCostSlowCase): Deleted.
853         (JSC::Heap::extraSize): Deleted.
854
855         * heap/Heap.h:
856         * heap/HeapInlines.h:
857         (JSC::Heap::reportExtraMemoryAllocated):
858         (JSC::Heap::reportExtraMemoryVisited):
859         (JSC::Heap::deprecatedReportExtraMemory):
860         (JSC::Heap::reportExtraMemoryCost): Deleted. Ditto.
861
862         * heap/SlotVisitor.h:
863         * heap/SlotVisitorInlines.h:
864         (JSC::SlotVisitor::reportExtraMemoryVisited):
865         (JSC::SlotVisitor::reportExtraMemoryUsage): Deleted. Moved this
866         functionality into the Heap since it's pretty detailed in its access
867         to the heap.
868
869         * runtime/JSArrayBufferView.cpp:
870         (JSC::JSArrayBufferView::ConstructionContext::ConstructionContext):
871         * runtime/JSGenericTypedArrayViewInlines.h:
872         (JSC::JSGenericTypedArrayView<Adaptor>::visitChildren): Updated for
873         renames.
874
875         * runtime/JSString.cpp:
876         (JSC::JSString::visitChildren):
877         (JSC::JSRopeString::resolveRopeToAtomicString):
878         (JSC::JSRopeString::resolveRope):
879         * runtime/JSString.h:
880         (JSC::JSString::finishCreation): Updated for renames.
881
882         * runtime/SparseArrayValueMap.cpp:
883         (JSC::SparseArrayValueMap::add): Added FIXME.
884
885         * runtime/WeakMapData.cpp:
886         (JSC::WeakMapData::visitChildren): Updated for rename.
887
888 2015-03-11  Ryosuke Niwa  <rniwa@webkit.org>
889
890         Calling super() in a base class results in a crash
891         https://bugs.webkit.org/show_bug.cgi?id=142563
892
893         Reviewed by Filip Pizlo.
894
895         The bug was caused by BytecodeGenerator trying to generate "super" expression inside the constructor of a base class.
896         Disallow that by keeping track of whether "super" has been used in the current scope or not (needsSuperBinding flag)
897         and then throwing a syntax error in parseFunctionInfo if it was used and the current scope wasn't the constructor of
898         a derived class.
899
900         * parser/Parser.cpp:
901         (JSC::Parser<LexerType>::parseFunctionInfo): Don't allow super() or super.foo outside the constructor of a derived class.
902         (JSC::Parser<LexerType>::parseClass): Pass in the constructor kind to parseGetterSetter.
903         (JSC::Parser<LexerType>::parseGetterSetter): Ditto to parseFunctionInfo.
904         (JSC::Parser<LexerType>::parseMemberExpression): Set needsSuperBinding flag true on the containing scope.
905         * parser/Parser.h:
906         (JSC::Scope::Scope):
907         (JSC::Scope::needsSuperBinding): Added.
908         (JSC::Scope::setNeedsSuperBinding): Added.
909
910 2015-03-10  Darin Adler  <darin@apple.com>
911
912         Some event handler fixes
913         https://bugs.webkit.org/show_bug.cgi?id=142474
914
915         Reviewed by Anders Carlsson.
916
917         * inspector/InjectedScriptManager.cpp:
918         (Inspector::InjectedScriptManager::createInjectedScript): Call clearException.
919         I spotted the fact it was missing by auditing all the calls to JSC::call.
920
921 2015-03-10  Matthew Mirman  <mmirman@apple.com>
922
923         Functions should have initialization precedence over arguments. 
924         https://bugs.webkit.org/show_bug.cgi?id=142550
925         rdar://problem/19702564
926
927         Reviewed by Geoffrey Garen.
928
929         * bytecompiler/BytecodeGenerator.cpp:
930         (JSC::BytecodeGenerator::BytecodeGenerator):
931         (JSC::BytecodeGenerator::initializeCapturedVariable):
932         * tests/stress/initialize_functions_after_arguments.js: Added.
933
934 2015-03-10  Andreas Kling  <akling@apple.com>
935
936         Eden collections should trigger sweep of MarkedBlocks containing new objects.
937         <https://webkit.org/b/142538>
938
939         Reviewed by Geoffrey Garen.
940
941         Take a snapshot of all MarkedBlocks with new objects as part of Eden collections,
942         and append that to the IncrementalSweeper's working set.
943
944         This ensures that we run destructors for objects that were discovered to be garbage during
945         Eden collections, instead of delaying their teardown until the next full collection,
946         or the next allocation cycle for their block.
947
948         * heap/Heap.cpp:
949         (JSC::Heap::snapshotMarkedSpace): For Eden collections, snapshot the list of MarkedBlocks
950         that contain new objects, since those are the only ones we're interested in.
951         Also use Vector::resizeToFit() to allocate the snapshot for full collections, since we know
952         the final size we need up front.
953
954         (JSC::Heap::notifyIncrementalSweeper): For Eden collections, tell the IncrementalSweeper
955         to add the block snapshot (taken earlier) to its existing set of blocks instead of replacing
956         it entirely. This allows Eden collections and incremental sweeping to occur interleaved with
957         each other without missing destruction opportunities.
958
959         * heap/IncrementalSweeper.h:
960         * heap/IncrementalSweeper.cpp:
961         (JSC::IncrementalSweeper::doSweep):
962         (JSC::IncrementalSweeper::sweepNextBlock): Change the way we iterate over the sweeper's
963         work list: instead of keeping an index for the next block, just pop from the end of the list.
964         This allows us to add new blocks and deduplicate the list without disturbing iteration.
965
966         (JSC::IncrementalSweeper::startSweeping): Make this take a Vector<MarkedBlock>&& so we can
967         pass ownership of this Vector efficiently from Heap to IncrementalSweeper.
968
969         (JSC::IncrementalSweeper::addBlocksAndContinueSweeping): Added. This is used by Eden
970         collections to add a set of MarkedBlocks with new objects to the sweeper's existing
971         working set and kick the timer.
972
973         * heap/MarkedSpace.h:
974         (JSC::MarkedSpace::blocksWithNewObjects): Expose the list of MarkedBlocks with new objects.
975
976 2015-03-10  Alex Christensen  <achristensen@webkit.org>
977
978         Use unsigned for HashSet size.
979         https://bugs.webkit.org/show_bug.cgi?id=142518
980
981         Reviewed by Benjamin Poulain.
982
983         * dfg/DFGAvailabilityMap.cpp:
984         (JSC::DFG::AvailabilityMap::prune):
985         * ftl/FTLOSRExitCompiler.cpp:
986         (JSC::FTL::compileStub):
987         * heap/MarkedBlockSet.h:
988         (JSC::MarkedBlockSet::remove):
989         * runtime/WeakMapData.h:
990
991 2015-03-10  Mark Lam  <mark.lam@apple.com>
992
993         Use std::numeric_limits<unsigned>::max() instead of (unsigned)-1.
994         <https://webkit.org/b/142539>
995
996         Reviewed by Benjamin Poulain.
997
998         * jit/JIT.cpp:
999         (JSC::JIT::JIT):
1000         (JSC::JIT::privateCompileMainPass):
1001         (JSC::JIT::privateCompileSlowCases):
1002         (JSC::JIT::privateCompile):
1003         (JSC::JIT::privateCompileExceptionHandlers):
1004         * jit/JITInlines.h:
1005         (JSC::JIT::emitNakedCall):
1006         (JSC::JIT::addSlowCase):
1007         (JSC::JIT::addJump):
1008         (JSC::JIT::emitJumpSlowToHot):
1009         (JSC::JIT::emitGetVirtualRegister):
1010         * jit/SlowPathCall.h:
1011         (JSC::JITSlowPathCall::call):
1012         * yarr/Yarr.h:
1013
1014 2015-03-10  Mark Lam  <mark.lam@apple.com>
1015
1016         [Win] JSC Build Warnings Need to be Resolved.
1017         <https://webkit.org/b/142366>
1018
1019         Reviewed by Brent Fulgham.
1020
1021         Applied some benign changes to make the MSVC compiler happy.
1022
1023         * bytecode/CodeBlock.cpp:
1024         (JSC::CodeBlock::dumpBytecode):
1025         * dfg/DFGSpeculativeJIT32_64.cpp:
1026         (JSC::DFG::SpeculativeJIT::fillJSValue):
1027         * runtime/BasicBlockLocation.cpp:
1028         (JSC::BasicBlockLocation::getExecutedRanges):
1029         * runtime/ControlFlowProfiler.cpp:
1030         (JSC::ControlFlowProfiler::hasBasicBlockAtTextOffsetBeenExecuted):
1031
1032 2015-03-10  Yusuke Suzuki  <utatane.tea@gmail.com>
1033
1034         Upgrade Map, Set and WeakMap constructor interface
1035         https://bugs.webkit.org/show_bug.cgi?id=142348
1036
1037         Reviewed by Filip Pizlo.
1038
1039         In the latest ES6 spec, Map and Set constructors take initialization data sets
1040         as iterable value. And iterate it and add the values into the constructed one.
1041
1042         This is breaking change because the old constructor interface is
1043         already shipped in Safari 8.
1044
1045         * runtime/MapConstructor.cpp:
1046         (JSC::callMap):
1047         (JSC::constructMap):
1048         (JSC::MapConstructor::getCallData):
1049         * runtime/SetConstructor.cpp:
1050         (JSC::callSet):
1051         (JSC::constructSet):
1052         * runtime/WeakMapConstructor.cpp:
1053         (JSC::callWeakMap):
1054         (JSC::constructWeakMap):
1055         (JSC::WeakMapConstructor::getCallData):
1056         * tests/stress/map-constructor-adder.js: Added.
1057         * tests/stress/map-constructor.js: Added.
1058         (testCallTypeError):
1059         (testTypeError):
1060         (for):
1061         * tests/stress/set-constructor-adder.js: Added.
1062         (Set.prototype.add):
1063         * tests/stress/set-constructor.js: Added.
1064         (for):
1065         * tests/stress/weak-map-constructor-adder.js: Added.
1066         * tests/stress/weak-map-constructor.js: Added.
1067         (testCallTypeError):
1068         (testTypeError):
1069         (for):
1070
1071 2015-03-10  Michael Catanzaro  <mcatanzaro@igalia.com>
1072
1073         GCC: CRASH() should be annotated with NORETURN
1074         https://bugs.webkit.org/show_bug.cgi?id=142524
1075
1076         Reviewed by Anders Carlsson.
1077
1078         Don't return from a NORETURN function. This used to avoid a warning from GCC, but now it
1079         causes one.
1080
1081         * jsc.cpp:
1082
1083 2015-03-10  Mark Lam  <mark.lam@apple.com>
1084
1085         Gardening: fix bleeding debug test bots.
1086         https://webkit.org/b/142513>
1087
1088         Not reviewed.
1089
1090         The test needs to initialize WTF threading explicitly before using it.
1091
1092         * API/tests/CompareAndSwapTest.cpp:
1093         (testCompareAndSwap):
1094
1095 2015-03-10  Alex Christensen  <achristensen@webkit.org>
1096
1097         [WinCairo] Unreviewed build fix.
1098
1099         * JavaScriptCore.vcxproj/testapi/testapiCommonCFLite.props:
1100         Added directory containing config.h, like r181304.
1101
1102 2015-03-09  Mark Lam  <mark.lam@apple.com>
1103
1104         Yet another build fix for Windows.
1105         https://webkit.org/b/142513>
1106
1107         Reviewed by Alex Christensen.
1108
1109         Looks like MSVC requires the function be explicitly declared in a header file
1110         in order for it to be linkable from another file in the same project.  This is
1111         strange, but it seems to make MSVC happy.
1112
1113         Also fixed a typo in testapi.vcxproj.filters.
1114
1115         * API/tests/CompareAndSwapTest.cpp:
1116         * API/tests/CompareAndSwapTest.h: Added.
1117         * API/tests/testapi.c:
1118         * JavaScriptCore.vcxproj/testapi/testapi.vcxproj:
1119         * JavaScriptCore.vcxproj/testapi/testapi.vcxproj.filters:
1120         * JavaScriptCore.xcodeproj/project.pbxproj:
1121
1122 2015-03-09  Chris Dumez  <cdumez@apple.com>
1123
1124         [iOS] Sweep all collected objects on critical memory pressure
1125         https://bugs.webkit.org/show_bug.cgi?id=142457
1126         <rdar://problem/20044440>
1127
1128         Reviewed by Geoffrey Garen.
1129
1130         All fullSweep() API to IncrementalSweeper so that we can call it in the
1131         memory pressure handler.
1132
1133         * heap/IncrementalSweeper.cpp:
1134         (JSC::IncrementalSweeper::fullSweep):
1135         * heap/IncrementalSweeper.h:
1136         (JSC::IncrementalSweeper::hasWork):
1137
1138 2015-03-09  Mark Lam  <mark.lam@apple.com>
1139
1140         Another build fix for Windows.
1141         https://webkit.org/b/142513>
1142
1143         Not reviewed.
1144
1145         * API/tests/CompareAndSwapTest.cpp:
1146         - Added JS_EXPORT_PRIVATE attribute.
1147
1148 2015-03-09  Mark Lam  <mark.lam@apple.com>
1149
1150         Build fix for Windows after r181305.
1151         https://webkit.org/b/142513>
1152
1153         Reviewed by Alex Christensen.
1154
1155         Windows doesn't like pthreads anymore.  Changed test to use WTF threading.
1156
1157         * API/tests/CompareAndSwapTest.cpp:
1158         (setBitThreadFunc):
1159         (testCompareAndSwap):
1160
1161 2015-03-09  Mark Lam  <mark.lam@apple.com>
1162
1163         8-bit version of weakCompareAndSwap() can cause an infinite loop.
1164         https://webkit.org/b/142513>
1165
1166         Reviewed by Filip Pizlo.
1167
1168         Added a test that exercises the 8-bit CAS from multiple threads.  The threads
1169         will contend to set bits in a large array of bytes using the CAS function.
1170
1171         * API/tests/CompareAndSwapTest.cpp: Added.
1172         (Bitmap::Bitmap):
1173         (Bitmap::numBits):
1174         (Bitmap::clearAll):
1175         (Bitmap::concurrentTestAndSet):
1176         (setBitThreadFunc):
1177         (testCompareAndSwap):
1178         * API/tests/testapi.c:
1179         (main):
1180         * JavaScriptCore.vcxproj/testapi/testapi.vcxproj:
1181         * JavaScriptCore.vcxproj/testapi/testapi.vcxproj.filters:
1182         * JavaScriptCore.xcodeproj/project.pbxproj:
1183
1184 2015-03-09  Brent Fulgham  <bfulgham@apple.com>
1185
1186         [Win] testapi project is unable to find the 'config.h' file.
1187
1188         Rubberstamped by Mark Lam.
1189
1190         * JavaScriptCore.vcxproj/testapi/testapiCommon.props: Add JavaScriptCore source directory
1191         to the include path.
1192
1193 2015-03-09  Andreas Kling  <akling@apple.com>
1194
1195         Stale entries in WeakGCMaps are keeping tons of WeakBlocks alive unnecessarily.
1196         <https://webkit.org/b/142115>
1197         <rdar://problem/19992268>
1198
1199         Reviewed by Geoffrey Garen.
1200
1201         Prune stale entries from WeakGCMaps as part of every full garbage collection.
1202         This frees up tons of previously-stuck WeakBlocks that were only sitting around
1203         with finalized handles waiting to die.
1204
1205         Note that WeakGCMaps register/unregister themselves with the GC heap in their
1206         ctor/dtor, so creating one now requires passing the VM.
1207
1208         Average time spent in the PruningStaleEntriesFromWeakGCMaps GC phase appears
1209         to be between 0.01ms and 0.3ms, though I've seen a few longer ones at ~1.2ms.
1210         It seems somewhat excessive to do this on every Eden collection, so it's only
1211         doing work in full collections for now.
1212
1213         Because the GC may now mutate WeakGCMap below object allocation, I've made it
1214         so that the classic HashMap::add() optimization can't be used with WeakGCMap.
1215         This caused intermittent test failures when originally landed due to having
1216         an invalid iterator on the stack after add() inserted a new entry and we
1217         proceeded to allocate the new object, triggering GC.
1218
1219         * API/JSWeakObjectMapRefInternal.h:
1220         (OpaqueJSWeakObjectMap::create):
1221         (OpaqueJSWeakObjectMap::OpaqueJSWeakObjectMap):
1222         * API/JSWeakObjectMapRefPrivate.cpp:
1223         * API/JSWrapperMap.mm:
1224         (-[JSWrapperMap initWithContext:]):
1225         (-[JSWrapperMap jsWrapperForObject:]): Pass VM to WeakGCMap constructor.
1226
1227         * JavaScriptCore.xcodeproj/project.pbxproj: Add WeakGCMapInlines.h and make
1228         it project-private so WebCore clients can access it.
1229
1230         * heap/Heap.cpp:
1231         (JSC::Heap::collect):
1232         (JSC::Heap::pruneStaleEntriesFromWeakGCMaps): Added a new GC phase for pruning
1233         stale entries from WeakGCMaps. This is only executed during full collections.
1234
1235         * heap/Heap.h:
1236         * heap/HeapInlines.h:
1237         (JSC::Heap::registerWeakGCMap):
1238         (JSC::Heap::unregisterWeakGCMap): Added a mechanism for WeakGCMaps to register
1239         themselves with the Heap and provide a pruning callback.
1240
1241         * runtime/PrototypeMap.h:
1242         (JSC::PrototypeMap::PrototypeMap):
1243         * runtime/Structure.cpp:
1244         (JSC::StructureTransitionTable::add): Pass VM to WeakGCMap constructor.
1245
1246         * runtime/JSCInlines.h: Add "WeakGCMapInlines.h"
1247
1248         * runtime/JSGlobalObject.cpp: Include "WeakGCMapInlines.h" so this builds.
1249
1250         * runtime/JSString.cpp:
1251         (JSC::jsStringWithCacheSlowCase):
1252         * runtime/PrototypeMap.cpp:
1253         (JSC::PrototypeMap::addPrototype):
1254         (JSC::PrototypeMap::emptyObjectStructureForPrototype): Remove HashMap add()
1255         optimization since it's not safe in the GC-managed WeakGCMap world.
1256
1257         * runtime/VM.cpp:
1258         (JSC::VM::VM): Pass VM to WeakGCMap constructor.
1259
1260         * runtime/WeakGCMap.h:
1261         (JSC::WeakGCMap::set):
1262         (JSC::WeakGCMap::add):
1263         (JSC::WeakGCMap::WeakGCMap): Deleted.
1264         (JSC::WeakGCMap::gcMap): Deleted.
1265         (JSC::WeakGCMap::gcMapIfNeeded): Deleted.
1266         * runtime/WeakGCMapInlines.h: Added.
1267         (JSC::WeakGCMap::WeakGCMap):
1268         (JSC::WeakGCMap::~WeakGCMap):
1269         (JSC::WeakGCMap::pruneStaleEntries): Moved ctor, dtor and pruning callback
1270         to WeakGCMapInlines.h to fix interdependent header issues. Removed code that
1271         prunes WeakGCMap at certain growth milestones and instead rely on the GC
1272         callback for housekeeping.
1273
1274 2015-03-09  Ryosuke Niwa  <rniwa@webkit.org>
1275
1276         Support extends and super keywords
1277         https://bugs.webkit.org/show_bug.cgi?id=142200
1278
1279         Reviewed by Filip Pizlo.
1280
1281         Added the support for ES6 class syntax inheritance.
1282
1283         Added ConstructorKind as well as boolean flags indicating the constructor kind to
1284         various classes in UnlinkedCodeBlock as well as AST nodes.
1285
1286         Each method stores the associated class as its homeObjectPrivateName. This value is used to
1287         make super calls.
1288
1289         * bytecode/UnlinkedCodeBlock.cpp:
1290         (JSC::generateFunctionCodeBlock):
1291         (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
1292         (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):
1293
1294         * bytecode/UnlinkedCodeBlock.h:
1295         (JSC::ExecutableInfo::ExecutableInfo):
1296         (JSC::UnlinkedFunctionExecutable::constructorKindIsDerived): Added.
1297         (JSC::UnlinkedCodeBlock::constructorKindIsDerived): Added.
1298
1299         * bytecompiler/BytecodeGenerator.cpp:
1300         (JSC::BytecodeGenerator::BytecodeGenerator): Don't emit op_create_this in a derived class
1301         as the object is allocated by the highest base class's constructor. Also set "this" to null
1302         and store the original value in m_newTargetRegister. "this" is supposed to be in TDZ but
1303         that will be implemented in a separate patch.
1304         (JSC::BytecodeGenerator::emitReturn): Allow "undefined" to be returned from a derived class.
1305         In a derived class's constructor, not returning "undefined" or an object results in a type
1306         error instead of "this" being returned.
1307         (JSC::BytecodeGenerator::emitThrowTypeError): Added.
1308
1309         * bytecompiler/BytecodeGenerator.h:
1310         (JSC::BytecodeGenerator::constructorKindIsDerived): Added.
1311         (JSC::BytecodeGenerator::newTarget): Added.
1312
1313         * bytecompiler/NodesCodegen.cpp:
1314         (JSC::SuperNode::emitBytecode): Added. Emits the code to obtain the callee's parent class.
1315         (JSC::emitSuperBaseForCallee): Added. Emits the code to obtain the parent class's prototype.
1316         (JSC::emitPutHomeObject): Added.
1317         (JSC::PropertyListNode::emitBytecode): Stores the home object when adding methods.
1318         (JSC::PropertyListNode::emitPutConstantProperty): Ditto.
1319         (JSC::BracketAccessorNode::emitBytecode): Added the support for super['foo'].
1320         (JSC::DotAccessorNode::emitBytecode): Added the support for super.foo.
1321         (JSC::FunctionCallValueNode::emitBytecode): Added the support for super().
1322         (JSC::FunctionCallBracketNode::emitBytecode): Added the support for super['foo']().
1323         (JSC::FunctionCallDotNode::emitBytecode): Added the support for super.foo().
1324         (JSC::DeleteBracketNode::emitBytecode): Forbid "delete super.foo".
1325         (JSC::DeleteDotNode::emitBytecode): Forbid "delete super['foo']".
1326         (JSC::ClassExprNode::emitBytecode): Added the support for "classHeritage". This is the main
1327         logic for inheritance. When a class B inherits from a class A, set B.__proto__ to A and set
1328         B.prototype.__proto__ to A.prototype. Throw exceptions when either A or A.__proto__ is not
1329         an object.
1330
1331         * parser/ASTBuilder.h:
1332         (JSC::ASTBuilder::superExpr): Added.
1333
1334         * parser/NodeConstructors.h:
1335         (JSC::SuperNode::SuperNode): Added.
1336
1337         * parser/Nodes.cpp:
1338         (JSC::FunctionBodyNode::FunctionBodyNode):
1339
1340         * parser/Nodes.h:
1341         (JSC::ExpressionNode::isSuperNode):
1342         (JSC::PropertyNode::type):
1343         (JSC::PropertyNode::needsSuperBinding):
1344
1345         * parser/Parser.cpp:
1346         (JSC::Parser<LexerType>::parseFunctionBody):
1347         (JSC::Parser<LexerType>::parseFunctionInfo): Throw a parser error if super() is used outside
1348         of class constructors.
1349         (JSC::Parser<LexerType>::parseFunctionDeclaration):
1350         (JSC::Parser<LexerType>::parseClass): ConstructorKind is "derived" if and only if the parent
1351         class is specified in the declaration / expression.
1352         (JSC::Parser<LexerType>::parseGetterSetter):
1353         (JSC::Parser<LexerType>::parsePrimaryExpression):
1354         (JSC::Parser<LexerType>::parseMemberExpression): Added the support for "super()", "super.foo",
1355         and "super['foo']". Throw a semantic error if "super" appears by itself.
1356
1357         * parser/Parser.h:
1358         (JSC::Scope::Scope): Added m_hasDirectSuper. This variable keeps track of the use of "super()"
1359         so that parseFunctionInfo can spit an error if it's used outside of class constructors.
1360         (JSC::Scope::hasDirectSuper): Added.
1361         (JSC::Scope::setHasDirectSuper): Added.
1362
1363         * parser/ParserModes.h:
1364         (JSC::ConstructorKind): Added.
1365
1366         * parser/SyntaxChecker.h:
1367         (JSC::SyntaxChecker::superExpr): Added.
1368
1369         * runtime/CommonIdentifiers.h: Added homeObjectPrivateName.
1370
1371         * runtime/Executable.h:
1372         (JSC::EvalExecutable::executableInfo): 
1373         (JSC::ProgramExecutable::executableInfo):
1374
1375 2015-03-08  Andreas Kling  <akling@apple.com>
1376
1377         JITThunks keeps finalized Weaks around, pinning WeakBlocks.
1378         <https://webkit.org/b/142454>
1379
1380         Reviewed by Darin Adler.
1381
1382         Make JITThunks a WeakHandleOwner so it can keep its host function map free of stale entries.
1383         This fixes an issue I was seeing where a bunch of WeakBlocks stuck around with nothing but
1384         finalized Weak<NativeExecutable> entries.
1385
1386         * jit/JITThunks.h:
1387         * jit/JITThunks.cpp:
1388         (JSC::JITThunks::finalize): Make JITThunks inherit from WeakHandleOwner so it can receive
1389         a callback when the NativeExecutables get garbage collected.
1390
1391         (JSC::JITThunks::hostFunctionStub): Pass 'this' as the handle owner when creating Weaks.
1392
1393 2015-03-08  Andreas Kling  <akling@apple.com>
1394
1395         BuiltinExecutables keeps finalized Weaks around, pinning WeakBlocks.
1396         <https://webkit.org/b/142460>
1397
1398         Reviewed by Geoffrey Garen.
1399
1400         Make BuiltinExecutables a WeakHandleOwner so it can clear out its respective Weak members
1401         if and when their pointees get garbage collected.
1402
1403         This fixes an issue I've seen locally where a WeakBlock is pinned down by a single one of
1404         these Weak<BuiltinExecutables>.
1405
1406         * builtins/BuiltinExecutables.h: Make BuiltinExecutables inherit from WeakHandleOwner.
1407
1408         * builtins/BuiltinExecutables.cpp:
1409         (JSC::BuiltinExecutables::finalize): Clear out the relevant member pointer when it's been
1410         garbage collected. We use the WeakImpl's "context" field to pass the address of the member.
1411
1412 2015-03-07  Geoffrey Garen  <ggaren@apple.com>
1413
1414         Use FastMalloc (bmalloc) instead of BlockAllocator for GC pages
1415         https://bugs.webkit.org/show_bug.cgi?id=140900
1416
1417         Reviewed by Mark Hahnenberg.
1418
1419         Re-landing just the removal of BlockAllocator, which is now unused.
1420
1421         * API/JSBase.cpp:
1422         * CMakeLists.txt:
1423         * JavaScriptCore.order:
1424         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
1425         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
1426         * JavaScriptCore.xcodeproj/project.pbxproj:
1427         * heap/BlockAllocator.cpp: Removed.
1428         * heap/BlockAllocator.h: Removed.
1429         * heap/GCThreadSharedData.h:
1430         * heap/HandleBlockInlines.h:
1431         * heap/Heap.cpp:
1432         (JSC::Heap::Heap):
1433         * heap/Heap.h:
1434         * heap/HeapInlines.h:
1435         (JSC::Heap::blockAllocator): Deleted.
1436         * heap/HeapTimer.cpp:
1437         * heap/MarkedBlock.h:
1438         * heap/MarkedSpace.h:
1439         * heap/Region.h: Removed.
1440         * heap/SuperRegion.cpp: Removed.
1441         * heap/SuperRegion.h: Removed.
1442
1443 2015-03-07  Commit Queue  <commit-queue@webkit.org>
1444
1445         Unreviewed, rolling out r181010.
1446         https://bugs.webkit.org/show_bug.cgi?id=142442
1447
1448         Broke media/video-src-invalid-poster.html (Requested by kling
1449         on #webkit).
1450
1451         Reverted changeset:
1452
1453         "Stale entries in WeakGCMaps are keeping tons of WeakBlocks
1454         alive unnecessarily."
1455         https://bugs.webkit.org/show_bug.cgi?id=142115
1456         http://trac.webkit.org/changeset/181010
1457
1458 2015-03-07  Ryosuke Niwa  <rniwa@webkit.org>
1459
1460         The code to link FunctionExecutable is duplicated everywhere
1461         https://bugs.webkit.org/show_bug.cgi?id=142436
1462
1463         Reviewed by Darin Adler.
1464
1465         Reduced code duplication by factoring out linkInsideExecutable and linkGlobalCode.
1466
1467         * bytecode/CodeBlock.cpp:
1468         (JSC::CodeBlock::CodeBlock): Calls linkInsideExecutable.
1469
1470         * bytecode/UnlinkedCodeBlock.cpp:
1471         (JSC::UnlinkedFunctionExecutable::linkInsideExecutable): Renamed from link. Now takes care of startOffset.
1472         This change was needed to use this function in CodeBlock::CodeBlock. Also, this function no longer takes
1473         lineOffset since this information is already stored in the source code.
1474         (JSC::UnlinkedFunctionExecutable::linkGlobalCode): Extracted from FunctionExecutable::fromGlobalCode.
1475
1476         * bytecode/UnlinkedCodeBlock.h:
1477
1478         * generate-js-builtins: Calls linkGlobalCode.
1479
1480         * runtime/Executable.cpp:
1481         (JSC::ProgramExecutable::initializeGlobalProperties): Calls linkGlobalCode.
1482         (JSC::FunctionExecutable::fromGlobalCode): Calls linkGlobalCode.
1483
1484 2015-03-06  Geoffrey Garen  <ggaren@apple.com>
1485
1486         Use FastMalloc (bmalloc) instead of BlockAllocator for GC pages
1487         https://bugs.webkit.org/show_bug.cgi?id=140900
1488
1489         Reviewed by Mark Hahnenberg.
1490
1491         Re-landing just the MarkedBlock piece of this patch.
1492
1493         * heap/MarkedAllocator.cpp:
1494         (JSC::MarkedAllocator::allocateBlock):
1495         * heap/MarkedBlock.cpp:
1496         (JSC::MarkedBlock::create):
1497         (JSC::MarkedBlock::destroy):
1498         (JSC::MarkedBlock::MarkedBlock):
1499         * heap/MarkedBlock.h:
1500         (JSC::MarkedBlock::capacity):
1501         * heap/MarkedSpace.cpp:
1502         (JSC::MarkedSpace::freeBlock):
1503
1504 2015-03-07  Ryosuke Niwa  <rniwa@webkit.org>
1505
1506         fromGlobalCode has an unused Debugger* argument
1507         https://bugs.webkit.org/show_bug.cgi?id=142430
1508
1509         Reviewed by Darin Adler.
1510
1511         Removed the debugger argument from UnlinkedFunctionExecutable::fromGlobalCode and
1512         FunctionExecutable::fromGlobalCode since it's not used in either function.
1513
1514         Also use reference in other arguments.
1515
1516         * bytecode/UnlinkedCodeBlock.cpp:
1517         (JSC::UnlinkedFunctionExecutable::fromGlobalCode):
1518         * bytecode/UnlinkedCodeBlock.h:
1519         * runtime/Executable.cpp:
1520         (JSC::FunctionExecutable::fromGlobalCode):
1521         * runtime/Executable.h:
1522         * runtime/FunctionConstructor.cpp:
1523         (JSC::constructFunctionSkippingEvalEnabledCheck):
1524
1525 2015-03-06  Brent Fulgham  <bfulgham@apple.com>
1526
1527         [Win] Turn off a warning on Windows.
1528
1529         Reduce build logging noise on Windows.
1530
1531         * JavaScriptCore.vcxproj/JavaScriptCoreCommon.props:
1532
1533 2015-03-06  Joseph Pecoraro  <pecoraro@apple.com>
1534
1535         Web Inspector: ES6: Improved Support for Iterator Objects
1536         https://bugs.webkit.org/show_bug.cgi?id=142420
1537
1538         Reviewed by Timothy Hatcher.
1539
1540         * inspector/protocol/Runtime.json:
1541         Add new object subtype "iterator" for built-in iterator objects.
1542
1543         * inspector/InjectedScriptSource.js:
1544         Return iterator values as Entry objects.
1545
1546         * inspector/JSInjectedScriptHost.cpp:
1547         (Inspector::JSInjectedScriptHost::subtype):
1548         Identify "iterator" typed objects.
1549
1550         (Inspector::JSInjectedScriptHost::getInternalProperties):
1551         Provide internal properties for the different Iterator objects.
1552
1553         (Inspector::JSInjectedScriptHost::iteratorEntries):
1554         Fetch the next few iterator entries of a built-in iterator object.
1555
1556         * inspector/JSInjectedScriptHost.h:
1557         * inspector/JSInjectedScriptHostPrototype.cpp:
1558         (Inspector::JSInjectedScriptHostPrototype::finishCreation):
1559         (Inspector::jsInjectedScriptHostPrototypeFunctionIteratorEntries):
1560         Call through to JSInjectedScriptHost.
1561
1562         * runtime/JSArgumentsIterator.cpp:
1563         (JSC::JSArgumentsIterator::clone):
1564         * runtime/JSArgumentsIterator.h:
1565         (JSC::JSArgumentsIterator::iteratedValue):
1566         * runtime/JSArrayIterator.cpp:
1567         (JSC::JSArrayIterator::kind):
1568         (JSC::JSArrayIterator::iteratedValue):
1569         (JSC::JSArrayIterator::clone):
1570         * runtime/JSArrayIterator.h:
1571         * runtime/JSMapIterator.cpp:
1572         (JSC::JSMapIterator::finishCreation):
1573         (JSC::JSMapIterator::clone):
1574         * runtime/JSMapIterator.h:
1575         (JSC::JSMapIterator::kind):
1576         (JSC::JSMapIterator::iteratedValue):
1577         * runtime/JSSetIterator.cpp:
1578         (JSC::JSSetIterator::finishCreation):
1579         (JSC::JSSetIterator::clone):
1580         * runtime/JSSetIterator.h:
1581         (JSC::JSSetIterator::kind):
1582         (JSC::JSSetIterator::iteratedValue):
1583         * runtime/JSStringIterator.cpp:
1584         (JSC::JSStringIterator::iteratedValue):
1585         (JSC::JSStringIterator::clone):
1586         * runtime/JSStringIterator.h:
1587         Add accessors for internal properties and provide a way to clone the
1588         iterator so we can be at the same index and peek at the next few
1589         objects without modifying the original iterator object.
1590
1591 2015-03-06  Ryosuke Niwa  <rniwa@webkit.org>
1592
1593         REGRESSION(r180595): construct varargs fails in FTL
1594         https://bugs.webkit.org/show_bug.cgi?id=142030
1595
1596         Reviewed by Michael Saboff.
1597
1598         Increase sizeOfCallVarargs as done for sizeOfConstructVarargs in r180651.
1599
1600         * ftl/FTLInlineCacheSize.cpp:
1601         (JSC::FTL::sizeOfCallVarargs):
1602
1603 2015-03-06  Joseph Pecoraro  <pecoraro@apple.com>
1604
1605         Web Inspector: Adopt Object Literal Shorthand Property Construction Syntax
1606         https://bugs.webkit.org/show_bug.cgi?id=142374
1607
1608         Reviewed by Timothy Hatcher.
1609
1610         * inspector/InjectedScriptSource.js:
1611
1612 2015-03-06  Joseph Pecoraro  <pecoraro@apple.com>
1613
1614         ES6: Object Literal Extensions - Methods
1615         https://bugs.webkit.org/show_bug.cgi?id=142390
1616
1617         Reviewed by Geoffrey Garen.
1618
1619         Support method syntax in object literals.
1620
1621         * parser/Parser.h:
1622         * parser/Parser.cpp:
1623         (JSC::stringForFunctionMode):
1624         (JSC::Parser<LexerType>::parseProperty):
1625         Methods are allowed for identifier, string, and numeric names,
1626         and computed property names.
1627
1628         (JSC::Parser<LexerType>::parsePropertyMethod):
1629         Helper for parsing a property method.
1630
1631 2015-03-05  Joseph Pecoraro  <pecoraro@apple.com>
1632
1633         __proto__ shorthand property should not modify prototype in Object Literal construction
1634         https://bugs.webkit.org/show_bug.cgi?id=142382
1635
1636         Reviewed by Geoffrey Garen.
1637
1638         When parsing shorthand property syntax we know we will do a
1639         put direct, even if the property name is __proto__. Pass that
1640         information through to bytecode generation.
1641
1642         * bytecompiler/BytecodeGenerator.cpp:
1643         (JSC::BytecodeGenerator::emitDirectPutById):
1644         * bytecompiler/BytecodeGenerator.h:
1645         * bytecompiler/NodesCodegen.cpp:
1646         (JSC::PropertyListNode::emitPutConstantProperty):
1647         * parser/ASTBuilder.h:
1648         (JSC::ASTBuilder::createGetterOrSetterProperty):
1649         (JSC::ASTBuilder::createProperty):
1650         * parser/NodeConstructors.h:
1651         (JSC::PropertyNode::PropertyNode):
1652         * parser/Nodes.h:
1653         (JSC::PropertyNode::putType):
1654         * parser/Parser.cpp:
1655         (JSC::Parser<LexerType>::parseClass):
1656         (JSC::Parser<LexerType>::parseProperty):
1657         * parser/SyntaxChecker.h:
1658         (JSC::SyntaxChecker::createProperty):
1659
1660 2015-03-06  Geoffrey Garen  <ggaren@apple.com>
1661
1662         Fix crashes seen on the the 32-bit buildbots after my last patch.
1663
1664         Unreviewed.
1665
1666         * heap/CopiedBlock.h:
1667         (JSC::CopiedBlock::payload):
1668         * heap/CopiedSpace.cpp:
1669         (JSC::CopiedSpace::tryAllocateOversize): Round up to the right alignment,
1670         since the size of the CopiedBlock class is not guaranteed to be the
1671         right alignment, and is in fact the wrong alignment on 32-bit.
1672
1673 2015-03-05  Geoffrey Garen  <ggaren@apple.com>
1674
1675         Use FastMalloc (bmalloc) instead of BlockAllocator for GC pages
1676         https://bugs.webkit.org/show_bug.cgi?id=140900
1677
1678         Reviewed by Mark Hahnenberg.
1679
1680         Re-landing just the CopiedBlock piece of this patch.
1681
1682         * heap/CopiedBlock.h:
1683         (JSC::CopiedBlock::createNoZeroFill):
1684         (JSC::CopiedBlock::destroy):
1685         (JSC::CopiedBlock::create):
1686         (JSC::CopiedBlock::CopiedBlock):
1687         (JSC::CopiedBlock::isOversize):
1688         (JSC::CopiedBlock::payloadEnd):
1689         (JSC::CopiedBlock::capacity):
1690         * heap/CopiedSpace.cpp:
1691         (JSC::CopiedSpace::~CopiedSpace):
1692         (JSC::CopiedSpace::tryAllocateOversize):
1693         (JSC::CopiedSpace::tryReallocateOversize):
1694         * heap/CopiedSpaceInlines.h:
1695         (JSC::CopiedSpace::recycleEvacuatedBlock):
1696         (JSC::CopiedSpace::recycleBorrowedBlock):
1697         (JSC::CopiedSpace::allocateBlockForCopyingPhase):
1698         (JSC::CopiedSpace::allocateBlock):
1699         (JSC::CopiedSpace::startedCopying):
1700         * heap/CopyWorkList.h:
1701
1702 2015-03-06  Myles C. Maxfield  <mmaxfield@apple.com>
1703
1704         [iOS] SVG fonts are garbled
1705         https://bugs.webkit.org/show_bug.cgi?id=142377
1706
1707         Reviewed by Simon Fraser.
1708
1709         * Configurations/FeatureDefines.xcconfig:
1710
1711 2015-03-05  Joseph Pecoraro  <pecoraro@apple.com>
1712
1713         ES6: Object Literal Extensions - Shorthand Properties (Identifiers)
1714         https://bugs.webkit.org/show_bug.cgi?id=142353
1715
1716         Reviewed by Geoffrey Garen.
1717
1718         * parser/Parser.cpp:
1719         (JSC::Parser<LexerType>::parseProperty):
1720         Parsing an identifier property followed by a comma or end brace treat
1721         as a shorthand property and create a property that has the same
1722         property name as the identifier name and value of a variable with that
1723         identifier. Otherwise, fall through to getter/setter parsing.
1724
1725 2015-03-05  Brent Fulgham  <bfulgham@apple.com>
1726
1727         [Win] Unreviewed gardening.
1728
1729         Confirmed with JSC that warning 4611 (interaction between '_setjmp' and C++ object
1730         destruction is non-portable) should be ignored in the JavaScriptCore project.
1731
1732         * JavaScriptCore.vcxproj/JavaScriptCoreCommon.props: Silence warning 4611.
1733
1734 2015-03-05  Chris Dumez  <cdumez@apple.com>
1735
1736         Regression(r173761): ASSERTION FAILED: !is8Bit() in StringImpl::characters16()
1737         https://bugs.webkit.org/show_bug.cgi?id=142350
1738
1739         Reviewed by Michael Saboff and Benjamin Poulain.
1740
1741         Call WTFString::hasInfixStartingAt() / hasInfixEndingAt() now that these
1742         methods have been renamed for clarity.
1743
1744         * runtime/StringPrototype.cpp:
1745         (JSC::stringProtoFuncStartsWith):
1746         (JSC::stringProtoFuncEndsWith):
1747
1748 2015-03-05  Yusuke Suzuki  <utatane.tea@gmail.com>
1749
1750         Implement ES6 StringIterator
1751         https://bugs.webkit.org/show_bug.cgi?id=142080
1752
1753         Reviewed by Filip Pizlo.
1754
1755         This patch introduces ES6 String Iterator.
1756         It enumerates code points instead of elements in String.
1757         So surrogate pairs should be handled correctly.
1758
1759         * CMakeLists.txt:
1760         * DerivedSources.make:
1761         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
1762         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
1763         * JavaScriptCore.xcodeproj/project.pbxproj:
1764         * builtins/StringIterator.prototype.js: Added.
1765         (next):
1766         * runtime/CommonIdentifiers.h:
1767         * runtime/JSGlobalObject.cpp:
1768         * runtime/JSGlobalObject.h:
1769         * runtime/JSStringIterator.cpp: Added.
1770         (JSC::JSStringIterator::finishCreation):
1771         * runtime/JSStringIterator.h: Added.
1772         (JSC::JSStringIterator::createStructure):
1773         (JSC::JSStringIterator::create):
1774         (JSC::JSStringIterator::JSStringIterator):
1775         * runtime/StringIteratorConstructor.cpp: Added.
1776         (JSC::StringIteratorConstructor::finishCreation):
1777         * runtime/StringIteratorConstructor.h: Added.
1778         (JSC::StringIteratorConstructor::create):
1779         (JSC::StringIteratorConstructor::createStructure):
1780         (JSC::StringIteratorConstructor::StringIteratorConstructor):
1781         * runtime/StringIteratorPrototype.cpp: Added.
1782         (JSC::StringIteratorPrototype::finishCreation):
1783         (JSC::StringIteratorPrototype::getOwnPropertySlot):
1784         (JSC::stringIteratorPrototypeIterator):
1785         * runtime/StringIteratorPrototype.h: Added.
1786         (JSC::StringIteratorPrototype::create):
1787         (JSC::StringIteratorPrototype::createStructure):
1788         (JSC::StringIteratorPrototype::StringIteratorPrototype):
1789         * runtime/StringPrototype.cpp:
1790         (JSC::StringPrototype::finishCreation):
1791         (JSC::stringProtoFuncIterator):
1792         * tests/stress/string-iterators.js: Added.
1793         (testSurrogatePair):
1794         (increment):
1795         (for):
1796
1797 2015-03-05  Csaba Osztrogonác  <ossy@webkit.org>
1798
1799         [ARM] Fix the FTL build on Aarch64 Linux after r177421
1800         https://bugs.webkit.org/show_bug.cgi?id=142040
1801
1802         Reviewed by Mark Lam.
1803
1804         * llvm/library/LLVMExports.cpp:
1805         (initializeAndGetJSCLLVMAPI):
1806
1807 2015-03-05  Yusuke Suzuki  <utatane.tea@gmail.com>
1808
1809         Upgrade ES6 Iterator interfaces
1810         https://bugs.webkit.org/show_bug.cgi?id=141351
1811
1812         Reviewed by Filip Pizlo.
1813
1814         This patch upgrades the exising ES6 iterator to align the latest spec.
1815         In the latest spec,
1816         1. `Iterator.next` returns object that implements IteratorResult interface { value: value, done, boolean }.
1817         2. `Iterator.return` is introduced. When the iteration is terminated by the abrupt completion,
1818         it is called to close iterator state.
1819         3. Iterator.next of Array is moved from an iterator object to `%ArrayIteratorPrototype%`.
1820
1821         To upgrade it, we changes the bytecode that represents for-of loops.
1822         And to embody the efficient iteration with an iterator object,
1823         we implemented %ArrayIteratorPrototype%.next in JavaScript and
1824         it is located in builtins/ArrayIterator.prototype.js.
1825         Implementing it in JavaScript encourages inlining and
1826         utilizes escape analysis for an iterator result object in DFG JIT.
1827         And we dropped the intrinsic version of %ArrayIteratorPrototype%.next.
1828
1829         And we introduced IteratorOperations that is defined in the spec.
1830         It aligns the iteration in the runtime to the latest spec.
1831         Currently, Promise.all and Promise.race uses an iterable object.
1832         However, Promise.all and Promise.race implementation is also based on the old spec.
1833         Subsequent patches will upgrade it.
1834
1835         * CMakeLists.txt:
1836         * DerivedSources.make:
1837         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
1838         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
1839         * JavaScriptCore.xcodeproj/project.pbxproj:
1840         * builtins/ArrayIterator.prototype.js: Copied from Source/JavaScriptCore/runtime/ArrayIteratorPrototype.h.
1841         (next):
1842         * bytecompiler/BytecodeGenerator.cpp:
1843         (JSC::BytecodeGenerator::emitReturn):
1844         (JSC::BytecodeGenerator::emitThrowTypeError):
1845         (JSC::BytecodeGenerator::emitEnumeration):
1846         (JSC::BytecodeGenerator::emitIsObject):
1847         (JSC::BytecodeGenerator::emitIsUndefined):
1848         * bytecompiler/BytecodeGenerator.h:
1849         * jit/ThunkGenerators.cpp:
1850         (JSC::arrayIteratorNextThunkGenerator): Deleted.
1851         (JSC::arrayIteratorNextKeyThunkGenerator): Deleted.
1852         (JSC::arrayIteratorNextValueThunkGenerator): Deleted.
1853         * jit/ThunkGenerators.h:
1854         * runtime/ArgumentsIteratorPrototype.cpp:
1855         (JSC::ArgumentsIteratorPrototype::finishCreation):
1856         (JSC::argumentsIteratorPrototypeFuncNext):
1857         * runtime/ArrayIteratorPrototype.cpp:
1858         (JSC::ArrayIteratorPrototype::finishCreation):
1859         (JSC::ArrayIteratorPrototype::getOwnPropertySlot):
1860         (JSC::arrayIteratorProtoFuncIterator):
1861         (JSC::arrayIteratorPrototypeIterate): Deleted.
1862         * runtime/ArrayIteratorPrototype.h:
1863         * runtime/CommonIdentifiers.h:
1864         * runtime/Intrinsic.h:
1865         * runtime/IteratorOperations.cpp: Added.
1866         (JSC::iteratorNext):
1867         (JSC::iteratorValue):
1868         (JSC::iteratorComplete):
1869         (JSC::iteratorStep):
1870         (JSC::iteratorClose):
1871         (JSC::createIterResultObject):
1872         * runtime/IteratorOperations.h: Copied from Source/JavaScriptCore/runtime/ArrayIteratorPrototype.cpp.
1873         * runtime/JSArrayIterator.cpp:
1874         (JSC::JSArrayIterator::finishCreation):
1875         (JSC::JSArrayIterator::visitChildren): Deleted.
1876         (JSC::createIteratorResult): Deleted.
1877         (JSC::arrayIteratorNext): Deleted.
1878         (JSC::arrayIteratorNextKey): Deleted.
1879         (JSC::arrayIteratorNextValue): Deleted.
1880         (JSC::arrayIteratorNextGeneric): Deleted.
1881         * runtime/JSArrayIterator.h:
1882         (JSC::JSArrayIterator::JSArrayIterator):
1883         (JSC::JSArrayIterator::iterationKind): Deleted.
1884         (JSC::JSArrayIterator::iteratedObject): Deleted.
1885         (JSC::JSArrayIterator::nextIndex): Deleted.
1886         (JSC::JSArrayIterator::setNextIndex): Deleted.
1887         (JSC::JSArrayIterator::finish): Deleted.
1888         (JSC::JSArrayIterator::offsetOfIterationKind): Deleted.
1889         (JSC::JSArrayIterator::offsetOfIteratedObject): Deleted.
1890         (JSC::JSArrayIterator::offsetOfNextIndex): Deleted.
1891         * runtime/JSGlobalObject.cpp:
1892         (JSC::JSGlobalObject::init):
1893         * runtime/JSPromiseConstructor.cpp:
1894         (JSC::performPromiseRaceLoop):
1895         (JSC::JSPromiseConstructorFuncRace):
1896         (JSC::performPromiseAll):
1897         (JSC::JSPromiseConstructorFuncAll):
1898         * runtime/MapIteratorPrototype.cpp:
1899         (JSC::MapIteratorPrototype::finishCreation):
1900         (JSC::MapIteratorPrototypeFuncNext):
1901         * runtime/SetIteratorPrototype.cpp:
1902         (JSC::SetIteratorPrototype::finishCreation):
1903         (JSC::SetIteratorPrototypeFuncNext):
1904         * runtime/VM.cpp:
1905         (JSC::thunkGeneratorForIntrinsic):
1906         * tests/stress/array-iterators-next-with-call.js: Added.
1907         (increment):
1908         (for):
1909         * tests/stress/array-iterators-next.js: Added.
1910
1911         Revive the older Array iterator tests that manually call 'next' method.
1912
1913         * tests/stress/custom-iterators.js: Added.
1914         (iter.next):
1915         (iter.Symbol.iterator):
1916         (iter.return):
1917         (iter.get next):
1918         (iter.get return):
1919         (iteratorInterfaceErrorTest.iter.next):
1920         (iteratorInterfaceErrorTest.iter.Symbol.iterator):
1921         (iteratorInterfaceErrorTest.iter.return):
1922         (iteratorInterfaceErrorTest):
1923         (iteratorInterfaceErrorTestReturn.iter.next):
1924         (iteratorInterfaceErrorTestReturn.iter.Symbol.iterator):
1925         (iteratorInterfaceErrorTestReturn.iter.return):
1926         (iteratorInterfaceErrorTestReturn):
1927         (iteratorInterfaceBreakTestReturn.iter.next):
1928         (iteratorInterfaceBreakTestReturn.iter.Symbol.iterator):
1929         (iteratorInterfaceBreakTestReturn.iter.return):
1930         (iteratorInterfaceBreakTestReturn):
1931
1932         This tests the behavior of custom iterators.
1933         'next' and 'return' of iterator work with for-of.
1934
1935         * tests/stress/iterators-shape.js: Added.
1936         (iteratorShape):
1937         (sameNextMethods):
1938         (set var):
1939
1940         This tests the shape of iterators; iterators of Array have 'next' method in %ArrayIteratorPrototype%.
1941
1942         * tests/stress/map-iterators-next.js: Added.
1943         (set var):
1944         (.get if):
1945         (otherKey):
1946         * tests/stress/set-iterators-next.js: Added.
1947         (otherKey):
1948
1949 2015-03-04  Yusuke Suzuki  <utatane.tea@gmail.com>
1950
1951         Hide Promise with runtime flags under Cocoa JSContext API
1952         https://bugs.webkit.org/show_bug.cgi?id=141965
1953
1954         Reviewed by Filip Pizlo.
1955
1956         Since there's no run loop in JavaScriptCore APIs, Promises don't work currently.
1957         So until they work, we hide Promise from a global object.
1958         Introduce new JSC runtime flag, PromiseDisabled. When `isPromiseDisabled` is true,
1959         Promise constructor is not attached to JSGlobalObject.
1960
1961         To make 0 as default runtime flags, we choose PromiseDisabled flag
1962         instead of PromiseEnabled flag. So by default, Promise is enabled.
1963
1964         * API/JSCallbackObjectFunctions.h:
1965         (JSC::JSCallbackObject<Parent>::JSCallbackObject):
1966         * API/JSContextRef.cpp:
1967         (javaScriptRuntimeFlags):
1968         (JSGlobalContextCreateInGroup):
1969         * API/tests/testapi.c:
1970         (main):
1971         * API/tests/testapi.mm:
1972         (testObjectiveCAPI):
1973         * runtime/JSGlobalObject.cpp:
1974         (JSC::JSGlobalObject::init):
1975         * runtime/JSGlobalObject.h:
1976         (JSC::JSGlobalObject::create):
1977         * runtime/RuntimeFlags.h:
1978         (JSC::RuntimeFlags::createAllEnabled):
1979
1980 2015-03-04  Joseph Pecoraro  <pecoraro@apple.com>
1981
1982         Web Inspector: Array/Collection Sizes should be visible and distinct
1983         https://bugs.webkit.org/show_bug.cgi?id=142254
1984
1985         Reviewed by Timothy Hatcher.
1986
1987         * runtime/WeakMapData.h:
1988         (JSC::WeakMapData::size):
1989         * inspector/JSInjectedScriptHost.cpp:
1990         (Inspector::JSInjectedScriptHost::weakMapSize):
1991         * inspector/JSInjectedScriptHost.h:
1992         * inspector/JSInjectedScriptHostPrototype.cpp:
1993         (Inspector::JSInjectedScriptHostPrototype::finishCreation):
1994         (Inspector::jsInjectedScriptHostPrototypeFunctionWeakMapSize):
1995         Add a way to get a WeakMap's size.
1996
1997         * inspector/protocol/Runtime.json:
1998         Include size in RemoteObject and ObjectPreview.
1999
2000         * inspector/InjectedScriptSource.js:
2001         Set the size of RemoteObjects and previews if they
2002         are array/collection types.
2003
2004 2015-03-04  Andreas Kling  <akling@apple.com>
2005
2006         GC should compute stack bounds and dump registers at the earliest opportunity.
2007         <https://webkit.org/b/142310>
2008         <rdar://problem/20045624>
2009
2010         Reviewed by Geoffrey Garen.
2011
2012         Make Heap::collect() a wrapper function around a collectImpl() where the work is actually done.
2013         The wrapper function that grabs a snapshot of the current stack boundaries and register values
2014         on entry, and sanitizes the stack on exit.
2015
2016         This is a speculative fix for what appears to be overly conservative behavior in the garbage
2017         collector following r178364 which caused a measurable regression in memory usage on Membuster.
2018         The theory being that we were putting pointers to dead things on the stack before scanning it,
2019         and by doing that ended up marking things that we'd otherwise discover to be garbage.
2020
2021         * heap/Heap.cpp:
2022         (JSC::Heap::markRoots):
2023         (JSC::Heap::gatherStackRoots):
2024         (JSC::Heap::collect):
2025         (JSC::Heap::collectImpl):
2026         * heap/Heap.h:
2027         * heap/MachineStackMarker.cpp:
2028         (JSC::MachineThreads::gatherFromCurrentThread):
2029         (JSC::MachineThreads::gatherConservativeRoots):
2030         * heap/MachineStackMarker.h:
2031
2032 2015-03-04  Debarshi Ray  <debarshir@gnome.org>
2033
2034         Silence GCC's -Wstrict-prototypes
2035         https://bugs.webkit.org/show_bug.cgi?id=142278
2036
2037         Reviewed by Alexey Proskuryakov.
2038
2039         * API/JSContextRef.h:
2040
2041 2015-03-04  Benjamin Poulain  <bpoulain@apple.com>
2042
2043         [JSC] Add a node for Math.log()
2044         https://bugs.webkit.org/show_bug.cgi?id=142126
2045
2046         Reviewed by Geoffrey Garen.
2047
2048         This patch adds the DFG node ArithLog for LogIntrinsic.
2049
2050         Having a direct call to log has very little value by itself, the implementation
2051         in DFG and FTL is a simple function call.
2052
2053         What is useful in ArithLog is that we know the operation is pure.
2054         This allow us to hoist it out of loops when the argument is independent
2055         is an invariant of the loop.
2056
2057         Perf wise, this patch gives:
2058         -Kraken's imaging-darkroom: definitely 1.2372x faster.
2059         -AsmBench's Towers.c: definitely 1.0261x faster.
2060
2061         * dfg/DFGAbstractInterpreterInlines.h:
2062         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2063         * dfg/DFGByteCodeParser.cpp:
2064         (JSC::DFG::ByteCodeParser::handleIntrinsic):
2065         * dfg/DFGClobberize.h:
2066         (JSC::DFG::clobberize):
2067         * dfg/DFGDoesGC.cpp:
2068         (JSC::DFG::doesGC):
2069         * dfg/DFGFixupPhase.cpp:
2070         (JSC::DFG::FixupPhase::fixupNode):
2071         * dfg/DFGNodeType.h:
2072         * dfg/DFGPredictionPropagationPhase.cpp:
2073         (JSC::DFG::PredictionPropagationPhase::propagate):
2074         (JSC::DFG::PredictionPropagationPhase::doDoubleVoting):
2075         * dfg/DFGSafeToExecute.h:
2076         (JSC::DFG::safeToExecute):
2077         * dfg/DFGSpeculativeJIT.cpp:
2078         (JSC::DFG::SpeculativeJIT::compileArithLog):
2079         * dfg/DFGSpeculativeJIT.h:
2080         * dfg/DFGSpeculativeJIT32_64.cpp:
2081         (JSC::DFG::SpeculativeJIT::compile):
2082         * dfg/DFGSpeculativeJIT64.cpp:
2083         (JSC::DFG::SpeculativeJIT::compile):
2084         * ftl/FTLCapabilities.cpp:
2085         (JSC::FTL::canCompile):
2086         * ftl/FTLIntrinsicRepository.h:
2087         * ftl/FTLLowerDFGToLLVM.cpp:
2088         (JSC::FTL::LowerDFGToLLVM::compileNode):
2089         (JSC::FTL::LowerDFGToLLVM::compileArithLog):
2090         * ftl/FTLOutput.h:
2091         (JSC::FTL::Output::doubleLog):
2092         * tests/stress/math-log-basics.js: Added.
2093         * tests/stress/math-log-with-constants.js: Added.
2094
2095 2015-03-04  Filip Pizlo  <fpizlo@apple.com>
2096
2097         Only Heap should be in charge of deciding how to select a subspace for a type
2098         https://bugs.webkit.org/show_bug.cgi?id=142304
2099
2100         Reviewed by Mark Lam.
2101         
2102         This slightly reduces the code duplication for selecting subspace based on type, and what
2103         duplication is left is at least localized in HeapInlines.h. The immediate effect is that
2104         the DFG and FTL don't have to duplicate this pattern.
2105
2106         * dfg/DFGSpeculativeJIT.h:
2107         (JSC::DFG::SpeculativeJIT::emitAllocateJSObject):
2108         (JSC::DFG::SpeculativeJIT::emitAllocateVariableSizedJSObject):
2109         * ftl/FTLLowerDFGToLLVM.cpp:
2110         (JSC::FTL::LowerDFGToLLVM::allocateObject):
2111         * heap/Heap.h:
2112         * heap/HeapInlines.h:
2113         (JSC::Heap::allocateObjectOfType):
2114         (JSC::Heap::subspaceForObjectOfType):
2115         (JSC::Heap::allocatorForObjectOfType):
2116         * runtime/JSCellInlines.h:
2117         (JSC::allocateCell):
2118
2119 2015-03-04  Andreas Kling  <akling@apple.com>
2120
2121         Stale entries in WeakGCMaps are keeping tons of WeakBlocks alive unnecessarily.
2122         <https://webkit.org/b/142115>
2123         <rdar://problem/19992268>
2124
2125         Reviewed by Geoffrey Garen.
2126
2127         Prune stale entries from WeakGCMaps as part of every full garbage collection.
2128         This frees up tons of previously-stuck WeakBlocks that were only sitting around
2129         with finalized handles waiting to die.
2130
2131         Note that WeakGCMaps register/unregister themselves with the GC heap in their
2132         ctor/dtor, so creating one now requires passing the VM.
2133
2134         Average time spent in the PruningStaleEntriesFromWeakGCMaps GC phase appears
2135         to be between 0.01ms and 0.3ms, though I've seen a few longer ones at ~1.2ms.
2136         It seems somewhat excessive to do this on every Eden collection, so it's only
2137         doing work in full collections for now.
2138
2139         * API/JSWeakObjectMapRefInternal.h:
2140         (OpaqueJSWeakObjectMap::create):
2141         (OpaqueJSWeakObjectMap::OpaqueJSWeakObjectMap):
2142         * API/JSWeakObjectMapRefPrivate.cpp:
2143         * API/JSWrapperMap.mm:
2144         (-[JSWrapperMap initWithContext:]):
2145         (-[JSWrapperMap jsWrapperForObject:]): Pass VM to WeakGCMap constructor.
2146
2147         * JavaScriptCore.xcodeproj/project.pbxproj: Add WeakGCMapInlines.h and make
2148         it project-private so WebCore clients can access it.
2149
2150         * heap/Heap.cpp:
2151         (JSC::Heap::collect):
2152         (JSC::Heap::pruneStaleEntriesFromWeakGCMaps): Added a new GC phase for pruning
2153         stale entries from WeakGCMaps. This is only executed during full collections.
2154
2155         * heap/Heap.h:
2156         * heap/HeapInlines.h:
2157         (JSC::Heap::registerWeakGCMap):
2158         (JSC::Heap::unregisterWeakGCMap): Added a mechanism for WeakGCMaps to register
2159         themselves with the Heap and provide a pruning callback.
2160
2161         * runtime/PrototypeMap.h:
2162         (JSC::PrototypeMap::PrototypeMap):
2163         * runtime/Structure.cpp:
2164         (JSC::StructureTransitionTable::add): Pass VM to WeakGCMap constructor.
2165
2166         * runtime/JSCInlines.h: Add "WeakGCMapInlines.h"
2167
2168         * runtime/JSGlobalObject.cpp: Include "WeakGCMapInlines.h" so this builds.
2169
2170         * runtime/VM.cpp:
2171         (JSC::VM::VM): Pass VM to WeakGCMap constructor.
2172
2173         * runtime/WeakGCMap.h:
2174         (JSC::WeakGCMap::set):
2175         (JSC::WeakGCMap::add):
2176         (JSC::WeakGCMap::WeakGCMap): Deleted.
2177         (JSC::WeakGCMap::gcMap): Deleted.
2178         (JSC::WeakGCMap::gcMapIfNeeded): Deleted.
2179         * runtime/WeakGCMapInlines.h: Added.
2180         (JSC::WeakGCMap::WeakGCMap):
2181         (JSC::WeakGCMap::~WeakGCMap):
2182         (JSC::WeakGCMap::pruneStaleEntries): Moved ctor, dtor and pruning callback
2183         to WeakGCMapInlines.h to fix interdependent header issues. Removed code that
2184         prunes WeakGCMap at certain growth milestones and instead rely on the GC
2185         callback for housekeeping.
2186
2187 2015-03-03  Filip Pizlo  <fpizlo@apple.com>
2188
2189         DFG IR should refer to FunctionExecutables directly and not via the CodeBlock
2190         https://bugs.webkit.org/show_bug.cgi?id=142229
2191
2192         Reviewed by Mark Lam and Benjamin Poulain.
2193         
2194         Anytime a DFG IR node refers to something in CodeBlock, it has three effects:
2195
2196         - Cumbersome API for accessing the thing that the node refers to.
2197         
2198         - Not obvious how to create a new such node after bytecode parsing, especially if the
2199           thing it refers to isn't already in the CodeBlock. We have done this in the past, but
2200           it usually involves subtle changes to CodeBlock.
2201         
2202         - Not obvious how to inline code that ends up using such nodes. Again, when we have done
2203           this, it involved subtle changes to CodeBlock.
2204         
2205         Prior to this change, the NewFunction* node types used an index into tables in CodeBlock.
2206         For this reason, those operations were not inlineable. But the functin tables in CodeBlock
2207         just point to FunctionExecutables, which are cells; this means that we can just abstract
2208         these operands in DFG IR as cellOperands. cellOperands use DFG::FrozenValue, which means
2209         that GC registration happens automagically. Even better, our dumping for cellOperand
2210         already did FunctionExecutable dumping - so that functionality gets to be deduplicated.
2211         
2212         Because this change increases the number of users of cellOperand, it also adds some
2213         convenience methods for using it. For example, whereas before you'd say things like:
2214         
2215             jsCast<Foo*>(node->cellOperand()->value())
2216         
2217         you can now just say:
2218         
2219             node->castOperand<Foo*>()
2220         
2221         This change also changes existing cellOperand users to use the new conveniance API when
2222         applicable.
2223
2224         * bytecode/CodeBlock.cpp:
2225         (JSC::CodeBlock::jettisonFunctionDeclsAndExprs):
2226         * bytecode/CodeBlock.h:
2227         * dfg/DFGByteCodeParser.cpp:
2228         (JSC::DFG::ByteCodeParser::parseBlock):
2229         * dfg/DFGCapabilities.cpp:
2230         (JSC::DFG::capabilityLevel):
2231         * dfg/DFGFrozenValue.h:
2232         (JSC::DFG::FrozenValue::cell):
2233         (JSC::DFG::FrozenValue::dynamicCast):
2234         (JSC::DFG::FrozenValue::cast):
2235         * dfg/DFGGraph.cpp:
2236         (JSC::DFG::Graph::dump):
2237         (JSC::DFG::Graph::registerFrozenValues):
2238         * dfg/DFGNode.h:
2239         (JSC::DFG::Node::hasCellOperand):
2240         (JSC::DFG::Node::castOperand):
2241         (JSC::DFG::Node::hasFunctionDeclIndex): Deleted.
2242         (JSC::DFG::Node::functionDeclIndex): Deleted.
2243         (JSC::DFG::Node::hasFunctionExprIndex): Deleted.
2244         (JSC::DFG::Node::functionExprIndex): Deleted.
2245         * dfg/DFGSpeculativeJIT.cpp:
2246         (JSC::DFG::SpeculativeJIT::compileNewFunctionNoCheck):
2247         (JSC::DFG::SpeculativeJIT::compileNewFunctionExpression):
2248         * dfg/DFGSpeculativeJIT32_64.cpp:
2249         (JSC::DFG::SpeculativeJIT::compile):
2250         * dfg/DFGSpeculativeJIT64.cpp:
2251         (JSC::DFG::SpeculativeJIT::compile):
2252         * dfg/DFGWatchpointCollectionPhase.cpp:
2253         (JSC::DFG::WatchpointCollectionPhase::handle):
2254         * ftl/FTLLowerDFGToLLVM.cpp:
2255         (JSC::FTL::LowerDFGToLLVM::compileCheckCell):
2256         (JSC::FTL::LowerDFGToLLVM::compileNativeCallOrConstruct):
2257
2258 2015-03-03  Michael Saboff  <msaboff@apple.com>
2259
2260         DelayedReleaseScope drops locks during GC which can cause a thread switch and code reentry
2261         https://bugs.webkit.org/show_bug.cgi?id=141275
2262
2263         Reviewed by Geoffrey Garen.
2264
2265         The original issue is that the CodeCache uses an unsafe method to add new UnlinkedCodeBlocks.
2266         It basically adds a null UnlinkedCodeBlock if there isn't a cached entry and then later
2267         updates the null entry to the result of the compilation.  If during that compilation and
2268         related processing we need to garbage collect, the DelayedReleaseScope would drop locks
2269         possibly allowing another thread to try to get the same source out of the CodeCache.
2270         This second thread would find the null entry and crash.  The fix is to move the processing of
2271         DelayedReleaseScope to when we drop locks and not drop locks during GC.  That was done in
2272         the original patch with the new function releaseDelayedReleasedObjects().
2273
2274         Updated releaseDelayedReleasedObjects() so that objects are released with all locks
2275         dropped.  Now its processing follows these steps
2276             Increment recursion counter and do recursion check and exit if recursing
2277             While there are objects to release
2278                 ASSERT that lock is held by current thread
2279                 Take all items from delayed release Vector and put into temporary Vector
2280                 Release API lock
2281                 Release and clear items from temporary vector
2282                 Reaquire API lock
2283         This meets the requirement that we release while the API lock is released and it is
2284         safer processing of the delayed release Vector.
2285
2286         Added new regression test to testapi.
2287
2288         Also added comment describing how recursion into releaseDelayedReleasedObjects() is
2289         prevented.
2290
2291         * API/tests/Regress141275.h: Added.
2292         * API/tests/Regress141275.mm: Added.
2293         (+[JSTEvaluatorTask evaluatorTaskWithEvaluateBlock:completionHandler:]):
2294         (-[JSTEvaluator init]):
2295         (-[JSTEvaluator initWithScript:]):
2296         (-[JSTEvaluator _accessPendingTasksWithBlock:]):
2297         (-[JSTEvaluator insertSignPostWithCompletion:]):
2298         (-[JSTEvaluator evaluateScript:completion:]):
2299         (-[JSTEvaluator evaluateBlock:completion:]):
2300         (-[JSTEvaluator waitForTasksDoneAndReportResults]):
2301         (__JSTRunLoopSourceScheduleCallBack):
2302         (__JSTRunLoopSourcePerformCallBack):
2303         (__JSTRunLoopSourceCancelCallBack):
2304         (-[JSTEvaluator _jsThreadMain]):
2305         (-[JSTEvaluator _sourceScheduledOnRunLoop:]):
2306         (-[JSTEvaluator _setupEvaluatorThreadContextIfNeeded]):
2307         (-[JSTEvaluator _callCompletionHandler:ifNeededWithError:]):
2308         (-[JSTEvaluator _sourcePerform]):
2309         (-[JSTEvaluator _sourceCanceledOnRunLoop:]):
2310         (runRegress141275):
2311         * API/tests/testapi.mm:
2312         (testObjectiveCAPI):
2313         * JavaScriptCore.xcodeproj/project.pbxproj:
2314         * heap/Heap.cpp:
2315         (JSC::Heap::releaseDelayedReleasedObjects):
2316         * runtime/JSLock.cpp:
2317         (JSC::JSLock::unlock):
2318
2319 2015-03-03  Filip Pizlo  <fpizlo@apple.com>
2320
2321         DFG should constant fold GetScope, and accesses to the scope register in the ByteCodeParser should not pretend that it's a constant as that breaks OSR exit liveness tracking
2322         https://bugs.webkit.org/show_bug.cgi?id=106202
2323
2324         Rubber stamped by Benjamin Poulain.
2325         
2326         This fixes a bug discovered by working on https://bugs.webkit.org/show_bug.cgi?id=142229,
2327         which was in turn discovered by working on https://bugs.webkit.org/show_bug.cgi?id=141174.
2328         Our way of dealing with scopes known to be constant is very sketchy, and only really works
2329         when a function is inlined. When it is, we pretend that every load of the scopeRegister sees
2330         a constant. But this breaks the DFG's tracking of the liveness of the scopeRegister. The way
2331         this worked made us miss oppportunities for optimizing based on a constant scope, and it also
2332         meant that in some cases - particularly like when we inline code that uses NewFuction and
2333         friends, as I do in bug 142229 - it makes OSR exit think that the scope is dead even though
2334         it's most definitely alive and it's a constant.
2335         
2336         The problem here is that we were doing too many optimizations in the ByteCodeParser, and not
2337         later. Later optimization phases know how to preserve OSR exit liveness. They're actually
2338         really good at it. Also, later phases know how to infer that any variable is a constant no
2339         matter how that constant arose - rather than the inlining-specific thing in ByteCodeParser.
2340         
2341         This changes the ByteCodeParser to largely avoid doing constant folding on the scope, except
2342         making the GetScope operation itself a constant. This is a compilation-time hack for small
2343         functions, and it doesn't break the loads of local variables - so OSR exit liveness still
2344         sees that the scopeRegister is in use. This then adds a vastly more powerful GetScope and
2345         GetClosureVar constant folder in the AbstractInterpreter. This handles most general cases
2346         including those that arise in complex control flow. This will catch cases where the scope
2347         is constant for any number of reasons. Basically anytime that the callee is inferred constant
2348         this will give us a constant scope. Also, we still have the parse-time constant folding of
2349         ResolveScope based on the reentry watchpoint, which luckily did the right thing with respect
2350         to OSR exit liveness (it splats a Phantom on its inputs, and it produces a constant result
2351         which is then set() normally).
2352         
2353         This appears to be a broad speed-up, albeit a small one. But mainly it unblocks bug 142229,
2354         which then should unblock bug 141174.
2355
2356         * dfg/DFGAbstractInterpreterInlines.h:
2357         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
2358         * dfg/DFGByteCodeParser.cpp:
2359         (JSC::DFG::ByteCodeParser::get):
2360         (JSC::DFG::ByteCodeParser::getLocal):
2361         (JSC::DFG::ByteCodeParser::parseBlock):
2362         (JSC::DFG::ByteCodeParser::parse):
2363         * dfg/DFGClobberize.h:
2364         (JSC::DFG::clobberize):
2365         * dfg/DFGDoesGC.cpp:
2366         (JSC::DFG::doesGC):
2367         * dfg/DFGFixupPhase.cpp:
2368         (JSC::DFG::FixupPhase::fixupNode):
2369         * dfg/DFGGraph.cpp:
2370         (JSC::DFG::Graph::tryGetConstantClosureVar):
2371         (JSC::DFG::Graph::tryGetRegisters):
2372         (JSC::DFG::Graph::tryGetActivation): Deleted.
2373         * dfg/DFGGraph.h:
2374         * dfg/DFGNode.h:
2375         (JSC::DFG::Node::hasVariableWatchpointSet):
2376         (JSC::DFG::Node::hasSymbolTable): Deleted.
2377         (JSC::DFG::Node::symbolTable): Deleted.
2378         * dfg/DFGNodeType.h:
2379         * dfg/DFGPredictionPropagationPhase.cpp:
2380         (JSC::DFG::PredictionPropagationPhase::propagate):
2381         * dfg/DFGSafeToExecute.h:
2382         (JSC::DFG::safeToExecute):
2383         * dfg/DFGSpeculativeJIT32_64.cpp:
2384         (JSC::DFG::SpeculativeJIT::compile):
2385         * dfg/DFGSpeculativeJIT64.cpp:
2386         (JSC::DFG::SpeculativeJIT::compile):
2387         * dfg/DFGWatchpointCollectionPhase.cpp:
2388         (JSC::DFG::WatchpointCollectionPhase::handle):
2389         * ftl/FTLCapabilities.cpp:
2390         (JSC::FTL::canCompile):
2391         * ftl/FTLLowerDFGToLLVM.cpp:
2392         (JSC::FTL::LowerDFGToLLVM::compileNode):
2393         (JSC::FTL::LowerDFGToLLVM::compileGetClosureVar):
2394         * runtime/SymbolTable.cpp:
2395         (JSC::SymbolTable::visitChildren):
2396         (JSC::SymbolTable::localToEntry):
2397         (JSC::SymbolTable::entryFor):
2398         * runtime/SymbolTable.h:
2399         (JSC::SymbolTable::add):
2400         (JSC::SymbolTable::set):
2401         * tests/stress/function-expression-exit.js: Added.
2402         * tests/stress/function-reentry-infer-on-self.js: Added.
2403         (thingy):
2404         * tests/stress/goofy-function-reentry-incorrect-inference.js: Added.
2405
2406 2015-03-03  Anders Carlsson  <andersca@apple.com>
2407
2408         Remove unused compression code
2409         https://bugs.webkit.org/show_bug.cgi?id=142237
2410
2411         Reviewed by Geoffrey Garen.
2412
2413         * bytecode/UnlinkedCodeBlock.h:
2414
2415 2015-03-03  Filip Pizlo  <fpizlo@apple.com>
2416
2417         JIT debugging features that selectively disable the JITs for code blocks need to stay out of the way of the critical path of JIT management
2418         https://bugs.webkit.org/show_bug.cgi?id=142234
2419
2420         Reviewed by Mark Lam and Benjamin Poulain.
2421         
2422         Long ago, we used to selectively disable compilation of CodeBlocks for debugging purposes by
2423         adding hacks to DFGDriver.cpp.  This was all well and good.  It used the existing
2424         CompilationFailed mode of the DFG driver to signal failure of CodeBlocks that we didn't want
2425         to compile.  That's great because CompilationFailed is a well-supported return value on the
2426         critical path, usually used for when we run out of JIT memory.
2427
2428         Later, this was moved into DFGCapabilities. This was basically incorrect. It introduced a bug
2429         where disabling compiling of a CodeBlock meant that we stopped inlining it as well.  So if
2430         you had a compiler bug that arose if foo was inlined into bar, and you bisected down to bar,
2431         then foo would no longer get inlined and you wouldn't see the bug.  That's busted.
2432
2433         So then we changed the code in DFGCapabilities to mark bar as CanCompile and foo as
2434         CanInline. Now, foo wouldn't get compiled alone but it would get inlined.
2435
2436         But then we removed CanCompile because that capability mode only existed for the purpose of
2437         our old varargs hacks.  After that removal, "CanInline" became CannotCompile.  This means
2438         that if you bisect down on bar in the "foo inlined into bar" case, you'll crash in the DFG
2439         because the baseline JIT wouldn't have known to insert profiling on foo.
2440
2441         We could fix this by bringing back CanInline.
2442
2443         But this is all a pile of nonsense.  The debug support to selectively disable compilation of
2444         some CodeBlocks shouldn't cross-cut our entire engine and should most certainly never involve
2445         adding new capability modes.  This support is a hack at best and is for use by JSC hackers
2446         only.  It should be as unintrusive as possible.
2447
2448         So, as in the ancient times, the only proper place to put this hack is in DFGDriver.cpp, and
2449         return CompilationFailed.  This is correct not just because it takes capability modes out of
2450         the picture (and obviates the need to introduce new ones), but also because it means that
2451         disabling compilation doesn't change the profiling mode of other CodeBlocks in the Baseline
2452         JIT.  Capability mode influences profiling mode which in turn influences code generation in
2453         the Baseline JIT, sometimes in very significant ways - like, we sometimes do additional
2454         double-to-int conversions in Baseline if we know that we might tier-up into the DFG, since
2455         this buys us more precise profiling.
2456         
2457         This change reduces the intrusiveness of debugging hacks by making them use the very simple
2458         CompilationFailed mechanism rather than trying to influence capability modes. Capability
2459         modes have very subtle effects on the whole engine, while CompilationFailed just makes the
2460         engine pretend like the DFG compilation will happen at timelike infinity. That makes these
2461         hacks much more likely to continue working as we make other changes to the system.
2462         
2463         This brings back the ability to bisect down onto a function bar when bar inlines foo. Prior
2464         to this change, we would crash in that case.
2465
2466         * dfg/DFGCapabilities.cpp:
2467         (JSC::DFG::isSupported):
2468         (JSC::DFG::mightCompileEval):
2469         (JSC::DFG::mightCompileProgram):
2470         (JSC::DFG::mightCompileFunctionForCall):
2471         (JSC::DFG::mightCompileFunctionForConstruct):
2472         * dfg/DFGCapabilities.h:
2473         * dfg/DFGDriver.cpp:
2474         (JSC::DFG::compileImpl):
2475
2476 2015-03-03  peavo@outlook.com  <peavo@outlook.com>
2477
2478         [Win64] JSC compile error.
2479         https://bugs.webkit.org/show_bug.cgi?id=142216
2480
2481         Reviewed by Mark Lam.
2482
2483         There is missing a version of setupArgumentsWithExecState when NUMBER_OF_ARGUMENT_REGISTERS == 4.
2484
2485         * jit/CCallHelpers.h:
2486         (JSC::CCallHelpers::setupArgumentsWithExecState):
2487
2488 2015-03-02  Filip Pizlo  <fpizlo@apple.com>
2489
2490         DFG compile time measurements should really report milliseconds
2491         https://bugs.webkit.org/show_bug.cgi?id=142209
2492
2493         Reviewed by Benjamin Poulain.
2494         
2495         Fix this to record milliseconds instead of seconds.
2496
2497         * dfg/DFGPlan.cpp:
2498         (JSC::DFG::Plan::compileInThread):
2499         (JSC::DFG::Plan::compileInThreadImpl):
2500
2501 2015-03-02  Filip Pizlo  <fpizlo@apple.com>
2502
2503         Remove op_get_callee, it's unused
2504         https://bugs.webkit.org/show_bug.cgi?id=142206
2505
2506         Reviewed by Andreas Kling.
2507         
2508         It's a bit of a shame that we stopped using this opcode since it gives us same-callee
2509         profiling. But, if we were to add this functionality back in, we would almost certainly do
2510         it by adding a JSFunction allocation watchpoint on FunctionExecutable.
2511
2512         * bytecode/BytecodeList.json:
2513         * bytecode/BytecodeUseDef.h:
2514         (JSC::computeUsesForBytecodeOffset):
2515         (JSC::computeDefsForBytecodeOffset):
2516         * bytecode/CodeBlock.cpp:
2517         (JSC::CodeBlock::dumpBytecode):
2518         (JSC::CodeBlock::finalizeUnconditionally):
2519         * dfg/DFGByteCodeParser.cpp:
2520         (JSC::DFG::ByteCodeParser::parseBlock):
2521         * dfg/DFGCapabilities.cpp:
2522         (JSC::DFG::capabilityLevel):
2523         * jit/JIT.cpp:
2524         (JSC::JIT::privateCompileMainPass):
2525         (JSC::JIT::privateCompileSlowCases):
2526         * jit/JIT.h:
2527         * jit/JITOpcodes.cpp:
2528         (JSC::JIT::emit_op_get_callee): Deleted.
2529         (JSC::JIT::emitSlow_op_get_callee): Deleted.
2530         * jit/JITOpcodes32_64.cpp:
2531         (JSC::JIT::emit_op_get_callee): Deleted.
2532         (JSC::JIT::emitSlow_op_get_callee): Deleted.
2533         * llint/LowLevelInterpreter32_64.asm:
2534         * llint/LowLevelInterpreter64.asm:
2535         * runtime/CommonSlowPaths.cpp:
2536         (JSC::SLOW_PATH_DECL): Deleted.
2537
2538 2015-03-02  Joseph Pecoraro  <pecoraro@apple.com>
2539
2540         Web Inspector: Context Menu to Log a Particular Object
2541         https://bugs.webkit.org/show_bug.cgi?id=142198
2542
2543         Reviewed by Timothy Hatcher.
2544
2545         Add a protocol method to assign a $n index to a value. For an object
2546         use the injected script context for that object. For a value, use
2547         the execution context to know where to save the value.
2548
2549         * inspector/InjectedScript.cpp:
2550         (Inspector::InjectedScript::saveResult):
2551         * inspector/InjectedScript.h:
2552         * inspector/InjectedScriptSource.js:
2553         * inspector/agents/InspectorRuntimeAgent.cpp:
2554         (Inspector::InspectorRuntimeAgent::saveResult):
2555         * inspector/agents/InspectorRuntimeAgent.h:
2556         * inspector/protocol/Debugger.json:
2557         * inspector/protocol/Runtime.json:
2558
2559 2015-03-02  Filip Pizlo  <fpizlo@apple.com>
2560
2561         SpeculativeJIT::emitAllocateArguments() should be a bit faster, and shouldn't do destructor initialization
2562         https://bugs.webkit.org/show_bug.cgi?id=142197
2563
2564         Reviewed by Geoffrey Garen.
2565
2566         * dfg/DFGSpeculativeJIT.cpp:
2567         (JSC::DFG::SpeculativeJIT::emitAllocateArguments): Use shift instead of mul, since mul doesn't automatically strength-reduce to shift. Also pass the structure as a TrustedImmPtr.
2568         * dfg/DFGSpeculativeJIT.h:
2569         (JSC::DFG::SpeculativeJIT::emitAllocateVariableSizedJSObject): Rationalize this a bit. The other emitAllocate... methods take a templated structure so that it can be either a TrustedImmPtr or a register. Also don't do destructor initialization, since its one client doesn't need it, and it's actually probably wrong.
2570
2571 2015-03-02  Mark Lam  <mark.lam@apple.com>
2572
2573         Exception stack unwinding in JSC hangs while the Timeline Profiler is enabled.
2574         <https://webkit.org/b/142191>
2575
2576         Reviewed by Geoffrey Garen.
2577
2578         Imagine a scenario where the Inspector is paused / suspended at a breakpoint or
2579         while the user is stepping through JS code. The user then tries to evaluate an
2580         expression in the console, and that evaluation results in an exception being
2581         thrown. Currently, if the Timeline Profiler is enabled while this exception is
2582         being thrown, the WebProcess will hang while trying to handle that exception.
2583
2584         The issue is that the Timeline Profiler's ProfileGenerator::didExecute() will
2585         return early and decline to process ProfileNodes if the Inspector is paused.
2586         This is proper because it does not want to count work done for injected scripts
2587         (e.g. from the console) towards the timeline profile of the webpage being run.
2588         However, this is in conflict with ProfileGenerator::exceptionUnwind()'s
2589         expectation that didExecute() will process ProfileNodes in order to do the stack
2590         unwinding for the exception handling. As a result,
2591         ProfileGenerator::exceptionUnwind() hangs.
2592
2593         ProfileGenerator::exceptionUnwind() is in error. While the Inspector is paused,
2594         there will not be any ProfileNodes that it needs to "unwind". Hence, the fix is
2595         simply to return early also in ProfileGenerator::exceptionUnwind() if the
2596         Inspector is paused.
2597
2598         * profiler/ProfileGenerator.cpp:
2599         (JSC::ProfileGenerator::exceptionUnwind):
2600
2601 2015-03-02  Filip Pizlo  <fpizlo@apple.com>
2602
2603         FTL should correctly document where it puts the argument count for inlined varargs frames
2604         https://bugs.webkit.org/show_bug.cgi?id=142187
2605
2606         Reviewed by Geoffrey Garn.
2607         
2608         After LLVM tells us where the captured variables alloca landed in the frame, we need to
2609         tell all of our meta-data about it. We were forgetting to do so for the argument count
2610         register, which is used by inlined varargs calls.
2611
2612         * ftl/FTLCompile.cpp:
2613         (JSC::FTL::mmAllocateDataSection):
2614         * tests/stress/inline-varargs-get-arguments.js: Added.
2615         (foo):
2616         (bar):
2617         (baz):
2618
2619 2015-03-02  Filip Pizlo  <fpizlo@apple.com>
2620
2621         Deduplicate slow path calling code in JITOpcodes.cpp/JITOpcodes32_64.cpp
2622         https://bugs.webkit.org/show_bug.cgi?id=142184
2623
2624         Reviewed by Michael Saboff.
2625
2626         * jit/JITOpcodes.cpp:
2627         (JSC::JIT::emit_op_get_enumerable_length):
2628         (JSC::JIT::emitSlow_op_has_structure_property):
2629         (JSC::JIT::emit_op_has_generic_property):
2630         (JSC::JIT::emit_op_get_structure_property_enumerator):
2631         (JSC::JIT::emit_op_get_generic_property_enumerator):
2632         (JSC::JIT::emit_op_to_index_string):
2633         * jit/JITOpcodes32_64.cpp:
2634         (JSC::JIT::emit_op_get_enumerable_length): Deleted.
2635         (JSC::JIT::emitSlow_op_has_structure_property): Deleted.
2636         (JSC::JIT::emit_op_has_generic_property): Deleted.
2637         (JSC::JIT::emit_op_get_structure_property_enumerator): Deleted.
2638         (JSC::JIT::emit_op_get_generic_property_enumerator): Deleted.
2639         (JSC::JIT::emit_op_to_index_string): Deleted.
2640         (JSC::JIT::emit_op_profile_control_flow): Deleted.
2641
2642 2015-03-02  Antti Koivisto  <antti@apple.com>
2643
2644         Add way to dump cache meta data to file
2645         https://bugs.webkit.org/show_bug.cgi?id=142183
2646
2647         Reviewed by Andreas Kling.
2648
2649         Export appendQuotedJSONStringToBuilder.
2650
2651         * bytecompiler/NodesCodegen.cpp:
2652         (JSC::ObjectPatternNode::toString):
2653         * runtime/JSONObject.cpp:
2654         (JSC::appendQuotedJSONStringToBuilder):
2655         (JSC::Stringifier::appendQuotedString):
2656         (JSC::escapeStringToBuilder): Deleted.
2657         * runtime/JSONObject.h:
2658
2659 2015-03-02  Joseph Pecoraro  <pecoraro@apple.com>
2660
2661         Web Inspector: Add Context Menus to Object Tree properties
2662         https://bugs.webkit.org/show_bug.cgi?id=142125
2663
2664         Reviewed by Timothy Hatcher.
2665
2666         * inspector/JSInjectedScriptHost.cpp:
2667         (Inspector::JSInjectedScriptHost::functionDetails):
2668         Update to include columnNumber.
2669
2670 2015-03-01  Filip Pizlo  <fpizlo@apple.com>
2671
2672         BytecodeGenerator shouldn't emit op_resolve_scope as a roundabout way of returning the scopeRegister
2673         https://bugs.webkit.org/show_bug.cgi?id=142153
2674
2675         Reviewed by Michael Saboff.
2676         
2677         We don't need a op_resolve_scope if we know that it will simply return the scope register.
2678         This changes the BytecodeGenerator to use the scope register directly in those cases where
2679         we know statically that we would just have returned that from op_resolve_scope.
2680         
2681         This doesn't appear to have a significant impact on performance.
2682
2683         * bytecode/CodeBlock.cpp:
2684         (JSC::CodeBlock::CodeBlock):
2685         * bytecompiler/BytecodeGenerator.cpp:
2686         (JSC::BytecodeGenerator::emitResolveScope):
2687         (JSC::BytecodeGenerator::emitReturn):
2688         (JSC::BytecodeGenerator::emitGetOwnScope): Deleted.
2689         * bytecompiler/BytecodeGenerator.h:
2690         * bytecompiler/NodesCodegen.cpp:
2691         (JSC::ResolveNode::emitBytecode):
2692         (JSC::EvalFunctionCallNode::emitBytecode):
2693         (JSC::FunctionCallResolveNode::emitBytecode):
2694         (JSC::PostfixNode::emitResolve):
2695         (JSC::DeleteResolveNode::emitBytecode):
2696         (JSC::TypeOfResolveNode::emitBytecode):
2697         (JSC::PrefixNode::emitResolve):
2698         (JSC::ReadModifyResolveNode::emitBytecode):
2699         (JSC::AssignResolveNode::emitBytecode):
2700         (JSC::ConstDeclNode::emitCodeSingle):
2701         (JSC::EmptyVarExpression::emitBytecode):
2702         (JSC::ForInNode::emitLoopHeader):
2703         (JSC::ForOfNode::emitBytecode):
2704         (JSC::BindingNode::bindValue):
2705
2706 2015-02-27  Benjamin Poulain  <bpoulain@apple.com>
2707
2708         [JSC] Use the way number constants are written to help type speculation
2709         https://bugs.webkit.org/show_bug.cgi?id=142072
2710
2711         Reviewed by Filip Pizlo.
2712
2713         This patch changes how we interpret numeric constant based on how they appear
2714         in the source.
2715
2716         Constants that are integers but written with a decimal point now carry that information
2717         to the optimizating tiers. From there, we use that to be more aggressive about typing
2718         math operations toward double operations.
2719
2720         For example, in:
2721             var a = x + 1.0;
2722             var b = y + 1;
2723         The Add for a would be biased toward doubles, the Add for b would speculate
2724         integer as usual.
2725
2726
2727         The gains are tiny but this is a prerequisite to make my next patch useful:
2728         -SunSpider's access-fannkuch: definitely 1.0661x faster
2729         -SunSpider's math-cordic: definitely 1.0266x slower
2730             overal: might be 1.0066x slower.
2731         -Kraken's imaging-darkroom: definitely 1.0333x faster.
2732
2733         * parser/Lexer.cpp:
2734         (JSC::tokenTypeForIntegerLikeToken):
2735         (JSC::Lexer<T>::lex):
2736         The lexer now create two types of tokens for number: INTEGER and DOUBLE.
2737         Those token types only carry information about how the values were
2738         entered, an INTEGER does not have to be an integer, it is only written like one.
2739         Large integer still end up represented as double in memory.
2740
2741         One trap I fell into was typing numbers like 12e3 as double. This kind of literal
2742         is frequently used in integer-typed code, while 12.e3 would appear in double-typed
2743         code.
2744         Because of that, the only signals for double are: decimal point, negative zero,
2745         and ridiculously large values.
2746
2747         * parser/NodeConstructors.h:
2748         (JSC::DoubleNode::DoubleNode):
2749         (JSC::IntegerNode::IntegerNode):
2750         * parser/Nodes.h:
2751         (JSC::NumberNode::value):
2752         (JSC::NumberNode::setValue): Deleted.
2753         Number get specialized in two new kind of nodes in the AST: IntegerNode and DoubleNode.
2754
2755         * bytecompiler/NodesCodegen.cpp:
2756         (JSC::NumberNode::emitBytecode):
2757
2758         * parser/ASTBuilder.h:
2759         (JSC::ASTBuilder::createDoubleExpr):
2760         (JSC::ASTBuilder::createIntegerExpr):
2761         (JSC::ASTBuilder::createIntegerLikeNumber):
2762         (JSC::ASTBuilder::createDoubleLikeNumber):
2763         (JSC::ASTBuilder::createNumberFromBinaryOperation):
2764         (JSC::ASTBuilder::createNumberFromUnaryOperation):
2765         (JSC::ASTBuilder::makeNegateNode):
2766         (JSC::ASTBuilder::makeBitwiseNotNode):
2767         (JSC::ASTBuilder::makeMultNode):
2768         (JSC::ASTBuilder::makeDivNode):
2769         (JSC::ASTBuilder::makeModNode):
2770         (JSC::ASTBuilder::makeAddNode):
2771         (JSC::ASTBuilder::makeSubNode):
2772         (JSC::ASTBuilder::makeLeftShiftNode):
2773         (JSC::ASTBuilder::makeRightShiftNode):
2774         (JSC::ASTBuilder::makeURightShiftNode):
2775         (JSC::ASTBuilder::makeBitOrNode):
2776         (JSC::ASTBuilder::makeBitAndNode):
2777         (JSC::ASTBuilder::makeBitXOrNode):
2778         (JSC::ASTBuilder::createNumberExpr): Deleted.
2779         (JSC::ASTBuilder::createNumber): Deleted.
2780         The AST has some optimization to resolve constants before emitting bytecode.
2781         In the new code, the intger representation is kept if both operands where
2782         also represented as integers.
2783
2784         * parser/Parser.cpp:
2785         (JSC::Parser<LexerType>::parseDeconstructionPattern):
2786         (JSC::Parser<LexerType>::parseProperty):
2787         (JSC::Parser<LexerType>::parseGetterSetter):
2788         (JSC::Parser<LexerType>::parsePrimaryExpression):
2789         (JSC::Parser<LexerType>::printUnexpectedTokenText):
2790         * parser/ParserTokens.h:
2791         * parser/SyntaxChecker.h:
2792         (JSC::SyntaxChecker::createDoubleExpr):
2793         (JSC::SyntaxChecker::createIntegerExpr):
2794         (JSC::SyntaxChecker::createNumberExpr): Deleted.
2795
2796         * bytecode/CodeBlock.cpp:
2797         (JSC::CodeBlock::registerName):
2798         (JSC::CodeBlock::constantName):
2799         Change constantName(r, getConstant(r)) -> constantName(r) to simplify
2800         the dump code.
2801
2802         (JSC::CodeBlock::dumpBytecode):
2803         Dump thre soure representation information we have with each constant.
2804
2805         (JSC::CodeBlock::CodeBlock):
2806         (JSC::CodeBlock::shrinkToFit):
2807         (JSC::constantName): Deleted.
2808         * bytecode/CodeBlock.h:
2809         (JSC::CodeBlock::constantsSourceCodeRepresentation):
2810         (JSC::CodeBlock::addConstant):
2811         (JSC::CodeBlock::addConstantLazily):
2812         (JSC::CodeBlock::constantSourceCodeRepresentation):
2813         (JSC::CodeBlock::setConstantRegisters):
2814
2815         * bytecode/UnlinkedCodeBlock.h:
2816         (JSC::UnlinkedCodeBlock::addConstant):
2817         (JSC::UnlinkedCodeBlock::constantsSourceCodeRepresentation):
2818         (JSC::UnlinkedCodeBlock::shrinkToFit):
2819
2820         * bytecompiler/BytecodeGenerator.cpp:
2821         (JSC::BytecodeGenerator::addConstantValue):
2822         (JSC::BytecodeGenerator::emitLoad):
2823         * bytecompiler/BytecodeGenerator.h:
2824         We have to differentiate between constants that have the same values but are
2825         represented differently in the source. Values like 1.0 and 1 now end up
2826         as different constants.
2827
2828         * dfg/DFGByteCodeParser.cpp:
2829         (JSC::DFG::ByteCodeParser::get):
2830         (JSC::DFG::ByteCodeParser::addConstantToGraph):
2831         * dfg/DFGGraph.cpp:
2832         (JSC::DFG::Graph::registerFrozenValues):
2833         * dfg/DFGGraph.h:
2834         (JSC::DFG::Graph::addSpeculationMode):
2835         (JSC::DFG::Graph::addImmediateShouldSpeculateInt32):
2836         ArithAdd is very aggressive toward using Int52, which is quite useful
2837         in many benchmarks.
2838
2839         Here we need to specialize to make sure we don't force our literals
2840         to Int52 if there were represented as double.
2841
2842         There is one exception to that rule: when the other operand is guaranteed
2843         to come from a NodeResultInt32. This is because there is some weird code
2844         doing stuff like:
2845             var b = a|0;
2846             var c = b*2.0;
2847
2848         * dfg/DFGNode.h:
2849         (JSC::DFG::Node::Node):
2850         (JSC::DFG::Node::setOpAndDefaultFlags):
2851         (JSC::DFG::Node::sourceCodeRepresentation):
2852         * dfg/DFGPredictionPropagationPhase.cpp:
2853         (JSC::DFG::PredictionPropagationPhase::propagate):
2854         * runtime/JSCJSValue.h:
2855         (JSC::EncodedJSValueWithRepresentationHashTraits::emptyValue):
2856         (JSC::EncodedJSValueWithRepresentationHashTraits::constructDeletedValue):
2857         (JSC::EncodedJSValueWithRepresentationHashTraits::isDeletedValue):
2858         (JSC::EncodedJSValueWithRepresentationHash::hash):
2859         (JSC::EncodedJSValueWithRepresentationHash::equal):
2860         * tests/stress/arith-add-with-constants.js: Added.
2861         * tests/stress/arith-mul-with-constants.js: Added.
2862
2863 2015-02-26  Filip Pizlo  <fpizlo@apple.com>
2864
2865         Unreviewed, roll out r180723. It broke a bunch of tests.
2866
2867         * bytecompiler/BytecodeGenerator.cpp:
2868         (JSC::BytecodeGenerator::constLocal):
2869         * bytecompiler/BytecodeGenerator.h:
2870         * bytecompiler/NodesCodegen.cpp:
2871         (JSC::ConstDeclNode::emitCodeSingle):
2872         * tests/stress/const-arguments.js: Removed.
2873
2874 2015-02-26  Mark Lam  <mark.lam@apple.com>
2875
2876         Assertion fix for r180711: The bool returning form of BytecodeGenerator::addVar() can be removed.
2877         <https://webkit.org/b/142064>
2878
2879         Reviewed by Joseph Pecoraro.
2880
2881         * bytecompiler/BytecodeGenerator.cpp:
2882         (JSC::BytecodeGenerator::addVar):
2883
2884 2015-02-26  Mark Lam  <mark.lam@apple.com>
2885
2886         MachineThreads::Thread clean up has a use after free race condition.
2887         <https://webkit.org/b/141990>
2888
2889         Reviewed by Filip Pizlo.
2890
2891         MachineThreads::Thread clean up relies on the clean up mechanism
2892         implemented in _pthread_tsd_cleanup_key(), which looks like this:
2893
2894         void _pthread_tsd_cleanup_key(pthread_t self, pthread_key_t key)
2895         {
2896             void (*destructor)(void *);
2897             if (_pthread_key_get_destructor(key, &destructor)) {
2898                 void **ptr = &self->tsd[key];
2899                 void *value = *ptr;
2900
2901             // === Start of window for the bug to manifest =================
2902
2903                 // At this point, this thread has cached "destructor" and "value"
2904                 // (which is a MachineThreads*).  If the VM gets destructed (along
2905                 // with its MachineThreads registry) by another thread, then this
2906                 // thread will have no way of knowing that the MachineThreads* is
2907                 // now pointing to freed memory.  Calling the destructor below will
2908                 // therefore result in a use after free scenario when it tries to
2909                 // access the MachineThreads' data members.
2910
2911                 if (value) {
2912                     *ptr = NULL;
2913                     if (destructor) {
2914
2915             // === End of window for the bug to manifest ==================
2916
2917                         destructor(value);
2918                     }
2919                 }
2920             }
2921         }
2922
2923         The fix is to add each active MachineThreads to an ActiveMachineThreadsManager,
2924         and always check if the manager still contains that MachineThreads object
2925         before we call removeCurrentThread() on it.  When MachineThreads is destructed,
2926         it will remove itself from the manager.  The add, remove, and checking
2927         operations are all synchronized on the manager's lock, thereby ensuring that
2928         the MachineThreads object, if found in the manager, will remain alive for the
2929         duration of time we call removeCurrentThread() on it.
2930
2931         There's also possible for the MachineThreads object to already be destructed
2932         and another one happened to have been instantiated at the same address.
2933         Hence, we should only remove the exiting thread if it is found in the
2934         MachineThreads object.
2935
2936         There is no test for this issue because this bug requires a race condition
2937         between 2 threads where:
2938         1. Thread B, which had previously used the VM, exiting and
2939            getting to the bug window shown in _pthread_tsd_cleanup_key() above.
2940         2. Thread A destructing the VM (and its MachineThreads object)
2941            within that window of time before Thread B calls the destructor.
2942
2943         It is not possible to get a reliable test case without invasively
2944         instrumenting _pthread_tsd_cleanup_key() or MachineThreads::removeCurrentThread()
2945         to significantly increase that window of opportunity.
2946
2947         * heap/MachineStackMarker.cpp:
2948         (JSC::ActiveMachineThreadsManager::Locker::Locker):
2949         (JSC::ActiveMachineThreadsManager::add):
2950         (JSC::ActiveMachineThreadsManager::remove):
2951         (JSC::ActiveMachineThreadsManager::contains):
2952         (JSC::ActiveMachineThreadsManager::ActiveMachineThreadsManager):
2953         (JSC::activeMachineThreadsManager):
2954         (JSC::MachineThreads::MachineThreads):
2955         (JSC::MachineThreads::~MachineThreads):
2956         (JSC::MachineThreads::removeThread):
2957         (JSC::MachineThreads::removeThreadIfFound):
2958         (JSC::MachineThreads::removeCurrentThread): Deleted.
2959         * heap/MachineStackMarker.h:
2960
2961 2015-02-26  Joseph Pecoraro  <pecoraro@apple.com>
2962
2963         Web Inspector: Save Console Evaluations into Command Line variables $1-$99 ($n)
2964         https://bugs.webkit.org/show_bug.cgi?id=142061
2965
2966         Reviewed by Timothy Hatcher.
2967
2968         * inspector/protocol/Debugger.json:
2969         * inspector/protocol/Runtime.json:
2970         Input flag "saveResult" on whether we should try to save a result.
2971         Output int "savedResultIndex" to tell the frontend the saved state.
2972
2973         * inspector/InjectedScriptSource.js:
2974         Handle saving and clearing $1-$99 values.
2975         Include in BasicCommandLineAPI for JSContext inspection.
2976
2977         * inspector/InjectedScriptBase.cpp:
2978         (Inspector::InjectedScriptBase::makeEvalCall):
2979         * inspector/InjectedScriptBase.h:
2980         Allow an optional "savedResultIndex" out value on evals.
2981
2982         * inspector/InjectedScript.cpp:
2983         (Inspector::InjectedScript::evaluate):
2984         (Inspector::InjectedScript::evaluateOnCallFrame):
2985         * inspector/InjectedScript.h:
2986         * inspector/agents/InspectorDebuggerAgent.cpp:
2987         (Inspector::InspectorDebuggerAgent::evaluateOnCallFrame):
2988         * inspector/agents/InspectorDebuggerAgent.h:
2989         * inspector/agents/InspectorRuntimeAgent.cpp:
2990         (Inspector::InspectorRuntimeAgent::evaluate):
2991         * inspector/agents/InspectorRuntimeAgent.h:
2992         Plumbing for new in and out parameters.
2993
2994 2015-02-26  Filip Pizlo  <fpizlo@apple.com>
2995
2996         The bool returning form of BytecodeGenerator::addVar() can be removed
2997         https://bugs.webkit.org/show_bug.cgi?id=142064
2998
2999         Reviewed by Mark Lam.
3000         
3001         It's easier to implement addVar() when you don't have to return whether it's a new
3002         variable or not.
3003
3004         * bytecompiler/BytecodeGenerator.cpp:
3005         (JSC::BytecodeGenerator::addVar):
3006         * bytecompiler/BytecodeGenerator.h:
3007         (JSC::BytecodeGenerator::addVar): Deleted.
3008
3009 2015-02-26  Filip Pizlo  <fpizlo@apple.com>
3010
3011         Various array access corner cases should take OSR exit feedback
3012         https://bugs.webkit.org/show_bug.cgi?id=142056
3013
3014         Reviewed by Geoffrey Garen.
3015         
3016         Two major changes here:
3017         
3018         - Don't keep converting GetById into GetArrayLength if we exited due to any kind of array
3019           type check.
3020         
3021         - Use a generic form of GetByVal/PutByVal if we exited due to any kind of exotic checks,
3022           like the Arguments safety checks. We use the "ExoticObjectMode" for out-of-bounds on
3023           arguments for now, since it's a convenient way of forcing out-of-bounds to be handled by
3024           the Generic array mode.
3025
3026         * bytecode/ExitKind.cpp:
3027         (JSC::exitKindToString):
3028         * bytecode/ExitKind.h:
3029         * dfg/DFGArrayMode.cpp:
3030         (JSC::DFG::ArrayMode::refine):
3031         * dfg/DFGFixupPhase.cpp:
3032         (JSC::DFG::FixupPhase::fixupNode):
3033         * dfg/DFGSpeculativeJIT.cpp:
3034         (JSC::DFG::SpeculativeJIT::compileGetByValOnArguments):
3035         (JSC::DFG::SpeculativeJIT::compileGetArgumentsLength):
3036         * tests/stress/array-length-array-storage-plain-object.js: Added.
3037         (foo):
3038         * tests/stress/array-length-plain-object.js: Added.
3039         (foo):
3040
3041 2015-02-25  Filip Pizlo  <fpizlo@apple.com>
3042
3043         DFG SSA stack accesses shouldn't speak of VariableAccessDatas
3044         https://bugs.webkit.org/show_bug.cgi?id=142036
3045
3046         Reviewed by Michael Saboff.
3047         
3048         VariableAccessData is a useful thing in LoadStore and ThreadedCPS, but it's purely harmful in
3049         SSA because you can't cook up new VariableAccessDatas. So, if you know that you want to load
3050         or store to the stack, and you know what format to use as well as the location, then prior to
3051         this patch you couldn't do it unless you found some existing VariableAccessData that matched
3052         your requirements. That can be a hard task.
3053         
3054         It's better if SSA doesn't speak of VariableAccessDatas but instead just has stack accesses
3055         that speak of the things that a stack access needs: local, machineLocal, and format. This
3056         patch changes the SSA way of accessing the stack to do just that.
3057         
3058         Also add more IR validation.
3059
3060         * CMakeLists.txt:
3061         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
3062         * JavaScriptCore.xcodeproj/project.pbxproj:
3063         * dfg/DFGAbstractInterpreterInlines.h:
3064         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3065         * dfg/DFGClobberize.h:
3066         (JSC::DFG::clobberize):
3067         * dfg/DFGConstantFoldingPhase.cpp:
3068         (JSC::DFG::ConstantFoldingPhase::foldConstants):
3069         * dfg/DFGDoesGC.cpp:
3070         (JSC::DFG::doesGC):
3071         * dfg/DFGFixupPhase.cpp:
3072         (JSC::DFG::FixupPhase::fixupNode):
3073         * dfg/DFGFlushFormat.h:
3074         (JSC::DFG::isConcrete):
3075         * dfg/DFGGraph.cpp:
3076         (JSC::DFG::Graph::dump):
3077         * dfg/DFGGraph.h:
3078         * dfg/DFGMayExit.cpp:
3079         (JSC::DFG::mayExit):
3080         * dfg/DFGNode.cpp:
3081         (JSC::DFG::Node::hasVariableAccessData):
3082         * dfg/DFGNode.h:
3083         (JSC::DFG::StackAccessData::StackAccessData):
3084         (JSC::DFG::StackAccessData::flushedAt):
3085         (JSC::DFG::Node::convertToPutStack):
3086         (JSC::DFG::Node::convertToGetStack):
3087         (JSC::DFG::Node::hasUnlinkedLocal):
3088         (JSC::DFG::Node::hasStackAccessData):
3089         (JSC::DFG::Node::stackAccessData):
3090         (JSC::DFG::Node::willHaveCodeGenOrOSR):
3091         * dfg/DFGNodeType.h:
3092         * dfg/DFGOSRAvailabilityAnalysisPhase.cpp:
3093         (JSC::DFG::LocalOSRAvailabilityCalculator::executeNode):
3094         * dfg/DFGPlan.cpp:
3095         (JSC::DFG::Plan::compileInThreadImpl):
3096         * dfg/DFGPredictionPropagationPhase.cpp:
3097         (JSC::DFG::PredictionPropagationPhase::propagate):
3098         * dfg/DFGPutLocalSinkingPhase.cpp: Removed.
3099         * dfg/DFGPutLocalSinkingPhase.h: Removed.
3100         * dfg/DFGPutStackSinkingPhase.cpp: Copied from Source/JavaScriptCore/dfg/DFGPutLocalSinkingPhase.cpp.
3101         (JSC::DFG::performPutStackSinking):
3102         (JSC::DFG::performPutLocalSinking): Deleted.
3103         * dfg/DFGPutStackSinkingPhase.h: Copied from Source/JavaScriptCore/dfg/DFGPutLocalSinkingPhase.h.
3104         * dfg/DFGSSAConversionPhase.cpp:
3105         (JSC::DFG::SSAConversionPhase::run):
3106         * dfg/DFGSafeToExecute.h:
3107         (JSC::DFG::safeToExecute):
3108         * dfg/DFGSpeculativeJIT32_64.cpp:
3109         (JSC::DFG::SpeculativeJIT::compile):
3110         * dfg/DFGSpeculativeJIT64.cpp:
3111         (JSC::DFG::SpeculativeJIT::compile):
3112         * dfg/DFGStackLayoutPhase.cpp:
3113         (JSC::DFG::StackLayoutPhase::run):
3114         * dfg/DFGValidate.cpp:
3115         (JSC::DFG::Validate::validate):
3116         (JSC::DFG::Validate::validateCPS):
3117         (JSC::DFG::Validate::validateSSA):
3118         * dfg/DFGVirtualRegisterAllocationPhase.cpp:
3119         (JSC::DFG::VirtualRegisterAllocationPhase::run):
3120         * ftl/FTLCapabilities.cpp:
3121         (JSC::FTL::canCompile):
3122         * ftl/FTLLowerDFGToLLVM.cpp:
3123         (JSC::FTL::LowerDFGToLLVM::lower):
3124         (JSC::FTL::LowerDFGToLLVM::compileNode):
3125         (JSC::FTL::LowerDFGToLLVM::compileGetStack):
3126         (JSC::FTL::LowerDFGToLLVM::compilePutStack):
3127         (JSC::FTL::LowerDFGToLLVM::compileGetLocal): Deleted.
3128         (JSC::FTL::LowerDFGToLLVM::compilePutLocal): Deleted.
3129         * ftl/FTLOSRExit.h:
3130         * tests/stress/many-sunken-locals.js: Added. This failure mode was caught by some miscellaneous test, so I figured I should write an explicit test for it.
3131         (foo):
3132         (bar):
3133         (baz):
3134         (fuzz):
3135         (buzz):
3136
3137 2015-02-26  Mark Lam  <mark.lam@apple.com>
3138
3139         Rolling out r180602, r180608, r180613, r180617, r180671.
3140         <https://webkit.org/b/141990>
3141
3142         Not reviewed.
3143
3144         The r180602 solution does result in more work for GC when worker
3145         threads are in use.  Filip is uncomfortable with that.
3146         The EFL and GTK ports also seem to be unhappy with this change.
3147         Rolling out while we investigate.
3148
3149         * heap/Heap.cpp:
3150         (JSC::Heap::Heap):
3151         (JSC::Heap::gatherStackRoots):
3152         (JSC::Heap::machineThreads): Deleted.
3153         * heap/Heap.h:
3154         (JSC::Heap::machineThreads):
3155         * heap/MachineStackMarker.cpp:
3156         (JSC::MachineThreads::MachineThreads):
3157         (JSC::MachineThreads::~MachineThreads):
3158         (JSC::MachineThreads::addCurrentThread):
3159         * heap/MachineStackMarker.h:
3160         * runtime/JSLock.cpp:
3161         (JSC::JSLock::didAcquireLock):
3162
3163 2015-02-26  Myles C. Maxfield  <mmaxfield@apple.com>
3164
3165         [Mac] [iOS] Parsing support for -apple-trailing-word
3166         https://bugs.webkit.org/show_bug.cgi?id=141939
3167
3168         Reviewed by Andreas Kling.
3169
3170         * Configurations/FeatureDefines.xcconfig:
3171
3172 2015-02-26  Michael Saboff  <msaboff@apple.com>
3173
3174         [Win] Debug-only JavaScriptCore failures
3175         https://bugs.webkit.org/show_bug.cgi?id=142045
3176
3177         Rubber stamped by Filip Pizlo.
3178
3179         Reduced loop count to a more reasonable value of 10,000.  This still gets us to tier up
3180         to the FTL, but doesn't take too long to run.
3181
3182         * tests/stress/repeated-arity-check-fail.js:
3183
3184 2015-02-26  Brent Fulgham  <bfulgham@apple.com>
3185
3186         [Win] Make build logs more legible by reducing noise
3187         https://bugs.webkit.org/show_bug.cgi?id=142034
3188
3189         Reviewed by Alexey Proskuryakov.
3190
3191         Modify batch files, makefiles, and DOS commands to remove
3192         uninteresting/unhelpful output.
3193
3194         * JavaScriptCore.vcxproj/JavaScriptCoreGenerated.make:
3195         * JavaScriptCore.vcxproj/JavaScriptCorePreBuild.cmd:
3196         * JavaScriptCore.vcxproj/copy-files.cmd:
3197         * JavaScriptCore.vcxproj/jsc/jscLauncherPreBuild.cmd:
3198         * JavaScriptCore.vcxproj/jsc/jscPreBuild.cmd:
3199         * JavaScriptCore.vcxproj/testRegExp/testRegExpLauncherPreBuild.cmd:
3200         * JavaScriptCore.vcxproj/testRegExp/testRegExpPreBuild.cmd:
3201         * JavaScriptCore.vcxproj/testapi/testapiLauncherPostBuild.cmd:
3202         * JavaScriptCore.vcxproj/testapi/testapiLauncherPreBuild.cmd:
3203         * JavaScriptCore.vcxproj/testapi/testapiPostBuild.cmd:
3204         * JavaScriptCore.vcxproj/testapi/testapiPreBuild.cmd:
3205
3206 2015-02-26  Csaba Osztrogonác  <ossy@webkit.org>
3207
3208         Add calleeSaveRegisters() implementation for ARM Traditional
3209         https://bugs.webkit.org/show_bug.cgi?id=141903
3210
3211         Reviewed by Darin Adler.
3212
3213         * jit/RegisterSet.cpp:
3214         (JSC::RegisterSet::calleeSaveRegisters):
3215
3216 2015-02-25  Michael Saboff  <msaboff@apple.com>
3217
3218         Web Inspector: CRASH when debugger pauses inside a Promise handler
3219         https://bugs.webkit.org/show_bug.cgi?id=141396
3220
3221         Reviewed by Mark Lam.
3222
3223         For frames that don't have a scope, typically native frames, use the lexicalGlobalObject to
3224         create the DebuggerScope for that frame.
3225
3226         * debugger/DebuggerCallFrame.cpp:
3227         (JSC::DebuggerCallFrame::scope):
3228
3229 2015-02-25  Filip Pizlo  <fpizlo@apple.com>
3230
3231         DFG abstract heaps should respect the difference between heap and stack
3232         https://bugs.webkit.org/show_bug.cgi?id=142022
3233
3234         Reviewed by Geoffrey Garen.
3235         
3236         We will soon (https://bugs.webkit.org/show_bug.cgi?id=141174) be in a world where a "world
3237         clobbering" operation cannot write to our stack, but may be able to read from it. This
3238         means that we need to change the DFG abstract heap hierarchy to have a notion of Heap that
3239         subsumes all that World previously subsumed, and a new notion of Stack that is a subtype
3240         of World and a sibling of Heap.
3241
3242         So, henceforth "clobbering the world" means reading World and writing Heap.
3243         
3244         This makes a bunch of changes to make this work, including changing the implementation of
3245         disjointness in AbstractHeap to make it support a more general hierarchy. I was expecting
3246         a slow-down, but I measured the heck out of this and found no perf difference.
3247
3248         * dfg/DFGAbstractHeap.cpp:
3249         (JSC::DFG::AbstractHeap::dump):
3250         * dfg/DFGAbstractHeap.h:
3251         (JSC::DFG::AbstractHeap::supertype):
3252         (JSC::DFG::AbstractHeap::isStrictSubtypeOf):
3253         (JSC::DFG::AbstractHeap::isSubtypeOf):
3254         (JSC::DFG::AbstractHeap::overlaps):
3255         (JSC::DFG::AbstractHeap::isDisjoint):
3256         * dfg/DFGClobberize.cpp:
3257         (JSC::DFG::clobbersHeap):
3258         (JSC::DFG::clobbersWorld): Deleted.
3259         * dfg/DFGClobberize.h:
3260         (JSC::DFG::clobberize):
3261         * dfg/DFGDoesGC.cpp:
3262         (JSC::DFG::doesGC):
3263
3264 2015-02-25  Ryosuke Niwa  <rniwa@webkit.org>
3265
3266         REGRESSION(r180595): construct varargs fails in FTL
3267         https://bugs.webkit.org/show_bug.cgi?id=142030
3268
3269         Reviewed by Geoffrey Garen.
3270
3271         The bug was caused by IC size being too small for construct_varargs even though we've added a new argument.
3272         Fixed the bug by increasing the IC size to match call_varargs.
3273
3274         * ftl/FTLInlineCacheSize.cpp:
3275         (JSC::FTL::sizeOfConstructVarargs):
3276
3277 2015-02-25  Mark Lam  <mark.lam@apple.com>
3278
3279         ASan does not like JSC::MachineThreads::tryCopyOtherThreadStack.
3280         <https://webkit.org/b/141672>
3281
3282         Reviewed by Alexey Proskuryakov.
3283
3284         ASan does not like the fact that we memcpy the stack for GC scans.  So,
3285         we're working around this by using our own memcpy (asanUnsafeMemcpy)
3286         implementation that we can tell ASan to ignore.
3287
3288         * heap/MachineStackMarker.cpp:
3289         (JSC::asanUnsafeMemcpy):
3290
3291 2015-02-25  Benjamin Poulain  <bpoulain@apple.com>
3292
3293         CodeBlock crashes when dumping op_push_name_scope
3294         https://bugs.webkit.org/show_bug.cgi?id=141953
3295
3296         Reviewed by Filip Pizlo and Csaba Osztrogonác.
3297
3298         * bytecode/CodeBlock.cpp:
3299         (JSC::CodeBlock::dumpBytecode):
3300         * tests/stress/op-push-name-scope-crashes-profiler.js: Added.
3301
3302 2015-02-25  Benjamin Poulain  <benjamin@webkit.org>
3303
3304         Make ParserError immutable by design
3305         https://bugs.webkit.org/show_bug.cgi?id=141955
3306
3307         Reviewed by Geoffrey Garen.
3308
3309         This patch enforce that no field of ParserError can
3310         be modified after the constructor.
3311
3312         * parser/ParserError.h:
3313         Move the attributes to pack the integer + 2 bytes together.
3314         This is irrelevant for memory impact, it is to remve a load-store
3315         when copying by value.
3316
3317         Also move the attributes to be private.
3318
3319         (JSC::ParserError::isValid):
3320         To client of the interface cared about the type of the error,
3321         the only information needed was: is there an error.
3322
3323         (JSC::ParserError::ParserError):
3324         (JSC::ParserError::syntaxErrorType):
3325         (JSC::ParserError::token):
3326         (JSC::ParserError::message):
3327         (JSC::ParserError::line):
3328         (JSC::ParserError::toErrorObject):
3329         * API/JSScriptRef.cpp:
3330         * builtins/BuiltinExecutables.cpp:
3331         (JSC::BuiltinExecutables::createBuiltinExecutable):
3332         * bytecode/UnlinkedCodeBlock.cpp:
3333         (JSC::generateFunctionCodeBlock):
3334         (JSC::UnlinkedFunctionExecutable::fromGlobalCode):
3335         (JSC::UnlinkedFunctionExecutable::codeBlockFor):
3336         * bytecode/UnlinkedCodeBlock.h:
3337         * inspector/agents/InspectorRuntimeAgent.cpp:
3338         (Inspector::InspectorRuntimeAgent::parse):
3339         * jsc.cpp:
3340         (runInteractive):
3341         * parser/Parser.h:
3342         (JSC::parse):
3343         * runtime/CodeCache.cpp:
3344         (JSC::CodeCache::getGlobalCodeBlock):
3345         (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
3346         * runtime/CodeCache.h:
3347         * runtime/Completion.h:
3348         * runtime/Executable.cpp:
3349         (JSC::ProgramExecutable::checkSyntax):
3350         * runtime/JSGlobalObject.cpp:
3351         (JSC::JSGlobalObject::createProgramCodeBlock):
3352         (JSC::JSGlobalObject::createEvalCodeBlock):
3353
3354 2015-02-25  Filip Pizlo  <fpizlo@apple.com>
3355
3356         Need to pass RTLD_DEEPBIND to dlopen() to ensure that our LLVMOverrides take effect on Linux
3357         https://bugs.webkit.org/show_bug.cgi?id=142006
3358
3359         Reviewed by Csaba Osztrogonác.
3360
3361         This fixes hard-to-reproduce concurrency-related crashes when running stress tests with FTL and
3362         concurrent JIT enabled.
3363
3364         * llvm/InitializeLLVMPOSIX.cpp:
3365         (JSC::initializeLLVMPOSIX):
3366
3367 2015-02-24  Filip Pizlo  <fpizlo@apple.com>
3368
3369         CMake build of libllvmForJSC.so should limit its export list like the Xcode build does
3370         https://bugs.webkit.org/show_bug.cgi?id=141989
3371
3372         Reviewed by Gyuyoung Kim.
3373
3374         * CMakeLists.txt:
3375         * llvm/library/libllvmForJSC.version: Added.
3376
3377 2015-02-24  Alexey Proskuryakov  <ap@apple.com>
3378
3379         More iOS build fix after r180602.
3380
3381         * heap/Heap.h: Export Heap::machineThreads().
3382
3383 2015-02-24  Brent Fulgham  <bfulgham@apple.com>
3384
3385         Unreviewed build fix after r180602.
3386
3387         * heap/MachineStackMarker.h: Add missing 'no return'
3388         declaration for Windows.
3389
3390 2015-02-24  Commit Queue  <commit-queue@webkit.org>
3391
3392         Unreviewed, rolling out r180599.
3393         https://bugs.webkit.org/show_bug.cgi?id=141998
3394
3395         Lots of new test failures (Requested by smfr on #webkit).
3396
3397         Reverted changeset:
3398
3399         "Parsing support for -webkit-trailing-word"
3400         https://bugs.webkit.org/show_bug.cgi?id=141939
3401         http://trac.webkit.org/changeset/180599
3402
3403 2015-02-24  Mark Lam  <mark.lam@apple.com>
3404
3405         MachineThreads::Thread clean up has a use after free race condition.
3406         <https://webkit.org/b/141990>
3407
3408         Reviewed by Michael Saboff.
3409
3410         MachineThreads::Thread clean up relies on the clean up mechanism
3411         implemented in _pthread_tsd_cleanup_key(), which looks like this:
3412
3413         void _pthread_tsd_cleanup_key(pthread_t self, pthread_key_t key)
3414         {
3415             void (*destructor)(void *);
3416             if (_pthread_key_get_destructor(key, &destructor)) {
3417                 void **ptr = &self->tsd[key];
3418                 void *value = *ptr;
3419
3420                 // At this point, this thread has cached "destructor" and "value"
3421                 // (which is a MachineThreads*).  If the VM gets destructed (along
3422                 // with its MachineThreads registry) by another thread, then this
3423                 // thread will have no way of knowing that the MachineThreads* is
3424                 // now pointing to freed memory.  Calling the destructor below will
3425                 // therefore result in a use after free scenario when it tries to
3426                 // access the MachineThreads' data members.
3427
3428                 if (value) {
3429                     *ptr = NULL;
3430                     if (destructor) {
3431                         destructor(value);
3432                     }
3433                 }
3434             }
3435         }
3436
3437         The solution is simply to change MachineThreads from a per VM thread
3438         registry to a process global singleton thread registry i.e. the
3439         MachineThreads registry is now immortal and we cannot have a use after
3440         free scenario since we never free it.
3441
3442         The cost of this change is that all VM instances will have to scan
3443         stacks of all threads ever touched by a VM, and not just those that
3444         touched a specific VM.  However, stacks tend to be shallow.  Hence,
3445         those additional scans will tend to be cheap.
3446
3447         Secondly, it is not common for there to be multiple JSC VMs in use
3448         concurrently on multiple threads.  Hence, this cost should rarely
3449         manifest in real world applications.
3450
3451         * heap/Heap.cpp:
3452         (JSC::Heap::Heap):
3453         (JSC::Heap::machineThreads):
3454         (JSC::Heap::gatherStackRoots):
3455         * heap/Heap.h:
3456         (JSC::Heap::machineThreads): Deleted.
3457         * heap/MachineStackMarker.cpp:
3458         (JSC::MachineThreads::MachineThreads):
3459         (JSC::MachineThreads::~MachineThreads):
3460         (JSC::MachineThreads::addCurrentThread):
3461         * heap/MachineStackMarker.h:
3462         * runtime/JSLock.cpp:
3463         (JSC::JSLock::didAcquireLock):
3464
3465 2015-02-24  Myles C. Maxfield  <mmaxfield@apple.com>
3466
3467         [Mac] [iOS] Parsing support for -apple-trailing-word
3468         https://bugs.webkit.org/show_bug.cgi?id=141939
3469
3470         Reviewed by Andreas Kling.
3471
3472         * Configurations/FeatureDefines.xcconfig:
3473
3474 2015-02-24  Ryosuke Niwa  <rniwa@webkit.org>
3475
3476         Use "this" instead of "callee" to get the constructor
3477         https://bugs.webkit.org/show_bug.cgi?id=141019
3478
3479         Reviewed by Filip Pizlo.
3480
3481         This patch uses "this" register to pass the constructor (newTarget) to op_create_this from
3482         op_construct or op_construct_varargs. This will allow future patches that implement ES6 class
3483         to pass in the most derived class' constructor through "this" argument.
3484
3485         BytecodeGenerator's emitConstruct and emitConstructVarargs now passes thisRegister like
3486         regular calls and emitCreateThis passes in this register to op_create_this as constructor.
3487
3488         The rest of the code change removes the code for special casing "this" register not being used
3489         in call to construct.
3490
3491         * bytecode/BytecodeUseDef.h:
3492         (JSC::computeUsesForBytecodeOffset):
3493         * bytecompiler/BytecodeGenerator.cpp:
3494         (JSC::BytecodeGenerator::emitCreateThis):
3495         (JSC::BytecodeGenerator::emitConstructVarargs):
3496         (JSC::BytecodeGenerator::emitConstruct):
3497         * bytecompiler/BytecodeGenerator.h:
3498         * bytecompiler/NodesCodegen.cpp:
3499         (JSC::NewExprNode::emitBytecode):
3500         * dfg/DFGByteCodeParser.cpp:
3501         (JSC::DFG::ByteCodeParser::addCallWithoutSettingResult):
3502         (JSC::DFG::ByteCodeParser::handleVarargsCall):
3503         (JSC::DFG::ByteCodeParser::emitArgumentPhantoms):
3504         (JSC::DFG::ByteCodeParser::attemptToInlineCall):
3505         (JSC::DFG::ByteCodeParser::handleInlining):
3506         (JSC::DFG::ByteCodeParser::handleConstantInternalFunction):
3507         (JSC::DFG::ByteCodeParser::parseBlock):
3508         * dfg/DFGJITCode.cpp:
3509         (JSC::DFG::JITCode::reconstruct):
3510         * dfg/DFGSpeculativeJIT32_64.cpp:
3511         (JSC::DFG::SpeculativeJIT::emitCall):
3512         * dfg/DFGSpeculativeJIT64.cpp:
3513         (JSC::DFG::SpeculativeJIT::emitCall):
3514         * ftl/FTLJSCallVarargs.cpp:
3515         (JSC::FTL::JSCallVarargs::emit):
3516         * ftl/FTLLowerDFGToLLVM.cpp:
3517         (JSC::FTL::LowerDFGToLLVM::compileNativeCallOrConstruct):
3518         (JSC::FTL::LowerDFGToLLVM::compileCallOrConstruct):
3519         (JSC::FTL::LowerDFGToLLVM::compileCallOrConstructVarargs):
3520         * interpreter/Interpreter.cpp:
3521         (JSC::Interpreter::executeConstruct):
3522         * jit/JITOperations.cpp:
3523
3524 2015-02-24  Joseph Pecoraro  <pecoraro@apple.com>
3525
3526         Web Inspector: Make Getter/Setter RemoteObject property and ObjectPreview handling consistent
3527         https://bugs.webkit.org/show_bug.cgi?id=141587
3528
3529         Reviewed by Timothy Hatcher.
3530
3531         Convert getProperties(ownAndGetterProperties) to getDisplayableProperties().
3532         Mark PropertyDescriptors that are presumed to be native getters / bindings
3533         separately so that the frontend may display them differently.
3534
3535         * inspector/InjectedScript.cpp:
3536         (Inspector::InjectedScript::getProperties):
3537         (Inspector::InjectedScript::getDisplayableProperties):
3538         * inspector/InjectedScript.h:
3539         * inspector/InjectedScriptSource.js:
3540         * inspector/agents/InspectorRuntimeAgent.cpp:
3541         (Inspector::InspectorRuntimeAgent::getProperties):
3542         (Inspector::InspectorRuntimeAgent::getDisplayableProperties):
3543         * inspector/agents/InspectorRuntimeAgent.h:
3544         * inspector/protocol/Runtime.json:
3545
3546 2015-02-24  Mark Lam  <mark.lam@apple.com>
3547
3548         Rolling out r179753.  The fix was invalid.
3549         <https://webkit.org/b/141990>
3550
3551         Not reviewed.
3552
3553         * API/tests/testapi.mm:
3554         (threadMain):
3555         (useVMFromOtherThread): Deleted.
3556         (useVMFromOtherThreadAndOutliveVM): Deleted.
3557         * heap/Heap.cpp:
3558         (JSC::Heap::Heap):
3559         (JSC::Heap::~Heap):
3560         (JSC::Heap::gatherStackRoots):
3561         * heap/Heap.h:
3562         (JSC::Heap::machineThreads):
3563         * heap/MachineStackMarker.cpp:
3564         (JSC::MachineThreads::Thread::Thread):
3565         (JSC::MachineThreads::MachineThreads):
3566         (JSC::MachineThreads::~MachineThreads):
3567         (JSC::MachineThreads::addCurrentThread):
3568         (JSC::MachineThreads::removeThread):
3569         (JSC::MachineThreads::removeCurrentThread):
3570         * heap/MachineStackMarker.h:
3571
3572 2015-02-24  Yusuke Suzuki  <utatane.tea@gmail.com>
3573
3574         Constructor returning null should construct an object instead of null
3575         https://bugs.webkit.org/show_bug.cgi?id=141640
3576
3577         Reviewed by Filip Pizlo.
3578
3579         When constructor code doesn't return object, constructor should return `this` object instead.
3580         Since we used `op_is_object` for this check and `op_is_object` is intended to be used for `typeof`,
3581         it allows `null` as an object.
3582         This patch fixes it by introducing an new bytecode `op_is_object_or_null` for `typeof` use cases.
3583         Instead, constructor uses simplified `is_object`.
3584
3585         As a result, `op_is_object` becomes fairly simple. So we introduce optimization for `op_is_object`.
3586
3587         1. LLInt and baseline JIT support `op_is_object` as a fast path.
3588         2. DFG abstract interpreter support `op_is_object`. And recognize its speculated type and read-write effects.
3589         3. DFG introduces inlined asm for `op_is_object` rather than calling a C++ function.
3590         4. FTL lowers DFG's IsObject into LLVM IR.
3591
3592         And at the same time, this patch fixes isString / isObject predicate used for `op_is_object` and others
3593         in LLInt, JIT, DFG and FTL.
3594         Before introducing ES6 Symbol, JSCell is only used for object and string in user observable area.
3595         So in many places, when the cell is not object, we recognize it as a string, and vice versa.
3596         However, now ES6 Symbol is implemented as a JSCell, this assumption is broken.
3597         So this patch stop using !isString as isObject.
3598         To check whether a cell is an object, instead of seeing that structure ID of a cell is not stringStructure,
3599         we examine typeInfo in JSCell.
3600
3601         * JavaScriptCore.order:
3602         * bytecode/BytecodeList.json:
3603         * bytecode/BytecodeUseDef.h:
3604         (JSC::computeUsesForBytecodeOffset):
3605         (JSC::computeDefsForBytecodeOffset):
3606         * bytecode/CodeBlock.cpp:
3607         (JSC::CodeBlock::dumpBytecode):
3608         * bytecode/PutByIdStatus.cpp:
3609         (JSC::PutByIdStatus::computeFor):
3610         * bytecompiler/BytecodeGenerator.cpp:
3611         (JSC::BytecodeGenerator::emitEqualityOp):
3612         (JSC::BytecodeGenerator::emitReturn):
3613         * dfg/DFGAbstractInterpreterInlines.h:
3614         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3615         * dfg/DFGByteCodeParser.cpp:
3616         (JSC::DFG::ByteCodeParser::parseBlock):
3617         * dfg/DFGCapabilities.cpp:
3618         (JSC::DFG::capabilityLevel):
3619         * dfg/DFGClobberize.h:
3620         (JSC::DFG::clobberize):
3621
3622         IsObject operation only touches JSCell typeInfoType.
3623         And this value would be changed through structure transition.
3624         As a result, IsObject can report that it doesn't read any information.
3625
3626         * dfg/DFGConstantFoldingPhase.cpp:
3627         (JSC::DFG::ConstantFoldingPhase::foldConstants):
3628         * dfg/DFGDoesGC.cpp:
3629         (JSC::DFG::doesGC):
3630         * dfg/DFGFixupPhase.cpp:
3631         (JSC::DFG::FixupPhase::fixupNode):
3632
3633         Just like IsString, IsObject is also fixed up.
3634
3635         * dfg/DFGHeapLocation.cpp:
3636         (WTF::printInternal):
3637         * dfg/DFGHeapLocation.h:
3638         * dfg/DFGNodeType.h:
3639         * dfg/DFGOperations.cpp:
3640         * dfg/DFGOperations.h:
3641         * dfg/DFGPredictionPropagationPhase.cpp:
3642         (JSC::DFG::PredictionPropagationPhase::propagate):
3643         * dfg/DFGSafeToExecute.h:
3644         (JSC::DFG::safeToExecute):
3645         * dfg/DFGSpeculativeJIT.cpp:
3646         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
3647         (JSC::DFG::SpeculativeJIT::compileStringToUntypedEquality):
3648         (JSC::DFG::SpeculativeJIT::compileStringIdentToNotStringVarEquality):
3649         (JSC::DFG::SpeculativeJIT::compileToStringOnCell):
3650         (JSC::DFG::SpeculativeJIT::speculateObject):
3651         (JSC::DFG::SpeculativeJIT::speculateObjectOrOther):
3652         (JSC::DFG::SpeculativeJIT::speculateString):
3653         (JSC::DFG::SpeculativeJIT::speculateNotStringVar):
3654         (JSC::DFG::SpeculativeJIT::emitSwitchChar):
3655         (JSC::DFG::SpeculativeJIT::emitSwitchString):
3656         (JSC::DFG::SpeculativeJIT::branchIsObject):
3657         (JSC::DFG::SpeculativeJIT::branchNotObject):
3658         (JSC::DFG::SpeculativeJIT::branchIsString):
3659         (JSC::DFG::SpeculativeJIT::branchNotString):
3660         * dfg/DFGSpeculativeJIT.h:
3661         * dfg/DFGSpeculativeJIT32_64.cpp:
3662         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
3663         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
3664         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
3665         (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
3666         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
3667         (JSC::DFG::SpeculativeJIT::compile):
3668         * dfg/DFGSpeculativeJIT64.cpp:
3669         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
3670         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
3671         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
3672         (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
3673         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
3674         (JSC::DFG::SpeculativeJIT::compile):
3675         * ftl/FTLCapabilities.cpp:
3676         (JSC::FTL::canCompile):
3677         * ftl/FTLLowerDFGToLLVM.cpp:
3678         (JSC::FTL::LowerDFGToLLVM::compileNode):
3679         (JSC::FTL::LowerDFGToLLVM::compileToString):
3680         (JSC::FTL::LowerDFGToLLVM::compileIsObject):
3681         (JSC::FTL::LowerDFGToLLVM::compileIsObjectOrNull):
3682         (JSC::FTL::LowerDFGToLLVM::speculateTruthyObject):
3683         (JSC::FTL::LowerDFGToLLVM::equalNullOrUndefined):
3684         (JSC::FTL::LowerDFGToLLVM::isObject):
3685         (JSC::FTL::LowerDFGToLLVM::isNotObject):
3686         (JSC::FTL::LowerDFGToLLVM::isNotString):
3687         (JSC::FTL::LowerDFGToLLVM::speculateNonNullObject):
3688         * jit/JIT.cpp:
3689         (JSC::JIT::privateCompileMainPass):
3690         * jit/JIT.h:
3691         * jit/JITInlines.h:
3692         (JSC::JIT::emitJumpIfCellObject):
3693         * jit/JITOpcodes.cpp:
3694         (JSC::JIT::emit_op_is_object):
3695         (JSC::JIT::emit_op_to_primitive):
3696         * jit/JITOpcodes32_64.cpp:
3697         (JSC::JIT::emit_op_is_object):
3698         (JSC::JIT::emit_op_to_primitive):
3699         (JSC::JIT::compileOpStrictEq):
3700         * llint/LowLevelInterpreter.asm:
3701         * llint/LowLevelInterpreter32_64.asm:
3702         * llint/LowLevelInterpreter64.asm:
3703         * runtime/CommonSlowPaths.cpp:
3704         (JSC::SLOW_PATH_DECL):
3705         * runtime/CommonSlowPaths.h:
3706         * runtime/Operations.cpp:
3707         (JSC::jsIsObjectTypeOrNull):
3708         (JSC::jsIsObjectType): Deleted.
3709         * runtime/Operations.h:
3710         * tests/stress/constructor-with-return.js: Added.
3711         (Test):
3712
3713         When constructor doesn't return an object, `this` should be returned instead.
3714         In this test, we check all primitives. And test object, array and wrappers.
3715
3716         * tests/stress/dfg-to-primitive-pass-symbol.js: Added.
3717         (toPrimitiveTarget):
3718         (doToPrimitive):
3719
3720         op_to_primitive operation passes Symbol in fast path.
3721
3722 2015-02-24  Yusuke Suzuki  <utatane.tea@gmail.com>
3723
3724         REGRESSION(r179429): Can't type comments in Facebook
3725         https://bugs.webkit.org/show_bug.cgi?id=141859
3726
3727         Reviewed by Brent Fulgham.
3728
3729         When window.Symbol is exposed to user-space pages,
3730         Facebook's JavaScript use it (maybe, for immutable-js and React.js's unique key).
3731         However, to work with Symbols completely, it also requires
3732         1) Object.getOwnPropertySymbols (for mixin including Symbols)
3733         2) the latest ES6 Iterator interface that uses Iterator.next and it returns { done: boolean, value: value }.
3734         Since they are not landed yet, comments in Facebook don't work.
3735
3736         This patch introduces RuntimeFlags for JavaScriptCore.
3737         Specifying SymbolEnabled flag under test runner and inspector to continue to work with Symbol.
3738         And drop JavaScriptExperimentsEnabled flag
3739         because it is no longer used and use case of this is duplicated to runtime flags.
3740
3741         * JavaScriptCore.order:
3742         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
3743         * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
3744         * JavaScriptCore.xcodeproj/project.pbxproj:
3745         * jsc.cpp:
3746         (GlobalObject::javaScriptRuntimeFlags):
3747         (GlobalObject::javaScriptExperimentsEnabled): Deleted.
3748         * runtime/JSGlobalObject.cpp:
3749         (JSC::JSGlobalObject::JSGlobalObject):
3750         (JSC::JSGlobalObject::init):
3751         * runtime/JSGlobalObject.h:
3752         (JSC::JSGlobalObject::finishCreation):
3753         (JSC::JSGlobalObject::javaScriptRuntimeFlags):
3754         (JSC::JSGlobalObject::javaScriptExperimentsEnabled): Deleted.
3755         * runtime/RuntimeFlags.h: Added.
3756         (JSC::RuntimeFlags::RuntimeFlags):
3757         (JSC::RuntimeFlags::createAllEnabled):
3758
3759 2015-02-23  Filip Pizlo  <fpizlo@apple.com>
3760
3761         Our bizarre behavior on Arguments::defineOwnProperty should be deliberate rather than a spaghetti incident
3762         https://bugs.webkit.org/show_bug.cgi?id=141951
3763
3764         Reviewed by Benjamin Poulain.
3765         
3766         This patch has no behavioral change, but it simplifies a bunch of wrong code. The code is
3767         still wrong in exactly the same way, but at least it's obvious what's going on. The wrongness
3768         is covered by this bug: https://bugs.webkit.org/show_bug.cgi?id=141952.
3769
3770         * runtime/Arguments.cpp:
3771         (JSC::Arguments::copyBackingStore): We should only see the arguments token; assert otherwise. This works because if the GC sees the butterfly token it calls the JSObject::copyBackingStore method directly.
3772         (JSC::Arguments::defineOwnProperty): Make our bizarre behavior deliberate rather than an accident of a decade of patches.
3773         * tests/stress/arguments-bizarre-behavior.js: Added.
3774         (foo):
3775         * tests/stress/arguments-bizarre-behaviour-disable-enumerability.js: Added. My choice of spellings of the word "behavio[u]r" is almost as consistent as our implementation of arguments.
3776         (foo):
3777         * tests/stress/arguments-custom-properties-gc.js: Added. I added this test because at first I was unsure if we GCd arguments correctly.
3778         (makeBaseArguments):
3779         (makeArray):
3780         (cons):
3781
3782 2015-02-23  Commit Queue  <commit-queue@webkit.org>
3783
3784         Unreviewed, rolling out r180547 and r180550.
3785         https://bugs.webkit.org/show_bug.cgi?id=141957
3786
3787         Broke 10 Windows tests. (Requested by bfulgham_ on #webkit).
3788
3789         Reverted changesets:
3790
3791         "REGRESSION(r179429): Can't type comments in Facebook"
3792         https://bugs.webkit.org/show_bug.cgi?id=141859
3793         http://trac.webkit.org/changeset/180547
3794
3795         "Constructor returning null should construct an object instead
3796         of null"
3797         https://bugs.webkit.org/show_bug.cgi?id=141640
3798         http://trac.webkit.org/changeset/180550
3799
3800 2015-02-23  Yusuke Suzuki  <utatane.tea@gmail.com>
3801
3802         Constructor returning null should construct an object instead of null
3803         https://bugs.webkit.org/show_bug.cgi?id=141640
3804
3805         Reviewed by Geoffrey Garen.
3806
3807         When constructor code doesn't return object, constructor should return `this` object instead.
3808         Since we used `op_is_object` for this check and `op_is_object` is intended to be used for `typeof`,
3809         it allows `null` as an object.
3810         This patch fixes it by introducing an new bytecode `op_is_object_or_null` for `typeof` use cases.
3811         Instead, constructor uses simplified `is_object`.
3812
3813         As a result, `op_is_object` becomes fairly simple. So we introduce optimization for `op_is_object`.
3814
3815         1. LLInt and baseline JIT support `op_is_object` as a fast path.
3816         2. DFG abstract interpreter support `op_is_object`. And recognize its speculated type and read-write effects.
3817         3. DFG introduces inlined asm for `op_is_object` rather than calling a C++ function.
3818         4. FTL lowers DFG's IsObject into LLVM IR.
3819
3820         And at the same time, this patch fixes isString / isObject predicate used for `op_is_object` and others
3821         in LLInt, JIT, DFG and FTL.
3822         Before introducing ES6 Symbol, JSCell is only used for object and string in user observable area.
3823         So in many places, when the cell is not object, we recognize it as a string, and vice versa.
3824         However, now ES6 Symbol is implemented as a JSCell, this assumption is broken.
3825         So this patch stop using !isString as isObject.
3826         To check whether a cell is an object, instead of seeing that structure ID of a cell is not stringStructure,
3827         we examine typeInfo in JSCell.
3828
3829         * JavaScriptCore.order:
3830         * bytecode/BytecodeList.json:
3831         * bytecode/BytecodeUseDef.h:
3832         (JSC::computeUsesForBytecodeOffset):
3833         (JSC::computeDefsForBytecodeOffset):
3834         * bytecode/CodeBlock.cpp:
3835         (JSC::CodeBlock::dumpBytecode):
3836         * bytecode/PutByIdStatus.cpp:
3837         (JSC::PutByIdStatus::computeFor):
3838         * bytecompiler/BytecodeGenerator.cpp:
3839         (JSC::BytecodeGenerator::emitEqualityOp):
3840         (JSC::BytecodeGenerator::emitReturn):
3841         * dfg/DFGAbstractInterpreterInlines.h:
3842         (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
3843         * dfg/DFGByteCodeParser.cpp:
3844         (JSC::DFG::ByteCodeParser::parseBlock):
3845         * dfg/DFGCapabilities.cpp:
3846         (JSC::DFG::capabilityLevel):
3847         * dfg/DFGClobberize.h:
3848         (JSC::DFG::clobberize):
3849
3850         IsObject operation only touches JSCell typeInfoType.
3851         And this value would not be changed through structure transition.
3852         As a result, IsObject can report that it doesn't read any information.
3853
3854         * dfg/DFGDoesGC.cpp:
3855         (JSC::DFG::doesGC):
3856         * dfg/DFGFixupPhase.cpp:
3857         (JSC::DFG::FixupPhase::fixupNode):
3858
3859         Just like IsString, IsObject is also fixed up.
3860
3861         * dfg/DFGHeapLocation.cpp:
3862         (WTF::printInternal):
3863         * dfg/DFGHeapLocation.h:
3864         * dfg/DFGNodeType.h:
3865         * dfg/DFGOperations.cpp:
3866         * dfg/DFGOperations.h:
3867         * dfg/DFGPredictionPropagationPhase.cpp:
3868         (JSC::DFG::PredictionPropagationPhase::propagate):
3869         * dfg/DFGSafeToExecute.h:
3870         (JSC::DFG::safeToExecute):
3871         * dfg/DFGSpeculativeJIT.cpp:
3872         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
3873         (JSC::DFG::SpeculativeJIT::compileStringToUntypedEquality):
3874         (JSC::DFG::SpeculativeJIT::compileStringIdentToNotStringVarEquality):
3875         (JSC::DFG::SpeculativeJIT::compileToStringOnCell):
3876         (JSC::DFG::SpeculativeJIT::speculateObject):
3877         (JSC::DFG::SpeculativeJIT::speculateObjectOrOther):
3878         (JSC::DFG::SpeculativeJIT::speculateString):
3879         (JSC::DFG::SpeculativeJIT::speculateNotStringVar):
3880         (JSC::DFG::SpeculativeJIT::emitSwitchChar):
3881         (JSC::DFG::SpeculativeJIT::emitSwitchString):
3882         (JSC::DFG::SpeculativeJIT::branchIsObject):
3883         (JSC::DFG::SpeculativeJIT::branchNotObject):
3884         (JSC::DFG::SpeculativeJIT::branchIsString):
3885         (JSC::DFG::SpeculativeJIT::branchNotString):
3886         * dfg/DFGSpeculativeJIT.h:
3887         * dfg/DFGSpeculativeJIT32_64.cpp:
3888         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
3889         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
3890         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
3891         (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
3892         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
3893         (JSC::DFG::SpeculativeJIT::compile):
3894         * dfg/DFGSpeculativeJIT64.cpp:
3895         (JSC::DFG::SpeculativeJIT::compileObjectEquality):
3896         (JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
3897         (JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
3898         (JSC::DFG::SpeculativeJIT::compileObjectOrOtherLogicalNot):
3899         (JSC::DFG::SpeculativeJIT::emitObjectOrOtherBranch):
3900         (JSC::DFG::SpeculativeJIT::compile):
3901         * ftl/FTLCapabilities.cpp:
3902         (JSC::FTL::canCompile):
3903         * ftl/FTLLowerDFGToLLVM.cpp:
3904         (JSC::FTL::LowerDFGToLLVM::compileNode):
3905         (JSC::FTL::LowerDFGToLLVM::compileToString):
3906         (JSC::FTL::LowerDFGToLLVM::compileIsObject):
3907         (JSC::FTL::LowerDFGToLLVM::compileIsObjectOrNull):
3908         (JSC::FTL::LowerDFGToLLVM::speculateTruthyObject):
3909         (JSC::FTL::LowerDFGToLLVM::equalNullOrUndefined):
3910         (JSC::FTL::LowerDFGToLLVM::isObject):
3911         (JSC::FTL::LowerDFGToLLVM::isNotObject):
3912         (JSC::FTL::LowerDFGToLLVM::isNotString):
3913         (JSC::FTL::LowerDFGToLLVM::speculateNonNullObject):