We should support the ability to do a non-effectful getById
[WebKit-https.git] / Source / JavaScriptCore / jsc.cpp
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2004-2008, 2012-2013, 2015-2016 Apple Inc. All rights reserved.
4  *  Copyright (C) 2006 Bjoern Graf (bjoern.graf@gmail.com)
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #include "config.h"
24
25 #include "ArrayPrototype.h"
26 #include "BuiltinExecutables.h"
27 #include "ButterflyInlines.h"
28 #include "BytecodeGenerator.h"
29 #include "CodeBlock.h"
30 #include "Completion.h"
31 #include "CopiedSpaceInlines.h"
32 #include "DFGPlan.h"
33 #include "Disassembler.h"
34 #include "Exception.h"
35 #include "ExceptionHelpers.h"
36 #include "GetterSetter.h"
37 #include "HeapProfiler.h"
38 #include "HeapSnapshotBuilder.h"
39 #include "HeapStatistics.h"
40 #include "InitializeThreading.h"
41 #include "Interpreter.h"
42 #include "JSArray.h"
43 #include "JSArrayBuffer.h"
44 #include "JSCInlines.h"
45 #include "JSFunction.h"
46 #include "JSInternalPromise.h"
47 #include "JSInternalPromiseDeferred.h"
48 #include "JSLock.h"
49 #include "JSNativeStdFunction.h"
50 #include "JSONObject.h"
51 #include "JSProxy.h"
52 #include "JSString.h"
53 #include "JSWASMModule.h"
54 #include "ProfilerDatabase.h"
55 #include "SamplingProfiler.h"
56 #include "ShadowChicken.h"
57 #include "StackVisitor.h"
58 #include "StructureInlines.h"
59 #include "StructureRareDataInlines.h"
60 #include "SuperSampler.h"
61 #include "TestRunnerUtils.h"
62 #include "TypeProfilerLog.h"
63 #include "WASMModuleParser.h"
64 #include <math.h>
65 #include <stdio.h>
66 #include <stdlib.h>
67 #include <string.h>
68 #include <thread>
69 #include <wtf/CurrentTime.h>
70 #include <wtf/MainThread.h>
71 #include <wtf/StringPrintStream.h>
72 #include <wtf/text/StringBuilder.h>
73
74 #if OS(WINDOWS)
75 #include <direct.h>
76 #else
77 #include <unistd.h>
78 #endif
79
80 #if HAVE(READLINE)
81 // readline/history.h has a Function typedef which conflicts with the WTF::Function template from WTF/Forward.h
82 // We #define it to something else to avoid this conflict.
83 #define Function ReadlineFunction
84 #include <readline/history.h>
85 #include <readline/readline.h>
86 #undef Function
87 #endif
88
89 #if HAVE(SYS_TIME_H)
90 #include <sys/time.h>
91 #endif
92
93 #if HAVE(SIGNAL_H)
94 #include <signal.h>
95 #endif
96
97 #if COMPILER(MSVC)
98 #include <crtdbg.h>
99 #include <mmsystem.h>
100 #include <windows.h>
101 #endif
102
103 #if PLATFORM(IOS) && CPU(ARM_THUMB2)
104 #include <fenv.h>
105 #include <arm/arch.h>
106 #endif
107
108 #if PLATFORM(EFL)
109 #include <Ecore.h>
110 #endif
111
112 #if !defined(PATH_MAX)
113 #define PATH_MAX 4096
114 #endif
115
116 using namespace JSC;
117 using namespace WTF;
118
119 namespace {
120
121 NO_RETURN_WITH_VALUE static void jscExit(int status)
122 {
123     waitForAsynchronousDisassembly();
124     
125 #if ENABLE(DFG_JIT)
126     if (DFG::isCrashing()) {
127         for (;;) {
128 #if OS(WINDOWS)
129             Sleep(1000);
130 #else
131             pause();
132 #endif
133         }
134     }
135 #endif // ENABLE(DFG_JIT)
136     exit(status);
137 }
138
139 class Element;
140 class ElementHandleOwner;
141 class Masuqerader;
142 class Root;
143 class RuntimeArray;
144
145 class Element : public JSNonFinalObject {
146 public:
147     Element(VM& vm, Structure* structure)
148         : Base(vm, structure)
149     {
150     }
151
152     typedef JSNonFinalObject Base;
153     static const bool needsDestruction = false;
154
155     Root* root() const { return m_root.get(); }
156     void setRoot(VM& vm, Root* root) { m_root.set(vm, this, root); }
157
158     static Element* create(VM& vm, JSGlobalObject* globalObject, Root* root)
159     {
160         Structure* structure = createStructure(vm, globalObject, jsNull());
161         Element* element = new (NotNull, allocateCell<Element>(vm.heap, sizeof(Element))) Element(vm, structure);
162         element->finishCreation(vm, root);
163         return element;
164     }
165
166     void finishCreation(VM&, Root*);
167
168     static void visitChildren(JSCell* cell, SlotVisitor& visitor)
169     {
170         Element* thisObject = jsCast<Element*>(cell);
171         ASSERT_GC_OBJECT_INHERITS(thisObject, info());
172         Base::visitChildren(thisObject, visitor);
173         visitor.append(&thisObject->m_root);
174     }
175
176     static ElementHandleOwner* handleOwner();
177
178     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
179     {
180         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
181     }
182
183     DECLARE_INFO;
184
185 private:
186     WriteBarrier<Root> m_root;
187 };
188
189 class ElementHandleOwner : public WeakHandleOwner {
190 public:
191     virtual bool isReachableFromOpaqueRoots(Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
192     {
193         Element* element = jsCast<Element*>(handle.slot()->asCell());
194         return visitor.containsOpaqueRoot(element->root());
195     }
196 };
197
198 class Masquerader : public JSNonFinalObject {
199 public:
200     Masquerader(VM& vm, Structure* structure)
201         : Base(vm, structure)
202     {
203     }
204
205     typedef JSNonFinalObject Base;
206     static const unsigned StructureFlags = Base::StructureFlags | JSC::MasqueradesAsUndefined;
207
208     static Masquerader* create(VM& vm, JSGlobalObject* globalObject)
209     {
210         globalObject->masqueradesAsUndefinedWatchpoint()->fireAll("Masquerading object allocated");
211         Structure* structure = createStructure(vm, globalObject, jsNull());
212         Masquerader* result = new (NotNull, allocateCell<Masquerader>(vm.heap, sizeof(Masquerader))) Masquerader(vm, structure);
213         result->finishCreation(vm);
214         return result;
215     }
216
217     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
218     {
219         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
220     }
221
222     DECLARE_INFO;
223 };
224
225 class Root : public JSDestructibleObject {
226 public:
227     Root(VM& vm, Structure* structure)
228         : Base(vm, structure)
229     {
230     }
231
232     Element* element()
233     {
234         return m_element.get();
235     }
236
237     void setElement(Element* element)
238     {
239         Weak<Element> newElement(element, Element::handleOwner());
240         m_element.swap(newElement);
241     }
242
243     static Root* create(VM& vm, JSGlobalObject* globalObject)
244     {
245         Structure* structure = createStructure(vm, globalObject, jsNull());
246         Root* root = new (NotNull, allocateCell<Root>(vm.heap, sizeof(Root))) Root(vm, structure);
247         root->finishCreation(vm);
248         return root;
249     }
250
251     typedef JSDestructibleObject Base;
252
253     DECLARE_INFO;
254     static const bool needsDestruction = true;
255
256     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
257     {
258         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
259     }
260
261     static void visitChildren(JSCell* thisObject, SlotVisitor& visitor)
262     {
263         Base::visitChildren(thisObject, visitor);
264         visitor.addOpaqueRoot(thisObject);
265     }
266
267 private:
268     Weak<Element> m_element;
269 };
270
271 class ImpureGetter : public JSNonFinalObject {
272 public:
273     ImpureGetter(VM& vm, Structure* structure)
274         : Base(vm, structure)
275     {
276     }
277
278     DECLARE_INFO;
279     typedef JSNonFinalObject Base;
280     static const unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpure | JSC::OverridesGetOwnPropertySlot;
281
282     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
283     {
284         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
285     }
286
287     static ImpureGetter* create(VM& vm, Structure* structure, JSObject* delegate)
288     {
289         ImpureGetter* getter = new (NotNull, allocateCell<ImpureGetter>(vm.heap, sizeof(ImpureGetter))) ImpureGetter(vm, structure);
290         getter->finishCreation(vm, delegate);
291         return getter;
292     }
293
294     void finishCreation(VM& vm, JSObject* delegate)
295     {
296         Base::finishCreation(vm);
297         if (delegate)
298             m_delegate.set(vm, this, delegate);
299     }
300
301     static bool getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName name, PropertySlot& slot)
302     {
303         ImpureGetter* thisObject = jsCast<ImpureGetter*>(object);
304         
305         if (thisObject->m_delegate && thisObject->m_delegate->getPropertySlot(exec, name, slot))
306             return true;
307
308         return Base::getOwnPropertySlot(object, exec, name, slot);
309     }
310
311     static void visitChildren(JSCell* cell, SlotVisitor& visitor)
312     {
313         Base::visitChildren(cell, visitor);
314         ImpureGetter* thisObject = jsCast<ImpureGetter*>(cell);
315         visitor.append(&thisObject->m_delegate);
316     }
317
318     void setDelegate(VM& vm, JSObject* delegate)
319     {
320         m_delegate.set(vm, this, delegate);
321     }
322
323 private:
324     WriteBarrier<JSObject> m_delegate;
325 };
326
327 class CustomGetter : public JSNonFinalObject {
328 public:
329     CustomGetter(VM& vm, Structure* structure)
330         : Base(vm, structure)
331     {
332     }
333
334     DECLARE_INFO;
335     typedef JSNonFinalObject Base;
336     static const unsigned StructureFlags = Base::StructureFlags | JSC::OverridesGetOwnPropertySlot;
337
338     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
339     {
340         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
341     }
342
343     static CustomGetter* create(VM& vm, Structure* structure)
344     {
345         CustomGetter* getter = new (NotNull, allocateCell<CustomGetter>(vm.heap, sizeof(CustomGetter))) CustomGetter(vm, structure);
346         getter->finishCreation(vm);
347         return getter;
348     }
349
350     static bool getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
351     {
352         CustomGetter* thisObject = jsCast<CustomGetter*>(object);
353         if (propertyName == PropertyName(Identifier::fromString(exec, "customGetter"))) {
354             slot.setCacheableCustom(thisObject, DontDelete | ReadOnly | DontEnum, thisObject->customGetter);
355             return true;
356         }
357         return JSObject::getOwnPropertySlot(thisObject, exec, propertyName, slot);
358     }
359
360 private:
361     static EncodedJSValue customGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName)
362     {
363         CustomGetter* thisObject = jsDynamicCast<CustomGetter*>(JSValue::decode(thisValue));
364         if (!thisObject)
365             return throwVMTypeError(exec);
366         bool shouldThrow = thisObject->get(exec, PropertyName(Identifier::fromString(exec, "shouldThrow"))).toBoolean(exec);
367         if (shouldThrow)
368             return throwVMTypeError(exec);
369         return JSValue::encode(jsNumber(100));
370     }
371 };
372
373 class RuntimeArray : public JSArray {
374 public:
375     typedef JSArray Base;
376     static const unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | OverridesGetPropertyNames;
377
378     static RuntimeArray* create(ExecState* exec)
379     {
380         VM& vm = exec->vm();
381         JSGlobalObject* globalObject = exec->lexicalGlobalObject();
382         Structure* structure = createStructure(vm, globalObject, createPrototype(vm, globalObject));
383         RuntimeArray* runtimeArray = new (NotNull, allocateCell<RuntimeArray>(*exec->heap())) RuntimeArray(exec, structure);
384         runtimeArray->finishCreation(exec);
385         vm.heap.addFinalizer(runtimeArray, destroy);
386         return runtimeArray;
387     }
388
389     ~RuntimeArray() { }
390
391     static void destroy(JSCell* cell)
392     {
393         static_cast<RuntimeArray*>(cell)->RuntimeArray::~RuntimeArray();
394     }
395
396     static const bool needsDestruction = false;
397
398     static bool getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
399     {
400         RuntimeArray* thisObject = jsCast<RuntimeArray*>(object);
401         if (propertyName == exec->propertyNames().length) {
402             slot.setCacheableCustom(thisObject, DontDelete | ReadOnly | DontEnum, thisObject->lengthGetter);
403             return true;
404         }
405
406         Optional<uint32_t> index = parseIndex(propertyName);
407         if (index && index.value() < thisObject->getLength()) {
408             slot.setValue(thisObject, DontDelete | DontEnum, jsNumber(thisObject->m_vector[index.value()]));
409             return true;
410         }
411
412         return JSObject::getOwnPropertySlot(thisObject, exec, propertyName, slot);
413     }
414
415     static bool getOwnPropertySlotByIndex(JSObject* object, ExecState* exec, unsigned index, PropertySlot& slot)
416     {
417         RuntimeArray* thisObject = jsCast<RuntimeArray*>(object);
418         if (index < thisObject->getLength()) {
419             slot.setValue(thisObject, DontDelete | DontEnum, jsNumber(thisObject->m_vector[index]));
420             return true;
421         }
422
423         return JSObject::getOwnPropertySlotByIndex(thisObject, exec, index, slot);
424     }
425
426     static NO_RETURN_DUE_TO_CRASH bool put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&)
427     {
428         RELEASE_ASSERT_NOT_REACHED();
429     }
430
431     static NO_RETURN_DUE_TO_CRASH bool deleteProperty(JSCell*, ExecState*, PropertyName)
432     {
433         RELEASE_ASSERT_NOT_REACHED();
434     }
435
436     unsigned getLength() const { return m_vector.size(); }
437
438     DECLARE_INFO;
439
440     static ArrayPrototype* createPrototype(VM&, JSGlobalObject* globalObject)
441     {
442         return globalObject->arrayPrototype();
443     }
444
445     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
446     {
447         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info(), ArrayClass);
448     }
449
450 protected:
451     void finishCreation(ExecState* exec)
452     {
453         Base::finishCreation(exec->vm());
454         ASSERT(inherits(info()));
455
456         for (size_t i = 0; i < exec->argumentCount(); i++)
457             m_vector.append(exec->argument(i).toInt32(exec));
458     }
459
460 private:
461     RuntimeArray(ExecState* exec, Structure* structure)
462         : JSArray(exec->vm(), structure, 0)
463     {
464     }
465
466     static EncodedJSValue lengthGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName)
467     {
468         RuntimeArray* thisObject = jsDynamicCast<RuntimeArray*>(JSValue::decode(thisValue));
469         if (!thisObject)
470             return throwVMTypeError(exec);
471         return JSValue::encode(jsNumber(thisObject->getLength()));
472     }
473
474     Vector<int> m_vector;
475 };
476
477 class SimpleObject : public JSNonFinalObject {
478 public:
479     SimpleObject(VM& vm, Structure* structure)
480         : Base(vm, structure)
481     {
482     }
483
484     typedef JSNonFinalObject Base;
485     static const bool needsDestruction = false;
486
487     static SimpleObject* create(VM& vm, JSGlobalObject* globalObject)
488     {
489         Structure* structure = createStructure(vm, globalObject, jsNull());
490         SimpleObject* simpleObject = new (NotNull, allocateCell<SimpleObject>(vm.heap, sizeof(SimpleObject))) SimpleObject(vm, structure);
491         simpleObject->finishCreation(vm);
492         return simpleObject;
493     }
494
495     static void visitChildren(JSCell* cell, SlotVisitor& visitor)
496     {
497         SimpleObject* thisObject = jsCast<SimpleObject*>(cell);
498         ASSERT_GC_OBJECT_INHERITS(thisObject, info());
499         Base::visitChildren(thisObject, visitor);
500         visitor.append(&thisObject->m_hiddenValue);
501     }
502
503     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
504     {
505         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
506     }
507
508     JSValue hiddenValue()
509     {
510         return m_hiddenValue.get();
511     }
512
513     void setHiddenValue(VM& vm, JSValue value)
514     {
515         ASSERT(value.isCell());
516         m_hiddenValue.set(vm, this, value);
517     }
518
519     DECLARE_INFO;
520
521 private:
522     WriteBarrier<JSC::Unknown> m_hiddenValue;
523 };
524
525
526 const ClassInfo Element::s_info = { "Element", &Base::s_info, 0, CREATE_METHOD_TABLE(Element) };
527 const ClassInfo Masquerader::s_info = { "Masquerader", &Base::s_info, 0, CREATE_METHOD_TABLE(Masquerader) };
528 const ClassInfo Root::s_info = { "Root", &Base::s_info, 0, CREATE_METHOD_TABLE(Root) };
529 const ClassInfo ImpureGetter::s_info = { "ImpureGetter", &Base::s_info, 0, CREATE_METHOD_TABLE(ImpureGetter) };
530 const ClassInfo CustomGetter::s_info = { "CustomGetter", &Base::s_info, 0, CREATE_METHOD_TABLE(CustomGetter) };
531 const ClassInfo RuntimeArray::s_info = { "RuntimeArray", &Base::s_info, 0, CREATE_METHOD_TABLE(RuntimeArray) };
532 const ClassInfo SimpleObject::s_info = { "SimpleObject", &Base::s_info, 0, CREATE_METHOD_TABLE(SimpleObject) };
533
534 ElementHandleOwner* Element::handleOwner()
535 {
536     static ElementHandleOwner* owner = 0;
537     if (!owner)
538         owner = new ElementHandleOwner();
539     return owner;
540 }
541
542 void Element::finishCreation(VM& vm, Root* root)
543 {
544     Base::finishCreation(vm);
545     setRoot(vm, root);
546     m_root->setElement(this);
547 }
548
549 }
550
551 static bool fillBufferWithContentsOfFile(const String& fileName, Vector<char>& buffer);
552
553 static EncodedJSValue JSC_HOST_CALL functionCreateProxy(ExecState*);
554 static EncodedJSValue JSC_HOST_CALL functionCreateRuntimeArray(ExecState*);
555 static EncodedJSValue JSC_HOST_CALL functionCreateImpureGetter(ExecState*);
556 static EncodedJSValue JSC_HOST_CALL functionCreateCustomGetterObject(ExecState*);
557 static EncodedJSValue JSC_HOST_CALL functionCreateBuiltin(ExecState*);
558 static EncodedJSValue JSC_HOST_CALL functionSetImpureGetterDelegate(ExecState*);
559
560 static EncodedJSValue JSC_HOST_CALL functionSetElementRoot(ExecState*);
561 static EncodedJSValue JSC_HOST_CALL functionCreateRoot(ExecState*);
562 static EncodedJSValue JSC_HOST_CALL functionCreateElement(ExecState*);
563 static EncodedJSValue JSC_HOST_CALL functionGetElement(ExecState*);
564 static EncodedJSValue JSC_HOST_CALL functionCreateSimpleObject(ExecState*);
565 static EncodedJSValue JSC_HOST_CALL functionGetHiddenValue(ExecState*);
566 static EncodedJSValue JSC_HOST_CALL functionSetHiddenValue(ExecState*);
567 static EncodedJSValue JSC_HOST_CALL functionPrint(ExecState*);
568 static EncodedJSValue JSC_HOST_CALL functionDebug(ExecState*);
569 static EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState*);
570 static EncodedJSValue JSC_HOST_CALL functionDescribeArray(ExecState*);
571 static EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState*);
572 static EncodedJSValue JSC_HOST_CALL functionGCAndSweep(ExecState*);
573 static EncodedJSValue JSC_HOST_CALL functionFullGC(ExecState*);
574 static EncodedJSValue JSC_HOST_CALL functionEdenGC(ExecState*);
575 static EncodedJSValue JSC_HOST_CALL functionForceGCSlowPaths(ExecState*);
576 static EncodedJSValue JSC_HOST_CALL functionHeapSize(ExecState*);
577 static EncodedJSValue JSC_HOST_CALL functionAddressOf(ExecState*);
578 static EncodedJSValue JSC_HOST_CALL functionGetGetterSetter(ExecState*);
579 #ifndef NDEBUG
580 static EncodedJSValue JSC_HOST_CALL functionDumpCallFrame(ExecState*);
581 #endif
582 static EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*);
583 static EncodedJSValue JSC_HOST_CALL functionRun(ExecState*);
584 static EncodedJSValue JSC_HOST_CALL functionLoad(ExecState*);
585 static EncodedJSValue JSC_HOST_CALL functionReadFile(ExecState*);
586 static EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState*);
587 static EncodedJSValue JSC_HOST_CALL functionReadline(ExecState*);
588 static EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*);
589 static EncodedJSValue JSC_HOST_CALL functionNeverInlineFunction(ExecState*);
590 static EncodedJSValue JSC_HOST_CALL functionNoDFG(ExecState*);
591 static EncodedJSValue JSC_HOST_CALL functionOptimizeNextInvocation(ExecState*);
592 static EncodedJSValue JSC_HOST_CALL functionNumberOfDFGCompiles(ExecState*);
593 static EncodedJSValue JSC_HOST_CALL functionReoptimizationRetryCount(ExecState*);
594 static EncodedJSValue JSC_HOST_CALL functionTransferArrayBuffer(ExecState*);
595 static EncodedJSValue JSC_HOST_CALL functionFailNextNewCodeBlock(ExecState*);
596 static NO_RETURN_WITH_VALUE EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*);
597 static NO_RETURN_DUE_TO_CRASH EncodedJSValue JSC_HOST_CALL functionAbort(ExecState*);
598 static EncodedJSValue JSC_HOST_CALL functionFalse1(ExecState*);
599 static EncodedJSValue JSC_HOST_CALL functionFalse2(ExecState*);
600 static EncodedJSValue JSC_HOST_CALL functionUndefined1(ExecState*);
601 static EncodedJSValue JSC_HOST_CALL functionUndefined2(ExecState*);
602 static EncodedJSValue JSC_HOST_CALL functionIsInt32(ExecState*);
603 static EncodedJSValue JSC_HOST_CALL functionEffectful42(ExecState*);
604 static EncodedJSValue JSC_HOST_CALL functionIdentity(ExecState*);
605 static EncodedJSValue JSC_HOST_CALL functionMakeMasquerader(ExecState*);
606 static EncodedJSValue JSC_HOST_CALL functionHasCustomProperties(ExecState*);
607 static EncodedJSValue JSC_HOST_CALL functionDumpTypesForAllVariables(ExecState*);
608 static EncodedJSValue JSC_HOST_CALL functionFindTypeForExpression(ExecState*);
609 static EncodedJSValue JSC_HOST_CALL functionReturnTypeFor(ExecState*);
610 static EncodedJSValue JSC_HOST_CALL functionDumpBasicBlockExecutionRanges(ExecState*);
611 static EncodedJSValue JSC_HOST_CALL functionHasBasicBlockExecuted(ExecState*);
612 static EncodedJSValue JSC_HOST_CALL functionBasicBlockExecutionCount(ExecState*);
613 static EncodedJSValue JSC_HOST_CALL functionEnableExceptionFuzz(ExecState*);
614 static EncodedJSValue JSC_HOST_CALL functionDrainMicrotasks(ExecState*);
615 static EncodedJSValue JSC_HOST_CALL functionIs32BitPlatform(ExecState*);
616 #if ENABLE(WEBASSEMBLY)
617 static EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState*);
618 #endif
619 static EncodedJSValue JSC_HOST_CALL functionLoadModule(ExecState*);
620 static EncodedJSValue JSC_HOST_CALL functionCheckModuleSyntax(ExecState*);
621 static EncodedJSValue JSC_HOST_CALL functionPlatformSupportsSamplingProfiler(ExecState*);
622 static EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshot(ExecState*);
623 #if ENABLE(SAMPLING_PROFILER)
624 static EncodedJSValue JSC_HOST_CALL functionStartSamplingProfiler(ExecState*);
625 static EncodedJSValue JSC_HOST_CALL functionSamplingProfilerStackTraces(ExecState*);
626 #endif
627
628 #if ENABLE(SAMPLING_FLAGS)
629 static EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*);
630 static EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState*);
631 #endif
632
633 static EncodedJSValue JSC_HOST_CALL functionShadowChickenFunctionsOnStack(ExecState*);
634
635 struct Script {
636     bool isFile;
637     char* argument;
638
639     Script(bool isFile, char *argument)
640         : isFile(isFile)
641         , argument(argument)
642     {
643     }
644 };
645
646 class CommandLine {
647 public:
648     CommandLine(int argc, char** argv)
649     {
650         parseArguments(argc, argv);
651     }
652
653     bool m_interactive { false };
654     bool m_dump { false };
655     bool m_module { false };
656     bool m_exitCode { false };
657     Vector<Script> m_scripts;
658     Vector<String> m_arguments;
659     bool m_profile { false };
660     String m_profilerOutput;
661
662     void parseArguments(int, char**);
663 };
664
665 static const char interactivePrompt[] = ">>> ";
666
667 class StopWatch {
668 public:
669     void start();
670     void stop();
671     long getElapsedMS(); // call stop() first
672
673 private:
674     double m_startTime;
675     double m_stopTime;
676 };
677
678 void StopWatch::start()
679 {
680     m_startTime = monotonicallyIncreasingTime();
681 }
682
683 void StopWatch::stop()
684 {
685     m_stopTime = monotonicallyIncreasingTime();
686 }
687
688 long StopWatch::getElapsedMS()
689 {
690     return static_cast<long>((m_stopTime - m_startTime) * 1000);
691 }
692
693 template<typename Vector>
694 static inline String stringFromUTF(const Vector& utf8)
695 {
696     return String::fromUTF8WithLatin1Fallback(utf8.data(), utf8.size());
697 }
698
699 template<typename Vector>
700 static inline SourceCode jscSource(const Vector& utf8, const String& filename)
701 {
702     String str = stringFromUTF(utf8);
703     return makeSource(str, filename);
704 }
705
706 class GlobalObject : public JSGlobalObject {
707 private:
708     GlobalObject(VM&, Structure*);
709
710 public:
711     typedef JSGlobalObject Base;
712
713     static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)
714     {
715         GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure);
716         object->finishCreation(vm, arguments);
717         vm.heap.addFinalizer(object, destroy);
718         return object;
719     }
720
721     static const bool needsDestruction = false;
722
723     DECLARE_INFO;
724     static const GlobalObjectMethodTable s_globalObjectMethodTable;
725
726     static Structure* createStructure(VM& vm, JSValue prototype)
727     {
728         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
729     }
730
731     static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags::createAllEnabled(); }
732
733 protected:
734     void finishCreation(VM& vm, const Vector<String>& arguments)
735     {
736         Base::finishCreation(vm);
737         
738         addFunction(vm, "debug", functionDebug, 1);
739         addFunction(vm, "describe", functionDescribe, 1);
740         addFunction(vm, "describeArray", functionDescribeArray, 1);
741         addFunction(vm, "print", functionPrint, 1);
742         addFunction(vm, "quit", functionQuit, 0);
743         addFunction(vm, "abort", functionAbort, 0);
744         addFunction(vm, "gc", functionGCAndSweep, 0);
745         addFunction(vm, "fullGC", functionFullGC, 0);
746         addFunction(vm, "edenGC", functionEdenGC, 0);
747         addFunction(vm, "forceGCSlowPaths", functionForceGCSlowPaths, 0);
748         addFunction(vm, "gcHeapSize", functionHeapSize, 0);
749         addFunction(vm, "addressOf", functionAddressOf, 1);
750         addFunction(vm, "getGetterSetter", functionGetGetterSetter, 2);
751 #ifndef NDEBUG
752         addFunction(vm, "dumpCallFrame", functionDumpCallFrame, 0);
753 #endif
754         addFunction(vm, "version", functionVersion, 1);
755         addFunction(vm, "run", functionRun, 1);
756         addFunction(vm, "load", functionLoad, 1);
757         addFunction(vm, "readFile", functionReadFile, 1);
758         addFunction(vm, "checkSyntax", functionCheckSyntax, 1);
759         addFunction(vm, "jscStack", functionJSCStack, 1);
760         addFunction(vm, "readline", functionReadline, 0);
761         addFunction(vm, "preciseTime", functionPreciseTime, 0);
762         addFunction(vm, "neverInlineFunction", functionNeverInlineFunction, 1);
763         addFunction(vm, "noInline", functionNeverInlineFunction, 1);
764         addFunction(vm, "noDFG", functionNoDFG, 1);
765         addFunction(vm, "numberOfDFGCompiles", functionNumberOfDFGCompiles, 1);
766         addFunction(vm, "optimizeNextInvocation", functionOptimizeNextInvocation, 1);
767         addFunction(vm, "reoptimizationRetryCount", functionReoptimizationRetryCount, 1);
768         addFunction(vm, "transferArrayBuffer", functionTransferArrayBuffer, 1);
769         addFunction(vm, "failNextNewCodeBlock", functionFailNextNewCodeBlock, 1);
770 #if ENABLE(SAMPLING_FLAGS)
771         addFunction(vm, "setSamplingFlags", functionSetSamplingFlags, 1);
772         addFunction(vm, "clearSamplingFlags", functionClearSamplingFlags, 1);
773 #endif
774         addFunction(vm, "shadowChickenFunctionsOnStack", functionShadowChickenFunctionsOnStack, 0);
775         addConstructableFunction(vm, "Root", functionCreateRoot, 0);
776         addConstructableFunction(vm, "Element", functionCreateElement, 1);
777         addFunction(vm, "getElement", functionGetElement, 1);
778         addFunction(vm, "setElementRoot", functionSetElementRoot, 2);
779         
780         addConstructableFunction(vm, "SimpleObject", functionCreateSimpleObject, 0);
781         addFunction(vm, "getHiddenValue", functionGetHiddenValue, 1);
782         addFunction(vm, "setHiddenValue", functionSetHiddenValue, 2);
783         
784         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "DFGTrue"), 0, functionFalse1, DFGTrueIntrinsic, DontEnum);
785         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "OSRExit"), 0, functionUndefined1, OSRExitIntrinsic, DontEnum);
786         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "isFinalTier"), 0, functionFalse2, IsFinalTierIntrinsic, DontEnum);
787         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "predictInt32"), 0, functionUndefined2, SetInt32HeapPredictionIntrinsic, DontEnum);
788         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "isInt32"), 0, functionIsInt32, CheckInt32Intrinsic, DontEnum);
789         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "fiatInt52"), 0, functionIdentity, FiatInt52Intrinsic, DontEnum);
790         
791         addFunction(vm, "effectful42", functionEffectful42, 0);
792         addFunction(vm, "makeMasquerader", functionMakeMasquerader, 0);
793         addFunction(vm, "hasCustomProperties", functionHasCustomProperties, 0);
794
795         addFunction(vm, "createProxy", functionCreateProxy, 1);
796         addFunction(vm, "createRuntimeArray", functionCreateRuntimeArray, 0);
797
798         addFunction(vm, "createImpureGetter", functionCreateImpureGetter, 1);
799         addFunction(vm, "createCustomGetterObject", functionCreateCustomGetterObject, 0);
800         addFunction(vm, "createBuiltin", functionCreateBuiltin, 2);
801         addFunction(vm, "setImpureGetterDelegate", functionSetImpureGetterDelegate, 2);
802
803         addFunction(vm, "dumpTypesForAllVariables", functionDumpTypesForAllVariables , 0);
804         addFunction(vm, "findTypeForExpression", functionFindTypeForExpression, 2);
805         addFunction(vm, "returnTypeFor", functionReturnTypeFor, 1);
806
807         addFunction(vm, "dumpBasicBlockExecutionRanges", functionDumpBasicBlockExecutionRanges , 0);
808         addFunction(vm, "hasBasicBlockExecuted", functionHasBasicBlockExecuted, 2);
809         addFunction(vm, "basicBlockExecutionCount", functionBasicBlockExecutionCount, 2);
810
811         addFunction(vm, "enableExceptionFuzz", functionEnableExceptionFuzz, 0);
812
813         addFunction(vm, "drainMicrotasks", functionDrainMicrotasks, 0);
814
815         addFunction(vm, "is32BitPlatform", functionIs32BitPlatform, 0);
816
817 #if ENABLE(WEBASSEMBLY)
818         addFunction(vm, "loadWebAssembly", functionLoadWebAssembly, 3);
819 #endif
820         addFunction(vm, "loadModule", functionLoadModule, 1);
821         addFunction(vm, "checkModuleSyntax", functionCheckModuleSyntax, 1);
822
823         addFunction(vm, "platformSupportsSamplingProfiler", functionPlatformSupportsSamplingProfiler, 0);
824         addFunction(vm, "generateHeapSnapshot", functionGenerateHeapSnapshot, 0);
825 #if ENABLE(SAMPLING_PROFILER)
826         addFunction(vm, "startSamplingProfiler", functionStartSamplingProfiler, 0);
827         addFunction(vm, "samplingProfilerStackTraces", functionSamplingProfilerStackTraces, 0);
828 #endif
829
830         if (!arguments.isEmpty()) {
831             JSArray* array = constructEmptyArray(globalExec(), 0);
832             for (size_t i = 0; i < arguments.size(); ++i)
833                 array->putDirectIndex(globalExec(), i, jsString(globalExec(), arguments[i]));
834             putDirect(vm, Identifier::fromString(globalExec(), "arguments"), array);
835         }
836
837         putDirect(vm, Identifier::fromString(globalExec(), "console"), jsUndefined());
838     }
839
840     void addFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)
841     {
842         Identifier identifier = Identifier::fromString(&vm, name);
843         putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function));
844     }
845     
846     void addConstructableFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)
847     {
848         Identifier identifier = Identifier::fromString(&vm, name);
849         putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function, NoIntrinsic, function));
850     }
851
852     static JSInternalPromise* moduleLoaderResolve(JSGlobalObject*, ExecState*, JSValue, JSValue);
853     static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, ExecState*, JSValue);
854 };
855
856 const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, nullptr, CREATE_METHOD_TABLE(GlobalObject) };
857 const GlobalObjectMethodTable GlobalObject::s_globalObjectMethodTable = { &allowsAccessFrom, &supportsLegacyProfiling, &supportsRichSourceInfo, &shouldInterruptScript, &javaScriptRuntimeFlags, 0, &shouldInterruptScriptBeforeTimeout, &moduleLoaderResolve, &moduleLoaderFetch, nullptr, nullptr, nullptr, nullptr };
858
859
860 GlobalObject::GlobalObject(VM& vm, Structure* structure)
861     : JSGlobalObject(vm, structure, &s_globalObjectMethodTable)
862 {
863 }
864
865 static UChar pathSeparator()
866 {
867 #if OS(WINDOWS)
868     return '\\';
869 #else
870     return '/';
871 #endif
872 }
873
874 struct DirectoryName {
875     // In unix, it is "/". In Windows, it becomes a drive letter like "C:\"
876     String rootName;
877
878     // If the directory name is "/home/WebKit", this becomes "home/WebKit". If the directory name is "/", this becomes "".
879     String queryName;
880 };
881
882 struct ModuleName {
883     ModuleName(const String& moduleName);
884
885     bool startsWithRoot() const
886     {
887         return !queries.isEmpty() && queries[0].isEmpty();
888     }
889
890     Vector<String> queries;
891 };
892
893 ModuleName::ModuleName(const String& moduleName)
894 {
895     // A module name given from code is represented as the UNIX style path. Like, `./A/B.js`.
896     moduleName.split('/', true, queries);
897 }
898
899 static bool extractDirectoryName(const String& absolutePathToFile, DirectoryName& directoryName)
900 {
901     size_t firstSeparatorPosition = absolutePathToFile.find(pathSeparator());
902     if (firstSeparatorPosition == notFound)
903         return false;
904     directoryName.rootName = absolutePathToFile.substring(0, firstSeparatorPosition + 1); // Include the separator.
905     size_t lastSeparatorPosition = absolutePathToFile.reverseFind(pathSeparator());
906     ASSERT_WITH_MESSAGE(lastSeparatorPosition != notFound, "If the separator is not found, this function already returns when performing the forward search.");
907     if (firstSeparatorPosition == lastSeparatorPosition)
908         directoryName.queryName = StringImpl::empty();
909     else {
910         size_t queryStartPosition = firstSeparatorPosition + 1;
911         size_t queryLength = lastSeparatorPosition - queryStartPosition; // Not include the last separator.
912         directoryName.queryName = absolutePathToFile.substring(queryStartPosition, queryLength);
913     }
914     return true;
915 }
916
917 static bool currentWorkingDirectory(DirectoryName& directoryName)
918 {
919 #if OS(WINDOWS)
920     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364934.aspx
921     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx#maxpath
922     // The _MAX_PATH in Windows is 260. If the path of the current working directory is longer than that, _getcwd truncates the result.
923     // And other I/O functions taking a path name also truncate it. To avoid this situation,
924     //
925     // (1). When opening the file in Windows for modules, we always use the abosolute path and add "\\?\" prefix to the path name.
926     // (2). When retrieving the current working directory, use GetCurrentDirectory instead of _getcwd.
927     //
928     // In the path utility functions inside the JSC shell, we does not handle the UNC and UNCW including the network host name.
929     DWORD bufferLength = ::GetCurrentDirectoryW(0, nullptr);
930     if (!bufferLength)
931         return false;
932     // In Windows, wchar_t is the UTF-16LE.
933     // https://msdn.microsoft.com/en-us/library/dd374081.aspx
934     // https://msdn.microsoft.com/en-us/library/windows/desktop/ff381407.aspx
935     auto buffer = std::make_unique<wchar_t[]>(bufferLength);
936     DWORD lengthNotIncludingNull = ::GetCurrentDirectoryW(bufferLength, buffer.get());
937     static_assert(sizeof(wchar_t) == sizeof(UChar), "In Windows, both are UTF-16LE");
938     String directoryString = String(reinterpret_cast<UChar*>(buffer.get()));
939     // We don't support network path like \\host\share\<path name>.
940     if (directoryString.startsWith("\\\\"))
941         return false;
942 #else
943     auto buffer = std::make_unique<char[]>(PATH_MAX);
944     if (!getcwd(buffer.get(), PATH_MAX))
945         return false;
946     String directoryString = String::fromUTF8(buffer.get());
947 #endif
948     if (directoryString.isEmpty())
949         return false;
950
951     if (directoryString[directoryString.length() - 1] == pathSeparator())
952         return extractDirectoryName(directoryString, directoryName);
953     // Append the seperator to represents the file name. extractDirectoryName only accepts the absolute file name.
954     return extractDirectoryName(makeString(directoryString, pathSeparator()), directoryName);
955 }
956
957 static String resolvePath(const DirectoryName& directoryName, const ModuleName& moduleName)
958 {
959     Vector<String> directoryPieces;
960     directoryName.queryName.split(pathSeparator(), false, directoryPieces);
961
962     // Only first '/' is recognized as the path from the root.
963     if (moduleName.startsWithRoot())
964         directoryPieces.clear();
965
966     for (const auto& query : moduleName.queries) {
967         if (query == String(ASCIILiteral(".."))) {
968             if (!directoryPieces.isEmpty())
969                 directoryPieces.removeLast();
970         } else if (!query.isEmpty() && query != String(ASCIILiteral(".")))
971             directoryPieces.append(query);
972     }
973
974     StringBuilder builder;
975     builder.append(directoryName.rootName);
976     for (size_t i = 0; i < directoryPieces.size(); ++i) {
977         builder.append(directoryPieces[i]);
978         if (i + 1 != directoryPieces.size())
979             builder.append(pathSeparator());
980     }
981     return builder.toString();
982 }
983
984 JSInternalPromise* GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSValue keyValue, JSValue referrerValue)
985 {
986     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
987     const Identifier key = keyValue.toPropertyKey(exec);
988     if (exec->hadException()) {
989         JSValue exception = exec->exception();
990         exec->clearException();
991         return deferred->reject(exec, exception);
992     }
993
994     if (key.isSymbol())
995         return deferred->resolve(exec, keyValue);
996
997     DirectoryName directoryName;
998     if (referrerValue.isUndefined()) {
999         if (!currentWorkingDirectory(directoryName))
1000             return deferred->reject(exec, createError(exec, ASCIILiteral("Could not resolve the current working directory.")));
1001     } else {
1002         const Identifier referrer = referrerValue.toPropertyKey(exec);
1003         if (exec->hadException()) {
1004             JSValue exception = exec->exception();
1005             exec->clearException();
1006             return deferred->reject(exec, exception);
1007         }
1008         if (referrer.isSymbol()) {
1009             if (!currentWorkingDirectory(directoryName))
1010                 return deferred->reject(exec, createError(exec, ASCIILiteral("Could not resolve the current working directory.")));
1011         } else {
1012             // If the referrer exists, we assume that the referrer is the correct absolute path.
1013             if (!extractDirectoryName(referrer.impl(), directoryName))
1014                 return deferred->reject(exec, createError(exec, makeString("Could not resolve the referrer name '", String(referrer.impl()), "'.")));
1015         }
1016     }
1017
1018     return deferred->resolve(exec, jsString(exec, resolvePath(directoryName, ModuleName(key.impl()))));
1019 }
1020
1021 static void convertShebangToJSComment(Vector<char>& buffer)
1022 {
1023     if (buffer.size() >= 2) {
1024         if (buffer[0] == '#' && buffer[1] == '!')
1025             buffer[0] = buffer[1] = '/';
1026     }
1027 }
1028
1029 static bool fillBufferWithContentsOfFile(FILE* file, Vector<char>& buffer)
1030 {
1031     fseek(file, 0, SEEK_END);
1032     size_t bufferCapacity = ftell(file);
1033     fseek(file, 0, SEEK_SET);
1034     buffer.resize(bufferCapacity);
1035     size_t readSize = fread(buffer.data(), 1, buffer.size(), file);
1036     return readSize == buffer.size();
1037 }
1038
1039 static bool fillBufferWithContentsOfFile(const String& fileName, Vector<char>& buffer)
1040 {
1041     FILE* f = fopen(fileName.utf8().data(), "rb");
1042     if (!f) {
1043         fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
1044         return false;
1045     }
1046
1047     bool result = fillBufferWithContentsOfFile(f, buffer);
1048     fclose(f);
1049
1050     return result;
1051 }
1052
1053 static bool fetchScriptFromLocalFileSystem(const String& fileName, Vector<char>& buffer)
1054 {
1055     if (!fillBufferWithContentsOfFile(fileName, buffer))
1056         return false;
1057     convertShebangToJSComment(buffer);
1058     return true;
1059 }
1060
1061 static bool fetchModuleFromLocalFileSystem(const String& fileName, Vector<char>& buffer)
1062 {
1063     // We assume that fileName is always an absolute path.
1064 #if OS(WINDOWS)
1065     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx#maxpath
1066     // Use long UNC to pass the long path name to the Windows APIs.
1067     String longUNCPathName = WTF::makeString("\\\\?\\", fileName);
1068     static_assert(sizeof(wchar_t) == sizeof(UChar), "In Windows, both are UTF-16LE");
1069     auto utf16Vector = longUNCPathName.charactersWithNullTermination();
1070     FILE* f = _wfopen(reinterpret_cast<wchar_t*>(utf16Vector.data()), L"rb");
1071 #else
1072     FILE* f = fopen(fileName.utf8().data(), "r");
1073 #endif
1074     if (!f) {
1075         fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
1076         return false;
1077     }
1078
1079     bool result = fillBufferWithContentsOfFile(f, buffer);
1080     if (result)
1081         convertShebangToJSComment(buffer);
1082     fclose(f);
1083
1084     return result;
1085 }
1086
1087 JSInternalPromise* GlobalObject::moduleLoaderFetch(JSGlobalObject* globalObject, ExecState* exec, JSValue key)
1088 {
1089     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
1090     String moduleKey = key.toString(exec)->value(exec);
1091     if (exec->hadException()) {
1092         JSValue exception = exec->exception();
1093         exec->clearException();
1094         return deferred->reject(exec, exception);
1095     }
1096
1097     // Here, now we consider moduleKey as the fileName.
1098     Vector<char> utf8;
1099     if (!fetchModuleFromLocalFileSystem(moduleKey, utf8))
1100         return deferred->reject(exec, createError(exec, makeString("Could not open file '", moduleKey, "'.")));
1101
1102     return deferred->resolve(exec, jsString(exec, stringFromUTF(utf8)));
1103 }
1104
1105
1106 EncodedJSValue JSC_HOST_CALL functionPrint(ExecState* exec)
1107 {
1108     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1109         if (i)
1110             putchar(' ');
1111
1112         printf("%s", exec->uncheckedArgument(i).toString(exec)->view(exec).get().utf8().data());
1113     }
1114
1115     putchar('\n');
1116     fflush(stdout);
1117     return JSValue::encode(jsUndefined());
1118 }
1119
1120 #ifndef NDEBUG
1121 EncodedJSValue JSC_HOST_CALL functionDumpCallFrame(ExecState* exec)
1122 {
1123     VMEntryFrame* topVMEntryFrame = exec->vm().topVMEntryFrame;
1124     ExecState* callerFrame = exec->callerFrame(topVMEntryFrame);
1125     if (callerFrame)
1126         exec->vm().interpreter->dumpCallFrame(callerFrame);
1127     return JSValue::encode(jsUndefined());
1128 }
1129 #endif
1130
1131 EncodedJSValue JSC_HOST_CALL functionDebug(ExecState* exec)
1132 {
1133     fprintf(stderr, "--> %s\n", exec->argument(0).toString(exec)->view(exec).get().utf8().data());
1134     return JSValue::encode(jsUndefined());
1135 }
1136
1137 EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState* exec)
1138 {
1139     if (exec->argumentCount() < 1)
1140         return JSValue::encode(jsUndefined());
1141     return JSValue::encode(jsString(exec, toString(exec->argument(0))));
1142 }
1143
1144 EncodedJSValue JSC_HOST_CALL functionDescribeArray(ExecState* exec)
1145 {
1146     if (exec->argumentCount() < 1)
1147         return JSValue::encode(jsUndefined());
1148     JSObject* object = jsDynamicCast<JSObject*>(exec->argument(0));
1149     if (!object)
1150         return JSValue::encode(jsNontrivialString(exec, ASCIILiteral("<not object>")));
1151     return JSValue::encode(jsNontrivialString(exec, toString("<Public length: ", object->getArrayLength(), "; vector length: ", object->getVectorLength(), ">")));
1152 }
1153
1154 class FunctionJSCStackFunctor {
1155 public:
1156     FunctionJSCStackFunctor(StringBuilder& trace)
1157         : m_trace(trace)
1158     {
1159     }
1160
1161     StackVisitor::Status operator()(StackVisitor& visitor) const
1162     {
1163         m_trace.append(String::format("    %zu   %s\n", visitor->index(), visitor->toString().utf8().data()));
1164         return StackVisitor::Continue;
1165     }
1166
1167 private:
1168     StringBuilder& m_trace;
1169 };
1170
1171 EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState* exec)
1172 {
1173     StringBuilder trace;
1174     trace.appendLiteral("--> Stack trace:\n");
1175
1176     FunctionJSCStackFunctor functor(trace);
1177     exec->iterate(functor);
1178     fprintf(stderr, "%s", trace.toString().utf8().data());
1179     return JSValue::encode(jsUndefined());
1180 }
1181
1182 EncodedJSValue JSC_HOST_CALL functionCreateRoot(ExecState* exec)
1183 {
1184     JSLockHolder lock(exec);
1185     return JSValue::encode(Root::create(exec->vm(), exec->lexicalGlobalObject()));
1186 }
1187
1188 EncodedJSValue JSC_HOST_CALL functionCreateElement(ExecState* exec)
1189 {
1190     JSLockHolder lock(exec);
1191     Root* root = jsDynamicCast<Root*>(exec->argument(0));
1192     if (!root)
1193         return JSValue::encode(jsUndefined());
1194     return JSValue::encode(Element::create(exec->vm(), exec->lexicalGlobalObject(), root));
1195 }
1196
1197 EncodedJSValue JSC_HOST_CALL functionGetElement(ExecState* exec)
1198 {
1199     JSLockHolder lock(exec);
1200     Root* root = jsDynamicCast<Root*>(exec->argument(0));
1201     if (!root)
1202         return JSValue::encode(jsUndefined());
1203     Element* result = root->element();
1204     return JSValue::encode(result ? result : jsUndefined());
1205 }
1206
1207 EncodedJSValue JSC_HOST_CALL functionSetElementRoot(ExecState* exec)
1208 {
1209     JSLockHolder lock(exec);
1210     Element* element = jsDynamicCast<Element*>(exec->argument(0));
1211     Root* root = jsDynamicCast<Root*>(exec->argument(1));
1212     if (element && root)
1213         element->setRoot(exec->vm(), root);
1214     return JSValue::encode(jsUndefined());
1215 }
1216
1217 EncodedJSValue JSC_HOST_CALL functionCreateSimpleObject(ExecState* exec)
1218 {
1219     JSLockHolder lock(exec);
1220     return JSValue::encode(SimpleObject::create(exec->vm(), exec->lexicalGlobalObject()));
1221 }
1222
1223 EncodedJSValue JSC_HOST_CALL functionGetHiddenValue(ExecState* exec)
1224 {
1225     JSLockHolder lock(exec);
1226     SimpleObject* simpleObject = jsCast<SimpleObject*>(exec->argument(0).asCell());
1227     return JSValue::encode(simpleObject->hiddenValue());
1228 }
1229
1230 EncodedJSValue JSC_HOST_CALL functionSetHiddenValue(ExecState* exec)
1231 {
1232     JSLockHolder lock(exec);
1233     SimpleObject* simpleObject = jsCast<SimpleObject*>(exec->argument(0).asCell());
1234     JSValue value = exec->argument(1);
1235     simpleObject->setHiddenValue(exec->vm(), value);
1236     return JSValue::encode(jsUndefined());
1237 }
1238
1239 EncodedJSValue JSC_HOST_CALL functionCreateProxy(ExecState* exec)
1240 {
1241     JSLockHolder lock(exec);
1242     JSValue target = exec->argument(0);
1243     if (!target.isObject())
1244         return JSValue::encode(jsUndefined());
1245     JSObject* jsTarget = asObject(target.asCell());
1246     Structure* structure = JSProxy::createStructure(exec->vm(), exec->lexicalGlobalObject(), jsTarget->getPrototypeDirect(), ImpureProxyType);
1247     JSProxy* proxy = JSProxy::create(exec->vm(), structure, jsTarget);
1248     return JSValue::encode(proxy);
1249 }
1250
1251 EncodedJSValue JSC_HOST_CALL functionCreateRuntimeArray(ExecState* exec)
1252 {
1253     JSLockHolder lock(exec);
1254     RuntimeArray* array = RuntimeArray::create(exec);
1255     return JSValue::encode(array);
1256 }
1257
1258 EncodedJSValue JSC_HOST_CALL functionCreateImpureGetter(ExecState* exec)
1259 {
1260     JSLockHolder lock(exec);
1261     JSValue target = exec->argument(0);
1262     JSObject* delegate = nullptr;
1263     if (target.isObject())
1264         delegate = asObject(target.asCell());
1265     Structure* structure = ImpureGetter::createStructure(exec->vm(), exec->lexicalGlobalObject(), jsNull());
1266     ImpureGetter* result = ImpureGetter::create(exec->vm(), structure, delegate);
1267     return JSValue::encode(result);
1268 }
1269
1270 EncodedJSValue JSC_HOST_CALL functionCreateCustomGetterObject(ExecState* exec)
1271 {
1272     JSLockHolder lock(exec);
1273     Structure* structure = CustomGetter::createStructure(exec->vm(), exec->lexicalGlobalObject(), jsNull());
1274     CustomGetter* result = CustomGetter::create(exec->vm(), structure);
1275     return JSValue::encode(result);
1276 }
1277
1278 EncodedJSValue JSC_HOST_CALL functionSetImpureGetterDelegate(ExecState* exec)
1279 {
1280     JSLockHolder lock(exec);
1281     JSValue base = exec->argument(0);
1282     if (!base.isObject())
1283         return JSValue::encode(jsUndefined());
1284     JSValue delegate = exec->argument(1);
1285     if (!delegate.isObject())
1286         return JSValue::encode(jsUndefined());
1287     ImpureGetter* impureGetter = jsCast<ImpureGetter*>(asObject(base.asCell()));
1288     impureGetter->setDelegate(exec->vm(), asObject(delegate.asCell()));
1289     return JSValue::encode(jsUndefined());
1290 }
1291
1292 EncodedJSValue JSC_HOST_CALL functionGCAndSweep(ExecState* exec)
1293 {
1294     JSLockHolder lock(exec);
1295     exec->heap()->collectAllGarbage();
1296     return JSValue::encode(jsNumber(exec->heap()->sizeAfterLastFullCollection()));
1297 }
1298
1299 EncodedJSValue JSC_HOST_CALL functionFullGC(ExecState* exec)
1300 {
1301     JSLockHolder lock(exec);
1302     exec->heap()->collect(FullCollection);
1303     return JSValue::encode(jsNumber(exec->heap()->sizeAfterLastFullCollection()));
1304 }
1305
1306 EncodedJSValue JSC_HOST_CALL functionEdenGC(ExecState* exec)
1307 {
1308     JSLockHolder lock(exec);
1309     exec->heap()->collect(EdenCollection);
1310     return JSValue::encode(jsNumber(exec->heap()->sizeAfterLastEdenCollection()));
1311 }
1312
1313 EncodedJSValue JSC_HOST_CALL functionForceGCSlowPaths(ExecState*)
1314 {
1315     // It's best for this to be the first thing called in the 
1316     // JS program so the option is set to true before we JIT.
1317     Options::forceGCSlowPaths() = true;
1318     return JSValue::encode(jsUndefined());
1319 }
1320
1321 EncodedJSValue JSC_HOST_CALL functionHeapSize(ExecState* exec)
1322 {
1323     JSLockHolder lock(exec);
1324     return JSValue::encode(jsNumber(exec->heap()->size()));
1325 }
1326
1327 // This function is not generally very helpful in 64-bit code as the tag and payload
1328 // share a register. But in 32-bit JITed code the tag may not be checked if an
1329 // optimization removes type checking requirements, such as in ===.
1330 EncodedJSValue JSC_HOST_CALL functionAddressOf(ExecState* exec)
1331 {
1332     JSValue value = exec->argument(0);
1333     if (!value.isCell())
1334         return JSValue::encode(jsUndefined());
1335     // Need to cast to uint64_t so bitwise_cast will play along.
1336     uint64_t asNumber = reinterpret_cast<uint64_t>(value.asCell());
1337     EncodedJSValue returnValue = JSValue::encode(jsNumber(bitwise_cast<double>(asNumber)));
1338     return returnValue;
1339 }
1340
1341 static EncodedJSValue JSC_HOST_CALL functionGetGetterSetter(ExecState* exec)
1342 {
1343     JSValue value = exec->argument(0);
1344     if (!value.isObject())
1345         return JSValue::encode(jsUndefined());
1346
1347     JSValue property = exec->argument(1);
1348     if (!property.isString())
1349         return JSValue::encode(jsUndefined());
1350
1351     Identifier ident = Identifier::fromString(&exec->vm(), property.toString(exec)->value(exec));
1352
1353     PropertySlot slot(value, PropertySlot::InternalMethodType::VMInquiry);
1354     value.getPropertySlot(exec, ident, slot);
1355
1356     JSValue result;
1357     if (slot.isCacheableGetter())
1358         result = slot.getterSetter();
1359     else
1360         result = jsNull();
1361
1362     return JSValue::encode(result);
1363 }
1364
1365 EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*)
1366 {
1367     // We need this function for compatibility with the Mozilla JS tests but for now
1368     // we don't actually do any version-specific handling
1369     return JSValue::encode(jsUndefined());
1370 }
1371
1372 EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec)
1373 {
1374     String fileName = exec->argument(0).toString(exec)->value(exec);
1375     if (exec->hadException())
1376         return JSValue::encode(jsUndefined());
1377     Vector<char> script;
1378     if (!fetchScriptFromLocalFileSystem(fileName, script))
1379         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1380
1381     GlobalObject* globalObject = GlobalObject::create(exec->vm(), GlobalObject::createStructure(exec->vm(), jsNull()), Vector<String>());
1382
1383     JSArray* array = constructEmptyArray(globalObject->globalExec(), 0);
1384     for (unsigned i = 1; i < exec->argumentCount(); ++i)
1385         array->putDirectIndex(globalObject->globalExec(), i - 1, exec->uncheckedArgument(i));
1386     globalObject->putDirect(
1387         exec->vm(), Identifier::fromString(globalObject->globalExec(), "arguments"), array);
1388
1389     NakedPtr<Exception> exception;
1390     StopWatch stopWatch;
1391     stopWatch.start();
1392     evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), exception);
1393     stopWatch.stop();
1394
1395     if (exception) {
1396         exec->vm().throwException(globalObject->globalExec(), exception);
1397         return JSValue::encode(jsUndefined());
1398     }
1399     
1400     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1401 }
1402
1403 EncodedJSValue JSC_HOST_CALL functionLoad(ExecState* exec)
1404 {
1405     String fileName = exec->argument(0).toString(exec)->value(exec);
1406     if (exec->hadException())
1407         return JSValue::encode(jsUndefined());
1408     Vector<char> script;
1409     if (!fetchScriptFromLocalFileSystem(fileName, script))
1410         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1411
1412     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1413     
1414     NakedPtr<Exception> evaluationException;
1415     JSValue result = evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), evaluationException);
1416     if (evaluationException)
1417         exec->vm().throwException(exec, evaluationException);
1418     return JSValue::encode(result);
1419 }
1420
1421 EncodedJSValue JSC_HOST_CALL functionReadFile(ExecState* exec)
1422 {
1423     String fileName = exec->argument(0).toString(exec)->value(exec);
1424     if (exec->hadException())
1425         return JSValue::encode(jsUndefined());
1426     Vector<char> script;
1427     if (!fillBufferWithContentsOfFile(fileName, script))
1428         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1429
1430     return JSValue::encode(jsString(exec, stringFromUTF(script)));
1431 }
1432
1433 EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec)
1434 {
1435     String fileName = exec->argument(0).toString(exec)->value(exec);
1436     if (exec->hadException())
1437         return JSValue::encode(jsUndefined());
1438     Vector<char> script;
1439     if (!fetchScriptFromLocalFileSystem(fileName, script))
1440         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1441
1442     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1443
1444     StopWatch stopWatch;
1445     stopWatch.start();
1446
1447     JSValue syntaxException;
1448     bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script, fileName), &syntaxException);
1449     stopWatch.stop();
1450
1451     if (!validSyntax)
1452         exec->vm().throwException(exec, syntaxException);
1453     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1454 }
1455
1456 #if ENABLE(SAMPLING_FLAGS)
1457 EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState* exec)
1458 {
1459     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1460         unsigned flag = static_cast<unsigned>(exec->uncheckedArgument(i).toNumber(exec));
1461         if ((flag >= 1) && (flag <= 32))
1462             SamplingFlags::setFlag(flag);
1463     }
1464     return JSValue::encode(jsNull());
1465 }
1466
1467 EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec)
1468 {
1469     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1470         unsigned flag = static_cast<unsigned>(exec->uncheckedArgument(i).toNumber(exec));
1471         if ((flag >= 1) && (flag <= 32))
1472             SamplingFlags::clearFlag(flag);
1473     }
1474     return JSValue::encode(jsNull());
1475 }
1476 #endif
1477
1478 EncodedJSValue JSC_HOST_CALL functionShadowChickenFunctionsOnStack(ExecState* exec)
1479 {
1480     return JSValue::encode(exec->vm().shadowChicken().functionsOnStack(exec));
1481 }
1482
1483 EncodedJSValue JSC_HOST_CALL functionReadline(ExecState* exec)
1484 {
1485     Vector<char, 256> line;
1486     int c;
1487     while ((c = getchar()) != EOF) {
1488         // FIXME: Should we also break on \r? 
1489         if (c == '\n')
1490             break;
1491         line.append(c);
1492     }
1493     line.append('\0');
1494     return JSValue::encode(jsString(exec, line.data()));
1495 }
1496
1497 EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*)
1498 {
1499     return JSValue::encode(jsNumber(currentTime()));
1500 }
1501
1502 EncodedJSValue JSC_HOST_CALL functionNeverInlineFunction(ExecState* exec)
1503 {
1504     return JSValue::encode(setNeverInline(exec));
1505 }
1506
1507 EncodedJSValue JSC_HOST_CALL functionNoDFG(ExecState* exec)
1508 {
1509     return JSValue::encode(setNeverOptimize(exec));
1510 }
1511
1512 EncodedJSValue JSC_HOST_CALL functionOptimizeNextInvocation(ExecState* exec)
1513 {
1514     return JSValue::encode(optimizeNextInvocation(exec));
1515 }
1516
1517 EncodedJSValue JSC_HOST_CALL functionNumberOfDFGCompiles(ExecState* exec)
1518 {
1519     return JSValue::encode(numberOfDFGCompiles(exec));
1520 }
1521
1522 EncodedJSValue JSC_HOST_CALL functionReoptimizationRetryCount(ExecState* exec)
1523 {
1524     if (exec->argumentCount() < 1)
1525         return JSValue::encode(jsUndefined());
1526     
1527     CodeBlock* block = getSomeBaselineCodeBlockForFunction(exec->argument(0));
1528     if (!block)
1529         return JSValue::encode(jsNumber(0));
1530     
1531     return JSValue::encode(jsNumber(block->reoptimizationRetryCounter()));
1532 }
1533
1534 EncodedJSValue JSC_HOST_CALL functionTransferArrayBuffer(ExecState* exec)
1535 {
1536     if (exec->argumentCount() < 1)
1537         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Not enough arguments"))));
1538     
1539     JSArrayBuffer* buffer = jsDynamicCast<JSArrayBuffer*>(exec->argument(0));
1540     if (!buffer)
1541         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Expected an array buffer"))));
1542     
1543     ArrayBufferContents dummyContents;
1544     buffer->impl()->transfer(dummyContents);
1545     
1546     return JSValue::encode(jsUndefined());
1547 }
1548
1549 EncodedJSValue JSC_HOST_CALL functionFailNextNewCodeBlock(ExecState* exec)
1550 {
1551     exec->vm().setFailNextNewCodeBlock();
1552     return JSValue::encode(jsUndefined());
1553 }
1554
1555 EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*)
1556 {
1557     jscExit(EXIT_SUCCESS);
1558
1559 #if COMPILER(MSVC)
1560     // Without this, Visual Studio will complain that this method does not return a value.
1561     return JSValue::encode(jsUndefined());
1562 #endif
1563 }
1564
1565 EncodedJSValue JSC_HOST_CALL functionAbort(ExecState*)
1566 {
1567     CRASH();
1568 }
1569
1570 EncodedJSValue JSC_HOST_CALL functionFalse1(ExecState*) { return JSValue::encode(jsBoolean(false)); }
1571 EncodedJSValue JSC_HOST_CALL functionFalse2(ExecState*) { return JSValue::encode(jsBoolean(false)); }
1572
1573 EncodedJSValue JSC_HOST_CALL functionUndefined1(ExecState*) { return JSValue::encode(jsUndefined()); }
1574 EncodedJSValue JSC_HOST_CALL functionUndefined2(ExecState*) { return JSValue::encode(jsUndefined()); }
1575 EncodedJSValue JSC_HOST_CALL functionIsInt32(ExecState* exec)
1576 {
1577     for (size_t i = 0; i < exec->argumentCount(); ++i) {
1578         if (!exec->argument(i).isInt32())
1579             return JSValue::encode(jsBoolean(false));
1580     }
1581     return JSValue::encode(jsBoolean(true));
1582 }
1583
1584 EncodedJSValue JSC_HOST_CALL functionIdentity(ExecState* exec) { return JSValue::encode(exec->argument(0)); }
1585
1586 EncodedJSValue JSC_HOST_CALL functionEffectful42(ExecState*)
1587 {
1588     return JSValue::encode(jsNumber(42));
1589 }
1590
1591 EncodedJSValue JSC_HOST_CALL functionMakeMasquerader(ExecState* exec)
1592 {
1593     return JSValue::encode(Masquerader::create(exec->vm(), exec->lexicalGlobalObject()));
1594 }
1595
1596 EncodedJSValue JSC_HOST_CALL functionHasCustomProperties(ExecState* exec)
1597 {
1598     JSValue value = exec->argument(0);
1599     if (value.isObject())
1600         return JSValue::encode(jsBoolean(asObject(value)->hasCustomProperties()));
1601     return JSValue::encode(jsBoolean(false));
1602 }
1603
1604 EncodedJSValue JSC_HOST_CALL functionDumpTypesForAllVariables(ExecState* exec)
1605 {
1606     exec->vm().dumpTypeProfilerData();
1607     return JSValue::encode(jsUndefined());
1608 }
1609
1610 EncodedJSValue JSC_HOST_CALL functionFindTypeForExpression(ExecState* exec)
1611 {
1612     RELEASE_ASSERT(exec->vm().typeProfiler());
1613     exec->vm().typeProfilerLog()->processLogEntries(ASCIILiteral("jsc Testing API: functionFindTypeForExpression"));
1614
1615     JSValue functionValue = exec->argument(0);
1616     RELEASE_ASSERT(functionValue.isFunction());
1617     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1618
1619     RELEASE_ASSERT(exec->argument(1).isString());
1620     String substring = exec->argument(1).getString(exec);
1621     String sourceCodeText = executable->source().view().toString();
1622     unsigned offset = static_cast<unsigned>(sourceCodeText.find(substring) + executable->source().startOffset());
1623     
1624     String jsonString = exec->vm().typeProfiler()->typeInformationForExpressionAtOffset(TypeProfilerSearchDescriptorNormal, offset, executable->sourceID(), exec->vm());
1625     return JSValue::encode(JSONParse(exec, jsonString));
1626 }
1627
1628 EncodedJSValue JSC_HOST_CALL functionReturnTypeFor(ExecState* exec)
1629 {
1630     RELEASE_ASSERT(exec->vm().typeProfiler());
1631     exec->vm().typeProfilerLog()->processLogEntries(ASCIILiteral("jsc Testing API: functionReturnTypeFor"));
1632
1633     JSValue functionValue = exec->argument(0);
1634     RELEASE_ASSERT(functionValue.isFunction());
1635     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1636
1637     unsigned offset = executable->typeProfilingStartOffset();
1638     String jsonString = exec->vm().typeProfiler()->typeInformationForExpressionAtOffset(TypeProfilerSearchDescriptorFunctionReturn, offset, executable->sourceID(), exec->vm());
1639     return JSValue::encode(JSONParse(exec, jsonString));
1640 }
1641
1642 EncodedJSValue JSC_HOST_CALL functionDumpBasicBlockExecutionRanges(ExecState* exec)
1643 {
1644     RELEASE_ASSERT(exec->vm().controlFlowProfiler());
1645     exec->vm().controlFlowProfiler()->dumpData();
1646     return JSValue::encode(jsUndefined());
1647 }
1648
1649 EncodedJSValue JSC_HOST_CALL functionHasBasicBlockExecuted(ExecState* exec)
1650 {
1651     RELEASE_ASSERT(exec->vm().controlFlowProfiler());
1652
1653     JSValue functionValue = exec->argument(0);
1654     RELEASE_ASSERT(functionValue.isFunction());
1655     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1656
1657     RELEASE_ASSERT(exec->argument(1).isString());
1658     String substring = exec->argument(1).getString(exec);
1659     String sourceCodeText = executable->source().view().toString();
1660     RELEASE_ASSERT(sourceCodeText.contains(substring));
1661     int offset = sourceCodeText.find(substring) + executable->source().startOffset();
1662     
1663     bool hasExecuted = exec->vm().controlFlowProfiler()->hasBasicBlockAtTextOffsetBeenExecuted(offset, executable->sourceID(), exec->vm());
1664     return JSValue::encode(jsBoolean(hasExecuted));
1665 }
1666
1667 EncodedJSValue JSC_HOST_CALL functionBasicBlockExecutionCount(ExecState* exec)
1668 {
1669     RELEASE_ASSERT(exec->vm().controlFlowProfiler());
1670
1671     JSValue functionValue = exec->argument(0);
1672     RELEASE_ASSERT(functionValue.isFunction());
1673     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1674
1675     RELEASE_ASSERT(exec->argument(1).isString());
1676     String substring = exec->argument(1).getString(exec);
1677     String sourceCodeText = executable->source().view().toString();
1678     RELEASE_ASSERT(sourceCodeText.contains(substring));
1679     int offset = sourceCodeText.find(substring) + executable->source().startOffset();
1680     
1681     size_t executionCount = exec->vm().controlFlowProfiler()->basicBlockExecutionCountAtTextOffset(offset, executable->sourceID(), exec->vm());
1682     return JSValue::encode(JSValue(executionCount));
1683 }
1684
1685 EncodedJSValue JSC_HOST_CALL functionEnableExceptionFuzz(ExecState*)
1686 {
1687     Options::useExceptionFuzz() = true;
1688     return JSValue::encode(jsUndefined());
1689 }
1690
1691 EncodedJSValue JSC_HOST_CALL functionDrainMicrotasks(ExecState* exec)
1692 {
1693     exec->vm().drainMicrotasks();
1694     return JSValue::encode(jsUndefined());
1695 }
1696
1697 EncodedJSValue JSC_HOST_CALL functionIs32BitPlatform(ExecState*)
1698 {
1699 #if USE(JSVALUE64)
1700     return JSValue::encode(JSValue(JSC::JSValue::JSFalse));
1701 #else
1702     return JSValue::encode(JSValue(JSC::JSValue::JSTrue));
1703 #endif
1704 }
1705
1706 #if ENABLE(WEBASSEMBLY)
1707 EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState* exec)
1708 {
1709     String fileName = exec->argument(0).toString(exec)->value(exec);
1710     if (exec->hadException())
1711         return JSValue::encode(jsUndefined());
1712     Vector<char> buffer;
1713     if (!fillBufferWithContentsOfFile(fileName, buffer))
1714         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1715     RefPtr<WebAssemblySourceProvider> sourceProvider = WebAssemblySourceProvider::create(reinterpret_cast<Vector<uint8_t>&>(buffer), fileName);
1716     SourceCode source(sourceProvider);
1717     JSObject* imports = exec->argument(1).getObject();
1718     JSArrayBuffer* arrayBuffer = jsDynamicCast<JSArrayBuffer*>(exec->argument(2));
1719
1720     String errorMessage;
1721     JSWASMModule* module = parseWebAssembly(exec, source, imports, arrayBuffer, errorMessage);
1722     if (!module)
1723         return JSValue::encode(exec->vm().throwException(exec, createSyntaxError(exec, errorMessage)));
1724     return JSValue::encode(module);
1725 }
1726 #endif
1727
1728 EncodedJSValue JSC_HOST_CALL functionLoadModule(ExecState* exec)
1729 {
1730     String fileName = exec->argument(0).toString(exec)->value(exec);
1731     if (exec->hadException())
1732         return JSValue::encode(jsUndefined());
1733     Vector<char> script;
1734     if (!fetchScriptFromLocalFileSystem(fileName, script))
1735         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1736
1737     JSInternalPromise* promise = loadAndEvaluateModule(exec, fileName);
1738     if (exec->hadException())
1739         return JSValue::encode(jsUndefined());
1740
1741     JSValue error;
1742     JSFunction* errorHandler = JSNativeStdFunction::create(exec->vm(), exec->lexicalGlobalObject(), 1, String(), [&](ExecState* exec) {
1743         error = exec->argument(0);
1744         return JSValue::encode(jsUndefined());
1745     });
1746
1747     promise->then(exec, nullptr, errorHandler);
1748     exec->vm().drainMicrotasks();
1749     if (error)
1750         return JSValue::encode(exec->vm().throwException(exec, error));
1751     return JSValue::encode(jsUndefined());
1752 }
1753
1754 EncodedJSValue JSC_HOST_CALL functionCreateBuiltin(ExecState* exec)
1755 {
1756     if (exec->argumentCount() < 1 || !exec->argument(0).isString())
1757         return JSValue::encode(jsUndefined());
1758
1759     String functionText = exec->argument(0).toString(exec)->value(exec);
1760     if (exec->hadException())
1761         return JSValue::encode(JSValue());
1762
1763     VM& vm = exec->vm();
1764     const SourceCode& source = makeSource(functionText);
1765     JSFunction* func = JSFunction::createBuiltinFunction(vm, BuiltinExecutables::createExecutable(vm, source, Identifier::fromString(&vm, "foo"), ConstructorKind::None, ConstructAbility::CannotConstruct)->link(vm, source), exec->lexicalGlobalObject());
1766
1767     return JSValue::encode(func);
1768 }
1769
1770 EncodedJSValue JSC_HOST_CALL functionCheckModuleSyntax(ExecState* exec)
1771 {
1772     String source = exec->argument(0).toString(exec)->value(exec);
1773     if (exec->hadException())
1774         return JSValue::encode(jsUndefined());
1775
1776     StopWatch stopWatch;
1777     stopWatch.start();
1778
1779     ParserError error;
1780     bool validSyntax = checkModuleSyntax(exec, makeSource(source), error);
1781     stopWatch.stop();
1782
1783     if (!validSyntax)
1784         exec->vm().throwException(exec, jsNontrivialString(exec, toString("SyntaxError: ", error.message(), ":", error.line())));
1785     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1786 }
1787
1788 EncodedJSValue JSC_HOST_CALL functionPlatformSupportsSamplingProfiler(ExecState*)
1789 {
1790 #if ENABLE(SAMPLING_PROFILER)
1791     return JSValue::encode(JSValue(JSC::JSValue::JSTrue));
1792 #else
1793     return JSValue::encode(JSValue(JSC::JSValue::JSFalse));
1794 #endif
1795 }
1796
1797 EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshot(ExecState* exec)
1798 {
1799     JSLockHolder lock(exec);
1800
1801     HeapSnapshotBuilder snapshotBuilder(exec->vm().ensureHeapProfiler());
1802     snapshotBuilder.buildSnapshot();
1803
1804     String jsonString = snapshotBuilder.json();
1805     EncodedJSValue result = JSValue::encode(JSONParse(exec, jsonString));
1806     RELEASE_ASSERT(!exec->hadException());
1807     return result;
1808 }
1809
1810 #if ENABLE(SAMPLING_PROFILER)
1811 EncodedJSValue JSC_HOST_CALL functionStartSamplingProfiler(ExecState* exec)
1812 {
1813     exec->vm().ensureSamplingProfiler(WTF::Stopwatch::create());
1814     exec->vm().samplingProfiler()->noticeCurrentThreadAsJSCExecutionThread();
1815     exec->vm().samplingProfiler()->start();
1816     return JSValue::encode(jsUndefined());
1817 }
1818
1819 EncodedJSValue JSC_HOST_CALL functionSamplingProfilerStackTraces(ExecState* exec)
1820 {
1821     RELEASE_ASSERT(exec->vm().samplingProfiler());
1822     String jsonString = exec->vm().samplingProfiler()->stackTracesAsJSON();
1823     EncodedJSValue result = JSValue::encode(JSONParse(exec, jsonString));
1824     RELEASE_ASSERT(!exec->hadException());
1825     return result;
1826 }
1827 #endif // ENABLE(SAMPLING_PROFILER)
1828
1829 // Use SEH for Release builds only to get rid of the crash report dialog
1830 // (luckily the same tests fail in Release and Debug builds so far). Need to
1831 // be in a separate main function because the jscmain function requires object
1832 // unwinding.
1833
1834 #if COMPILER(MSVC) && !defined(_DEBUG)
1835 #define TRY       __try {
1836 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
1837 #else
1838 #define TRY
1839 #define EXCEPT(x)
1840 #endif
1841
1842 int jscmain(int argc, char** argv);
1843
1844 static double s_desiredTimeout;
1845
1846 static NO_RETURN_DUE_TO_CRASH void timeoutThreadMain(void*)
1847 {
1848     auto timeout = std::chrono::microseconds(static_cast<std::chrono::microseconds::rep>(s_desiredTimeout * 1000000));
1849     std::this_thread::sleep_for(timeout);
1850     
1851     dataLog("Timed out after ", s_desiredTimeout, " seconds!\n");
1852     CRASH();
1853 }
1854
1855 int main(int argc, char** argv)
1856 {
1857 #if PLATFORM(IOS) && CPU(ARM_THUMB2)
1858     // Enabled IEEE754 denormal support.
1859     fenv_t env;
1860     fegetenv( &env );
1861     env.__fpscr &= ~0x01000000u;
1862     fesetenv( &env );
1863 #endif
1864
1865 #if OS(WINDOWS)
1866     // Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for
1867     // testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the
1868     // error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.
1869     ::SetErrorMode(0);
1870
1871 #if defined(_DEBUG)
1872     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
1873     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
1874     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
1875     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
1876     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
1877     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
1878 #endif
1879
1880     timeBeginPeriod(1);
1881 #endif
1882
1883 #if PLATFORM(EFL)
1884     ecore_init();
1885 #endif
1886
1887     // Need to initialize WTF threading before we start any threads. Cannot initialize JSC
1888     // threading yet, since that would do somethings that we'd like to defer until after we
1889     // have a chance to parse options.
1890     WTF::initializeThreading();
1891
1892     if (char* timeoutString = getenv("JSCTEST_timeout")) {
1893         if (sscanf(timeoutString, "%lf", &s_desiredTimeout) != 1) {
1894             dataLog(
1895                 "WARNING: timeout string is malformed, got ", timeoutString,
1896                 " but expected a number. Not using a timeout.\n");
1897         } else
1898             createThread(timeoutThreadMain, 0, "jsc Timeout Thread");
1899     }
1900
1901 #if PLATFORM(IOS)
1902     Options::crashIfCantAllocateJITMemory() = true;
1903 #endif
1904
1905     // We can't use destructors in the following code because it uses Windows
1906     // Structured Exception Handling
1907     int res = 0;
1908     TRY
1909         res = jscmain(argc, argv);
1910     EXCEPT(res = 3)
1911     if (Options::logHeapStatisticsAtExit())
1912         HeapStatistics::reportSuccess();
1913
1914 #if PLATFORM(EFL)
1915     ecore_shutdown();
1916 #endif
1917
1918     jscExit(res);
1919 }
1920
1921 static void dumpException(GlobalObject* globalObject, JSValue exception)
1922 {
1923     printf("Exception: %s\n", exception.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
1924     Identifier stackID = Identifier::fromString(globalObject->globalExec(), "stack");
1925     JSValue stackValue = exception.get(globalObject->globalExec(), stackID);
1926     if (!stackValue.isUndefinedOrNull())
1927         printf("%s\n", stackValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
1928 }
1929
1930 static void dumpException(GlobalObject* globalObject, NakedPtr<Exception> evaluationException)
1931 {
1932     if (evaluationException)
1933         dumpException(globalObject, evaluationException->value());
1934 }
1935
1936 static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scripts, bool dump, bool module)
1937 {
1938     String fileName;
1939     Vector<char> scriptBuffer;
1940
1941     if (dump)
1942         JSC::Options::dumpGeneratedBytecodes() = true;
1943
1944     VM& vm = globalObject->vm();
1945     bool success = true;
1946
1947     JSFunction* errorHandler = JSNativeStdFunction::create(vm, globalObject, 1, String(), [&](ExecState* exec) {
1948         success = false;
1949         dumpException(globalObject, exec->argument(0));
1950         return JSValue::encode(jsUndefined());
1951     });
1952
1953 #if ENABLE(SAMPLING_FLAGS)
1954     SamplingFlags::start();
1955 #endif
1956
1957     for (size_t i = 0; i < scripts.size(); i++) {
1958         JSInternalPromise* promise = nullptr;
1959         if (scripts[i].isFile) {
1960             fileName = scripts[i].argument;
1961             if (module)
1962                 promise = loadAndEvaluateModule(globalObject->globalExec(), fileName);
1963             else {
1964                 if (!fetchScriptFromLocalFileSystem(fileName, scriptBuffer))
1965                     return false; // fail early so we can catch missing files
1966             }
1967         } else {
1968             size_t commandLineLength = strlen(scripts[i].argument);
1969             scriptBuffer.resize(commandLineLength);
1970             std::copy(scripts[i].argument, scripts[i].argument + commandLineLength, scriptBuffer.begin());
1971             fileName = ASCIILiteral("[Command Line]");
1972         }
1973
1974         if (module) {
1975             if (!promise)
1976                 promise = loadAndEvaluateModule(globalObject->globalExec(), jscSource(scriptBuffer, fileName));
1977             globalObject->globalExec()->clearException();
1978             promise->then(globalObject->globalExec(), nullptr, errorHandler);
1979             globalObject->vm().drainMicrotasks();
1980         } else {
1981             NakedPtr<Exception> evaluationException;
1982             JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(scriptBuffer, fileName), JSValue(), evaluationException);
1983             success = success && !evaluationException;
1984             if (dump && !evaluationException)
1985                 printf("End: %s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
1986             dumpException(globalObject, evaluationException);
1987         }
1988
1989         globalObject->globalExec()->clearException();
1990     }
1991
1992 #if ENABLE(REGEXP_TRACING)
1993     vm.dumpRegExpTrace();
1994 #endif
1995     return success;
1996 }
1997
1998 #define RUNNING_FROM_XCODE 0
1999
2000 static void runInteractive(GlobalObject* globalObject)
2001 {
2002     String interpreterName(ASCIILiteral("Interpreter"));
2003     
2004     bool shouldQuit = false;
2005     while (!shouldQuit) {
2006 #if HAVE(READLINE) && !RUNNING_FROM_XCODE
2007         ParserError error;
2008         String source;
2009         do {
2010             error = ParserError();
2011             char* line = readline(source.isEmpty() ? interactivePrompt : "... ");
2012             shouldQuit = !line;
2013             if (!line)
2014                 break;
2015             source = source + line;
2016             source = source + '\n';
2017             checkSyntax(globalObject->vm(), makeSource(source, interpreterName), error);
2018             if (!line[0])
2019                 break;
2020             add_history(line);
2021         } while (error.syntaxErrorType() == ParserError::SyntaxErrorRecoverable);
2022         
2023         if (error.isValid()) {
2024             printf("%s:%d\n", error.message().utf8().data(), error.line());
2025             continue;
2026         }
2027         
2028         
2029         NakedPtr<Exception> evaluationException;
2030         JSValue returnValue = evaluate(globalObject->globalExec(), makeSource(source, interpreterName), JSValue(), evaluationException);
2031 #else
2032         printf("%s", interactivePrompt);
2033         Vector<char, 256> line;
2034         int c;
2035         while ((c = getchar()) != EOF) {
2036             // FIXME: Should we also break on \r? 
2037             if (c == '\n')
2038                 break;
2039             line.append(c);
2040         }
2041         if (line.isEmpty())
2042             break;
2043
2044         NakedPtr<Exception> evaluationException;
2045         JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(line, interpreterName), JSValue(), evaluationException);
2046 #endif
2047         if (evaluationException)
2048             printf("Exception: %s\n", evaluationException->value().toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
2049         else
2050             printf("%s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
2051
2052         globalObject->globalExec()->clearException();
2053         globalObject->vm().drainMicrotasks();
2054     }
2055     printf("\n");
2056 }
2057
2058 static NO_RETURN void printUsageStatement(bool help = false)
2059 {
2060     fprintf(stderr, "Usage: jsc [options] [files] [-- arguments]\n");
2061     fprintf(stderr, "  -d         Dumps bytecode (debug builds only)\n");
2062     fprintf(stderr, "  -e         Evaluate argument as script code\n");
2063     fprintf(stderr, "  -f         Specifies a source file (deprecated)\n");
2064     fprintf(stderr, "  -h|--help  Prints this help message\n");
2065     fprintf(stderr, "  -i         Enables interactive mode (default if no files are specified)\n");
2066     fprintf(stderr, "  -m         Execute as a module\n");
2067 #if HAVE(SIGNAL_H)
2068     fprintf(stderr, "  -s         Installs signal handlers that exit on a crash (Unix platforms only)\n");
2069 #endif
2070     fprintf(stderr, "  -p <file>  Outputs profiling data to a file\n");
2071     fprintf(stderr, "  -x         Output exit code before terminating\n");
2072     fprintf(stderr, "\n");
2073     fprintf(stderr, "  --options                  Dumps all JSC VM options and exits\n");
2074     fprintf(stderr, "  --dumpOptions              Dumps all JSC VM options before continuing\n");
2075     fprintf(stderr, "  --<jsc VM option>=<value>  Sets the specified JSC VM option\n");
2076     fprintf(stderr, "\n");
2077
2078     jscExit(help ? EXIT_SUCCESS : EXIT_FAILURE);
2079 }
2080
2081 void CommandLine::parseArguments(int argc, char** argv)
2082 {
2083     Options::initialize();
2084     
2085     int i = 1;
2086     bool needToDumpOptions = false;
2087     bool needToExit = false;
2088
2089     bool hasBadJSCOptions = false;
2090     for (; i < argc; ++i) {
2091         const char* arg = argv[i];
2092         if (!strcmp(arg, "-f")) {
2093             if (++i == argc)
2094                 printUsageStatement();
2095             m_scripts.append(Script(true, argv[i]));
2096             continue;
2097         }
2098         if (!strcmp(arg, "-e")) {
2099             if (++i == argc)
2100                 printUsageStatement();
2101             m_scripts.append(Script(false, argv[i]));
2102             continue;
2103         }
2104         if (!strcmp(arg, "-i")) {
2105             m_interactive = true;
2106             continue;
2107         }
2108         if (!strcmp(arg, "-d")) {
2109             m_dump = true;
2110             continue;
2111         }
2112         if (!strcmp(arg, "-p")) {
2113             if (++i == argc)
2114                 printUsageStatement();
2115             m_profile = true;
2116             m_profilerOutput = argv[i];
2117             continue;
2118         }
2119         if (!strcmp(arg, "-m")) {
2120             m_module = true;
2121             continue;
2122         }
2123         if (!strcmp(arg, "-s")) {
2124 #if HAVE(SIGNAL_H)
2125             signal(SIGILL, _exit);
2126             signal(SIGFPE, _exit);
2127             signal(SIGBUS, _exit);
2128             signal(SIGSEGV, _exit);
2129 #endif
2130             continue;
2131         }
2132         if (!strcmp(arg, "-x")) {
2133             m_exitCode = true;
2134             continue;
2135         }
2136         if (!strcmp(arg, "--")) {
2137             ++i;
2138             break;
2139         }
2140         if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
2141             printUsageStatement(true);
2142
2143         if (!strcmp(arg, "--options")) {
2144             needToDumpOptions = true;
2145             needToExit = true;
2146             continue;
2147         }
2148         if (!strcmp(arg, "--dumpOptions")) {
2149             needToDumpOptions = true;
2150             continue;
2151         }
2152
2153         // See if the -- option is a JSC VM option.
2154         if (strstr(arg, "--") == arg) {
2155             if (!JSC::Options::setOption(&arg[2])) {
2156                 hasBadJSCOptions = true;
2157                 dataLog("ERROR: invalid option: ", arg, "\n");
2158             }
2159             continue;
2160         }
2161
2162         // This arg is not recognized by the VM nor by jsc. Pass it on to the
2163         // script.
2164         m_scripts.append(Script(true, argv[i]));
2165     }
2166
2167     if (hasBadJSCOptions && JSC::Options::validateOptions())
2168         CRASH();
2169
2170     if (m_scripts.isEmpty())
2171         m_interactive = true;
2172
2173     for (; i < argc; ++i)
2174         m_arguments.append(argv[i]);
2175
2176     if (needToDumpOptions)
2177         JSC::Options::dumpAllOptions(stderr, JSC::Options::DumpLevel::Overridden, "All JSC runtime options:");
2178     JSC::Options::ensureOptionsAreCoherent();
2179     if (needToExit)
2180         jscExit(EXIT_SUCCESS);
2181 }
2182
2183 // We make this function no inline so that globalObject won't be on the stack if we do a GC in jscmain.
2184 static int NEVER_INLINE runJSC(VM* vm, CommandLine options)
2185 {
2186     JSLockHolder locker(vm);
2187
2188     int result;
2189     if (options.m_profile && !vm->m_perBytecodeProfiler)
2190         vm->m_perBytecodeProfiler = std::make_unique<Profiler::Database>(*vm);
2191
2192     GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.m_arguments);
2193     bool success = runWithScripts(globalObject, options.m_scripts, options.m_dump, options.m_module);
2194     if (options.m_interactive && success)
2195         runInteractive(globalObject);
2196
2197     result = success ? 0 : 3;
2198
2199     if (options.m_exitCode)
2200         printf("jsc exiting %d\n", result);
2201
2202     if (options.m_profile) {
2203         if (!vm->m_perBytecodeProfiler->save(options.m_profilerOutput.utf8().data()))
2204             fprintf(stderr, "could not save profiler output.\n");
2205     }
2206
2207 #if ENABLE(JIT)
2208     if (Options::useExceptionFuzz())
2209         printf("JSC EXCEPTION FUZZ: encountered %u checks.\n", numberOfExceptionFuzzChecks());
2210     bool fireAtEnabled =
2211     Options::fireExecutableAllocationFuzzAt() || Options::fireExecutableAllocationFuzzAtOrAfter();
2212     if (Options::useExecutableAllocationFuzz() && (!fireAtEnabled || Options::verboseExecutableAllocationFuzz()))
2213         printf("JSC EXECUTABLE ALLOCATION FUZZ: encountered %u checks.\n", numberOfExecutableAllocationFuzzChecks());
2214     if (Options::useOSRExitFuzz()) {
2215         printf("JSC OSR EXIT FUZZ: encountered %u static checks.\n", numberOfStaticOSRExitFuzzChecks());
2216         printf("JSC OSR EXIT FUZZ: encountered %u dynamic checks.\n", numberOfOSRExitFuzzChecks());
2217     }
2218 #endif
2219     auto compileTimeStats = DFG::Plan::compileTimeStats();
2220     Vector<CString> compileTimeKeys;
2221     for (auto& entry : compileTimeStats)
2222         compileTimeKeys.append(entry.key);
2223     std::sort(compileTimeKeys.begin(), compileTimeKeys.end());
2224     for (CString key : compileTimeKeys)
2225         printf("%40s: %.3lf ms\n", key.data(), compileTimeStats.get(key));
2226
2227     return result;
2228 }
2229
2230 int jscmain(int argc, char** argv)
2231 {
2232     // Note that the options parsing can affect VM creation, and thus
2233     // comes first.
2234     CommandLine options(argc, argv);
2235
2236     // Initialize JSC before getting VM.
2237 #if ENABLE(SAMPLING_REGIONS)
2238     WTF::initializeMainThread();
2239 #endif
2240     JSC::initializeThreading();
2241
2242     VM* vm = &VM::create(LargeHeap).leakRef();
2243     int result;
2244     result = runJSC(vm, options);
2245
2246     if (Options::gcAtEnd()) {
2247         // We need to hold the API lock to do a GC.
2248         JSLockHolder locker(vm);
2249         vm->heap.collectAllGarbage();
2250     }
2251
2252     printSuperSamplerState();
2253
2254     return result;
2255 }
2256
2257 #if OS(WINDOWS)
2258 extern "C" __declspec(dllexport) int WINAPI dllLauncherEntryPoint(int argc, const char* argv[])
2259 {
2260     return main(argc, const_cast<char**>(argv));
2261 }
2262 #endif