7eef6b3e5a8e4617fa8b894959a48f42a459c0ea
[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 "BuiltinExecutableCreator.h"
27 #include "ButterflyInlines.h"
28 #include "BytecodeGenerator.h"
29 #include "CodeBlock.h"
30 #include "Completion.h"
31 #include "CopiedSpaceInlines.h"
32 #include "Disassembler.h"
33 #include "Exception.h"
34 #include "ExceptionHelpers.h"
35 #include "GetterSetter.h"
36 #include "HeapProfiler.h"
37 #include "HeapSnapshotBuilder.h"
38 #include "HeapStatistics.h"
39 #include "InitializeThreading.h"
40 #include "Interpreter.h"
41 #include "JIT.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 static bool test262AsyncPassed { false };
534 static bool test262AsyncTest { false };
535
536 ElementHandleOwner* Element::handleOwner()
537 {
538     static ElementHandleOwner* owner = 0;
539     if (!owner)
540         owner = new ElementHandleOwner();
541     return owner;
542 }
543
544 void Element::finishCreation(VM& vm, Root* root)
545 {
546     Base::finishCreation(vm);
547     setRoot(vm, root);
548     m_root->setElement(this);
549 }
550
551 }
552
553 static bool fillBufferWithContentsOfFile(const String& fileName, Vector<char>& buffer);
554
555 static EncodedJSValue JSC_HOST_CALL functionCreateProxy(ExecState*);
556 static EncodedJSValue JSC_HOST_CALL functionCreateRuntimeArray(ExecState*);
557 static EncodedJSValue JSC_HOST_CALL functionCreateImpureGetter(ExecState*);
558 static EncodedJSValue JSC_HOST_CALL functionCreateCustomGetterObject(ExecState*);
559 static EncodedJSValue JSC_HOST_CALL functionCreateBuiltin(ExecState*);
560 static EncodedJSValue JSC_HOST_CALL functionCreateGlobalObject(ExecState*);
561 static EncodedJSValue JSC_HOST_CALL functionSetImpureGetterDelegate(ExecState*);
562
563 static EncodedJSValue JSC_HOST_CALL functionSetElementRoot(ExecState*);
564 static EncodedJSValue JSC_HOST_CALL functionCreateRoot(ExecState*);
565 static EncodedJSValue JSC_HOST_CALL functionCreateElement(ExecState*);
566 static EncodedJSValue JSC_HOST_CALL functionGetElement(ExecState*);
567 static EncodedJSValue JSC_HOST_CALL functionCreateSimpleObject(ExecState*);
568 static EncodedJSValue JSC_HOST_CALL functionGetHiddenValue(ExecState*);
569 static EncodedJSValue JSC_HOST_CALL functionSetHiddenValue(ExecState*);
570 static EncodedJSValue JSC_HOST_CALL functionPrint(ExecState*);
571 static EncodedJSValue JSC_HOST_CALL functionDebug(ExecState*);
572 static EncodedJSValue JSC_HOST_CALL functionDataLogValue(ExecState*);
573 static EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState*);
574 static EncodedJSValue JSC_HOST_CALL functionDescribeArray(ExecState*);
575 static EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState*);
576 static EncodedJSValue JSC_HOST_CALL functionGCAndSweep(ExecState*);
577 static EncodedJSValue JSC_HOST_CALL functionFullGC(ExecState*);
578 static EncodedJSValue JSC_HOST_CALL functionEdenGC(ExecState*);
579 static EncodedJSValue JSC_HOST_CALL functionForceGCSlowPaths(ExecState*);
580 static EncodedJSValue JSC_HOST_CALL functionHeapSize(ExecState*);
581 static EncodedJSValue JSC_HOST_CALL functionAddressOf(ExecState*);
582 static EncodedJSValue JSC_HOST_CALL functionGetGetterSetter(ExecState*);
583 #ifndef NDEBUG
584 static EncodedJSValue JSC_HOST_CALL functionDumpCallFrame(ExecState*);
585 #endif
586 static EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*);
587 static EncodedJSValue JSC_HOST_CALL functionRun(ExecState*);
588 static EncodedJSValue JSC_HOST_CALL functionLoad(ExecState*);
589 static EncodedJSValue JSC_HOST_CALL functionReadFile(ExecState*);
590 static EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState*);
591 static EncodedJSValue JSC_HOST_CALL functionReadline(ExecState*);
592 static EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*);
593 static EncodedJSValue JSC_HOST_CALL functionNeverInlineFunction(ExecState*);
594 static EncodedJSValue JSC_HOST_CALL functionNoDFG(ExecState*);
595 static EncodedJSValue JSC_HOST_CALL functionNoFTL(ExecState*);
596 static EncodedJSValue JSC_HOST_CALL functionOptimizeNextInvocation(ExecState*);
597 static EncodedJSValue JSC_HOST_CALL functionNumberOfDFGCompiles(ExecState*);
598 static EncodedJSValue JSC_HOST_CALL functionReoptimizationRetryCount(ExecState*);
599 static EncodedJSValue JSC_HOST_CALL functionTransferArrayBuffer(ExecState*);
600 static EncodedJSValue JSC_HOST_CALL functionFailNextNewCodeBlock(ExecState*);
601 static NO_RETURN_WITH_VALUE EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*);
602 static NO_RETURN_DUE_TO_CRASH EncodedJSValue JSC_HOST_CALL functionAbort(ExecState*);
603 static EncodedJSValue JSC_HOST_CALL functionFalse1(ExecState*);
604 static EncodedJSValue JSC_HOST_CALL functionFalse2(ExecState*);
605 static EncodedJSValue JSC_HOST_CALL functionUndefined1(ExecState*);
606 static EncodedJSValue JSC_HOST_CALL functionUndefined2(ExecState*);
607 static EncodedJSValue JSC_HOST_CALL functionIsInt32(ExecState*);
608 static EncodedJSValue JSC_HOST_CALL functionEffectful42(ExecState*);
609 static EncodedJSValue JSC_HOST_CALL functionIdentity(ExecState*);
610 static EncodedJSValue JSC_HOST_CALL functionMakeMasquerader(ExecState*);
611 static EncodedJSValue JSC_HOST_CALL functionHasCustomProperties(ExecState*);
612 static EncodedJSValue JSC_HOST_CALL functionDumpTypesForAllVariables(ExecState*);
613 static EncodedJSValue JSC_HOST_CALL functionFindTypeForExpression(ExecState*);
614 static EncodedJSValue JSC_HOST_CALL functionReturnTypeFor(ExecState*);
615 static EncodedJSValue JSC_HOST_CALL functionDumpBasicBlockExecutionRanges(ExecState*);
616 static EncodedJSValue JSC_HOST_CALL functionHasBasicBlockExecuted(ExecState*);
617 static EncodedJSValue JSC_HOST_CALL functionBasicBlockExecutionCount(ExecState*);
618 static EncodedJSValue JSC_HOST_CALL functionEnableExceptionFuzz(ExecState*);
619 static EncodedJSValue JSC_HOST_CALL functionDrainMicrotasks(ExecState*);
620 static EncodedJSValue JSC_HOST_CALL functionIs32BitPlatform(ExecState*);
621 #if ENABLE(WEBASSEMBLY)
622 static EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState*);
623 #endif
624 static EncodedJSValue JSC_HOST_CALL functionLoadModule(ExecState*);
625 static EncodedJSValue JSC_HOST_CALL functionCheckModuleSyntax(ExecState*);
626 static EncodedJSValue JSC_HOST_CALL functionPlatformSupportsSamplingProfiler(ExecState*);
627 static EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshot(ExecState*);
628 #if ENABLE(SAMPLING_PROFILER)
629 static EncodedJSValue JSC_HOST_CALL functionStartSamplingProfiler(ExecState*);
630 static EncodedJSValue JSC_HOST_CALL functionSamplingProfilerStackTraces(ExecState*);
631 #endif
632
633 #if ENABLE(SAMPLING_FLAGS)
634 static EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*);
635 static EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState*);
636 #endif
637
638 static EncodedJSValue JSC_HOST_CALL functionShadowChickenFunctionsOnStack(ExecState*);
639 static EncodedJSValue JSC_HOST_CALL functionSetGlobalConstRedeclarationShouldNotThrow(ExecState*);
640
641 struct Script {
642     bool parseAsStrict;
643     bool isFile;
644     char* argument;
645
646     Script(bool parseAsStrict, bool isFile, char *argument)
647         : parseAsStrict(parseAsStrict)
648         , isFile(isFile)
649         , argument(argument)
650     {
651         if (parseAsStrict)
652             ASSERT(isFile);
653     }
654 };
655
656 class CommandLine {
657 public:
658     CommandLine(int argc, char** argv)
659     {
660         parseArguments(argc, argv);
661     }
662
663     bool m_interactive { false };
664     bool m_dump { false };
665     bool m_module { false };
666     bool m_exitCode { false };
667     Vector<Script> m_scripts;
668     Vector<String> m_arguments;
669     bool m_profile { false };
670     String m_profilerOutput;
671     String m_uncaughtExceptionName;
672     bool m_dumpSamplingProfilerData { false };
673
674     void parseArguments(int, char**);
675 };
676
677 static const char interactivePrompt[] = ">>> ";
678
679 class StopWatch {
680 public:
681     void start();
682     void stop();
683     long getElapsedMS(); // call stop() first
684
685 private:
686     double m_startTime;
687     double m_stopTime;
688 };
689
690 void StopWatch::start()
691 {
692     m_startTime = monotonicallyIncreasingTime();
693 }
694
695 void StopWatch::stop()
696 {
697     m_stopTime = monotonicallyIncreasingTime();
698 }
699
700 long StopWatch::getElapsedMS()
701 {
702     return static_cast<long>((m_stopTime - m_startTime) * 1000);
703 }
704
705 template<typename Vector>
706 static inline String stringFromUTF(const Vector& utf8)
707 {
708     return String::fromUTF8WithLatin1Fallback(utf8.data(), utf8.size());
709 }
710
711 template<typename Vector>
712 static inline SourceCode jscSource(const Vector& utf8, const String& filename)
713 {
714     String str = stringFromUTF(utf8);
715     return makeSource(str, filename);
716 }
717
718 class GlobalObject : public JSGlobalObject {
719 private:
720     GlobalObject(VM&, Structure*);
721
722 public:
723     typedef JSGlobalObject Base;
724
725     static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)
726     {
727         GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure);
728         object->finishCreation(vm, arguments);
729         vm.heap.addFinalizer(object, destroy);
730         return object;
731     }
732
733     static const bool needsDestruction = false;
734
735     DECLARE_INFO;
736     static const GlobalObjectMethodTable s_globalObjectMethodTable;
737
738     static Structure* createStructure(VM& vm, JSValue prototype)
739     {
740         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
741     }
742
743     static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags::createAllEnabled(); }
744
745 protected:
746     void finishCreation(VM& vm, const Vector<String>& arguments)
747     {
748         Base::finishCreation(vm);
749
750         addFunction(vm, "dataLogValue", functionDataLogValue, 1);
751         addFunction(vm, "debug", functionDebug, 1);
752         addFunction(vm, "describe", functionDescribe, 1);
753         addFunction(vm, "describeArray", functionDescribeArray, 1);
754         addFunction(vm, "print", functionPrint, 1);
755         addFunction(vm, "quit", functionQuit, 0);
756         addFunction(vm, "abort", functionAbort, 0);
757         addFunction(vm, "gc", functionGCAndSweep, 0);
758         addFunction(vm, "fullGC", functionFullGC, 0);
759         addFunction(vm, "edenGC", functionEdenGC, 0);
760         addFunction(vm, "forceGCSlowPaths", functionForceGCSlowPaths, 0);
761         addFunction(vm, "gcHeapSize", functionHeapSize, 0);
762         addFunction(vm, "addressOf", functionAddressOf, 1);
763         addFunction(vm, "getGetterSetter", functionGetGetterSetter, 2);
764 #ifndef NDEBUG
765         addFunction(vm, "dumpCallFrame", functionDumpCallFrame, 0);
766 #endif
767         addFunction(vm, "version", functionVersion, 1);
768         addFunction(vm, "run", functionRun, 1);
769         addFunction(vm, "load", functionLoad, 1);
770         addFunction(vm, "readFile", functionReadFile, 1);
771         addFunction(vm, "checkSyntax", functionCheckSyntax, 1);
772         addFunction(vm, "jscStack", functionJSCStack, 1);
773         addFunction(vm, "readline", functionReadline, 0);
774         addFunction(vm, "preciseTime", functionPreciseTime, 0);
775         addFunction(vm, "neverInlineFunction", functionNeverInlineFunction, 1);
776         addFunction(vm, "noInline", functionNeverInlineFunction, 1);
777         addFunction(vm, "noDFG", functionNoDFG, 1);
778         addFunction(vm, "noFTL", functionNoFTL, 1);
779         addFunction(vm, "numberOfDFGCompiles", functionNumberOfDFGCompiles, 1);
780         addFunction(vm, "optimizeNextInvocation", functionOptimizeNextInvocation, 1);
781         addFunction(vm, "reoptimizationRetryCount", functionReoptimizationRetryCount, 1);
782         addFunction(vm, "transferArrayBuffer", functionTransferArrayBuffer, 1);
783         addFunction(vm, "failNextNewCodeBlock", functionFailNextNewCodeBlock, 1);
784 #if ENABLE(SAMPLING_FLAGS)
785         addFunction(vm, "setSamplingFlags", functionSetSamplingFlags, 1);
786         addFunction(vm, "clearSamplingFlags", functionClearSamplingFlags, 1);
787 #endif
788         addFunction(vm, "shadowChickenFunctionsOnStack", functionShadowChickenFunctionsOnStack, 0);
789         addFunction(vm, "setGlobalConstRedeclarationShouldNotThrow", functionSetGlobalConstRedeclarationShouldNotThrow, 0);
790         addConstructableFunction(vm, "Root", functionCreateRoot, 0);
791         addConstructableFunction(vm, "Element", functionCreateElement, 1);
792         addFunction(vm, "getElement", functionGetElement, 1);
793         addFunction(vm, "setElementRoot", functionSetElementRoot, 2);
794         
795         addConstructableFunction(vm, "SimpleObject", functionCreateSimpleObject, 0);
796         addFunction(vm, "getHiddenValue", functionGetHiddenValue, 1);
797         addFunction(vm, "setHiddenValue", functionSetHiddenValue, 2);
798         
799         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "DFGTrue"), 0, functionFalse1, DFGTrueIntrinsic, DontEnum);
800         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "OSRExit"), 0, functionUndefined1, OSRExitIntrinsic, DontEnum);
801         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "isFinalTier"), 0, functionFalse2, IsFinalTierIntrinsic, DontEnum);
802         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "predictInt32"), 0, functionUndefined2, SetInt32HeapPredictionIntrinsic, DontEnum);
803         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "isInt32"), 0, functionIsInt32, CheckInt32Intrinsic, DontEnum);
804         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "fiatInt52"), 0, functionIdentity, FiatInt52Intrinsic, DontEnum);
805         
806         addFunction(vm, "effectful42", functionEffectful42, 0);
807         addFunction(vm, "makeMasquerader", functionMakeMasquerader, 0);
808         addFunction(vm, "hasCustomProperties", functionHasCustomProperties, 0);
809
810         addFunction(vm, "createProxy", functionCreateProxy, 1);
811         addFunction(vm, "createRuntimeArray", functionCreateRuntimeArray, 0);
812
813         addFunction(vm, "createImpureGetter", functionCreateImpureGetter, 1);
814         addFunction(vm, "createCustomGetterObject", functionCreateCustomGetterObject, 0);
815         addFunction(vm, "createBuiltin", functionCreateBuiltin, 2);
816         addFunction(vm, "createGlobalObject", functionCreateGlobalObject, 0);
817         addFunction(vm, "setImpureGetterDelegate", functionSetImpureGetterDelegate, 2);
818
819         addFunction(vm, "dumpTypesForAllVariables", functionDumpTypesForAllVariables , 0);
820         addFunction(vm, "findTypeForExpression", functionFindTypeForExpression, 2);
821         addFunction(vm, "returnTypeFor", functionReturnTypeFor, 1);
822
823         addFunction(vm, "dumpBasicBlockExecutionRanges", functionDumpBasicBlockExecutionRanges , 0);
824         addFunction(vm, "hasBasicBlockExecuted", functionHasBasicBlockExecuted, 2);
825         addFunction(vm, "basicBlockExecutionCount", functionBasicBlockExecutionCount, 2);
826
827         addFunction(vm, "enableExceptionFuzz", functionEnableExceptionFuzz, 0);
828
829         addFunction(vm, "drainMicrotasks", functionDrainMicrotasks, 0);
830
831         addFunction(vm, "is32BitPlatform", functionIs32BitPlatform, 0);
832
833 #if ENABLE(WEBASSEMBLY)
834         addFunction(vm, "loadWebAssembly", functionLoadWebAssembly, 3);
835 #endif
836         addFunction(vm, "loadModule", functionLoadModule, 1);
837         addFunction(vm, "checkModuleSyntax", functionCheckModuleSyntax, 1);
838
839         addFunction(vm, "platformSupportsSamplingProfiler", functionPlatformSupportsSamplingProfiler, 0);
840         addFunction(vm, "generateHeapSnapshot", functionGenerateHeapSnapshot, 0);
841 #if ENABLE(SAMPLING_PROFILER)
842         addFunction(vm, "startSamplingProfiler", functionStartSamplingProfiler, 0);
843         addFunction(vm, "samplingProfilerStackTraces", functionSamplingProfilerStackTraces, 0);
844 #endif
845
846         if (!arguments.isEmpty()) {
847             JSArray* array = constructEmptyArray(globalExec(), 0);
848             for (size_t i = 0; i < arguments.size(); ++i)
849                 array->putDirectIndex(globalExec(), i, jsString(globalExec(), arguments[i]));
850             putDirect(vm, Identifier::fromString(globalExec(), "arguments"), array);
851         }
852
853         putDirect(vm, Identifier::fromString(globalExec(), "console"), jsUndefined());
854         putDirect(vm, vm.propertyNames->printPrivateName, JSFunction::create(vm, this, 1, vm.propertyNames->printPrivateName.string(), functionPrint));
855     }
856
857     void addFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)
858     {
859         Identifier identifier = Identifier::fromString(&vm, name);
860         putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function));
861     }
862     
863     void addConstructableFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)
864     {
865         Identifier identifier = Identifier::fromString(&vm, name);
866         putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function, NoIntrinsic, function));
867     }
868
869     static JSInternalPromise* moduleLoaderResolve(JSGlobalObject*, ExecState*, JSValue, JSValue);
870     static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, ExecState*, JSValue);
871 };
872
873 const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, nullptr, CREATE_METHOD_TABLE(GlobalObject) };
874 const GlobalObjectMethodTable GlobalObject::s_globalObjectMethodTable = { &allowsAccessFrom, &supportsLegacyProfiling, &supportsRichSourceInfo, &shouldInterruptScript, &javaScriptRuntimeFlags, 0, &shouldInterruptScriptBeforeTimeout, &moduleLoaderResolve, &moduleLoaderFetch, nullptr, nullptr, nullptr, nullptr };
875
876
877 GlobalObject::GlobalObject(VM& vm, Structure* structure)
878     : JSGlobalObject(vm, structure, &s_globalObjectMethodTable)
879 {
880 }
881
882 static UChar pathSeparator()
883 {
884 #if OS(WINDOWS)
885     return '\\';
886 #else
887     return '/';
888 #endif
889 }
890
891 struct DirectoryName {
892     // In unix, it is "/". In Windows, it becomes a drive letter like "C:\"
893     String rootName;
894
895     // If the directory name is "/home/WebKit", this becomes "home/WebKit". If the directory name is "/", this becomes "".
896     String queryName;
897 };
898
899 struct ModuleName {
900     ModuleName(const String& moduleName);
901
902     bool startsWithRoot() const
903     {
904         return !queries.isEmpty() && queries[0].isEmpty();
905     }
906
907     Vector<String> queries;
908 };
909
910 ModuleName::ModuleName(const String& moduleName)
911 {
912     // A module name given from code is represented as the UNIX style path. Like, `./A/B.js`.
913     moduleName.split('/', true, queries);
914 }
915
916 static bool extractDirectoryName(const String& absolutePathToFile, DirectoryName& directoryName)
917 {
918     size_t firstSeparatorPosition = absolutePathToFile.find(pathSeparator());
919     if (firstSeparatorPosition == notFound)
920         return false;
921     directoryName.rootName = absolutePathToFile.substring(0, firstSeparatorPosition + 1); // Include the separator.
922     size_t lastSeparatorPosition = absolutePathToFile.reverseFind(pathSeparator());
923     ASSERT_WITH_MESSAGE(lastSeparatorPosition != notFound, "If the separator is not found, this function already returns when performing the forward search.");
924     if (firstSeparatorPosition == lastSeparatorPosition)
925         directoryName.queryName = StringImpl::empty();
926     else {
927         size_t queryStartPosition = firstSeparatorPosition + 1;
928         size_t queryLength = lastSeparatorPosition - queryStartPosition; // Not include the last separator.
929         directoryName.queryName = absolutePathToFile.substring(queryStartPosition, queryLength);
930     }
931     return true;
932 }
933
934 static bool currentWorkingDirectory(DirectoryName& directoryName)
935 {
936 #if OS(WINDOWS)
937     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364934.aspx
938     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx#maxpath
939     // The _MAX_PATH in Windows is 260. If the path of the current working directory is longer than that, _getcwd truncates the result.
940     // And other I/O functions taking a path name also truncate it. To avoid this situation,
941     //
942     // (1). When opening the file in Windows for modules, we always use the abosolute path and add "\\?\" prefix to the path name.
943     // (2). When retrieving the current working directory, use GetCurrentDirectory instead of _getcwd.
944     //
945     // In the path utility functions inside the JSC shell, we does not handle the UNC and UNCW including the network host name.
946     DWORD bufferLength = ::GetCurrentDirectoryW(0, nullptr);
947     if (!bufferLength)
948         return false;
949     // In Windows, wchar_t is the UTF-16LE.
950     // https://msdn.microsoft.com/en-us/library/dd374081.aspx
951     // https://msdn.microsoft.com/en-us/library/windows/desktop/ff381407.aspx
952     auto buffer = std::make_unique<wchar_t[]>(bufferLength);
953     DWORD lengthNotIncludingNull = ::GetCurrentDirectoryW(bufferLength, buffer.get());
954     static_assert(sizeof(wchar_t) == sizeof(UChar), "In Windows, both are UTF-16LE");
955     String directoryString = String(reinterpret_cast<UChar*>(buffer.get()));
956     // We don't support network path like \\host\share\<path name>.
957     if (directoryString.startsWith("\\\\"))
958         return false;
959 #else
960     auto buffer = std::make_unique<char[]>(PATH_MAX);
961     if (!getcwd(buffer.get(), PATH_MAX))
962         return false;
963     String directoryString = String::fromUTF8(buffer.get());
964 #endif
965     if (directoryString.isEmpty())
966         return false;
967
968     if (directoryString[directoryString.length() - 1] == pathSeparator())
969         return extractDirectoryName(directoryString, directoryName);
970     // Append the seperator to represents the file name. extractDirectoryName only accepts the absolute file name.
971     return extractDirectoryName(makeString(directoryString, pathSeparator()), directoryName);
972 }
973
974 static String resolvePath(const DirectoryName& directoryName, const ModuleName& moduleName)
975 {
976     Vector<String> directoryPieces;
977     directoryName.queryName.split(pathSeparator(), false, directoryPieces);
978
979     // Only first '/' is recognized as the path from the root.
980     if (moduleName.startsWithRoot())
981         directoryPieces.clear();
982
983     for (const auto& query : moduleName.queries) {
984         if (query == String(ASCIILiteral(".."))) {
985             if (!directoryPieces.isEmpty())
986                 directoryPieces.removeLast();
987         } else if (!query.isEmpty() && query != String(ASCIILiteral(".")))
988             directoryPieces.append(query);
989     }
990
991     StringBuilder builder;
992     builder.append(directoryName.rootName);
993     for (size_t i = 0; i < directoryPieces.size(); ++i) {
994         builder.append(directoryPieces[i]);
995         if (i + 1 != directoryPieces.size())
996             builder.append(pathSeparator());
997     }
998     return builder.toString();
999 }
1000
1001 JSInternalPromise* GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSValue keyValue, JSValue referrerValue)
1002 {
1003     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
1004     const Identifier key = keyValue.toPropertyKey(exec);
1005     if (exec->hadException()) {
1006         JSValue exception = exec->exception();
1007         exec->clearException();
1008         return deferred->reject(exec, exception);
1009     }
1010
1011     if (key.isSymbol())
1012         return deferred->resolve(exec, keyValue);
1013
1014     DirectoryName directoryName;
1015     if (referrerValue.isUndefined()) {
1016         if (!currentWorkingDirectory(directoryName))
1017             return deferred->reject(exec, createError(exec, ASCIILiteral("Could not resolve the current working directory.")));
1018     } else {
1019         const Identifier referrer = referrerValue.toPropertyKey(exec);
1020         if (exec->hadException()) {
1021             JSValue exception = exec->exception();
1022             exec->clearException();
1023             return deferred->reject(exec, exception);
1024         }
1025         if (referrer.isSymbol()) {
1026             if (!currentWorkingDirectory(directoryName))
1027                 return deferred->reject(exec, createError(exec, ASCIILiteral("Could not resolve the current working directory.")));
1028         } else {
1029             // If the referrer exists, we assume that the referrer is the correct absolute path.
1030             if (!extractDirectoryName(referrer.impl(), directoryName))
1031                 return deferred->reject(exec, createError(exec, makeString("Could not resolve the referrer name '", String(referrer.impl()), "'.")));
1032         }
1033     }
1034
1035     return deferred->resolve(exec, jsString(exec, resolvePath(directoryName, ModuleName(key.impl()))));
1036 }
1037
1038 static void convertShebangToJSComment(Vector<char>& buffer)
1039 {
1040     if (buffer.size() >= 2) {
1041         if (buffer[0] == '#' && buffer[1] == '!')
1042             buffer[0] = buffer[1] = '/';
1043     }
1044 }
1045
1046 static bool fillBufferWithContentsOfFile(FILE* file, Vector<char>& buffer)
1047 {
1048     // We might have injected "use strict"; at the top.
1049     size_t initialSize = buffer.size();
1050     fseek(file, 0, SEEK_END);
1051     size_t bufferCapacity = ftell(file);
1052     fseek(file, 0, SEEK_SET);
1053     buffer.resize(bufferCapacity + initialSize);
1054     size_t readSize = fread(buffer.data() + initialSize, 1, buffer.size(), file);
1055     return readSize == buffer.size() - initialSize;
1056 }
1057
1058 static bool fillBufferWithContentsOfFile(const String& fileName, Vector<char>& buffer)
1059 {
1060     FILE* f = fopen(fileName.utf8().data(), "rb");
1061     if (!f) {
1062         fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
1063         return false;
1064     }
1065
1066     bool result = fillBufferWithContentsOfFile(f, buffer);
1067     fclose(f);
1068
1069     return result;
1070 }
1071
1072 static bool fetchScriptFromLocalFileSystem(const String& fileName, Vector<char>& buffer)
1073 {
1074     if (!fillBufferWithContentsOfFile(fileName, buffer))
1075         return false;
1076     convertShebangToJSComment(buffer);
1077     return true;
1078 }
1079
1080 static bool fetchModuleFromLocalFileSystem(const String& fileName, Vector<char>& buffer)
1081 {
1082     // We assume that fileName is always an absolute path.
1083 #if OS(WINDOWS)
1084     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx#maxpath
1085     // Use long UNC to pass the long path name to the Windows APIs.
1086     String longUNCPathName = WTF::makeString("\\\\?\\", fileName);
1087     static_assert(sizeof(wchar_t) == sizeof(UChar), "In Windows, both are UTF-16LE");
1088     auto utf16Vector = longUNCPathName.charactersWithNullTermination();
1089     FILE* f = _wfopen(reinterpret_cast<wchar_t*>(utf16Vector.data()), L"rb");
1090 #else
1091     FILE* f = fopen(fileName.utf8().data(), "r");
1092 #endif
1093     if (!f) {
1094         fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
1095         return false;
1096     }
1097
1098     bool result = fillBufferWithContentsOfFile(f, buffer);
1099     if (result)
1100         convertShebangToJSComment(buffer);
1101     fclose(f);
1102
1103     return result;
1104 }
1105
1106 JSInternalPromise* GlobalObject::moduleLoaderFetch(JSGlobalObject* globalObject, ExecState* exec, JSValue key)
1107 {
1108     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
1109     String moduleKey = key.toString(exec)->value(exec);
1110     if (exec->hadException()) {
1111         JSValue exception = exec->exception();
1112         exec->clearException();
1113         return deferred->reject(exec, exception);
1114     }
1115
1116     // Here, now we consider moduleKey as the fileName.
1117     Vector<char> utf8;
1118     if (!fetchModuleFromLocalFileSystem(moduleKey, utf8))
1119         return deferred->reject(exec, createError(exec, makeString("Could not open file '", moduleKey, "'.")));
1120
1121     return deferred->resolve(exec, jsString(exec, stringFromUTF(utf8)));
1122 }
1123
1124
1125 EncodedJSValue JSC_HOST_CALL functionPrint(ExecState* exec)
1126 {
1127     if (test262AsyncTest) {
1128         JSValue value = exec->argument(0);
1129         if (value.isString() && WTF::equal(asString(value)->value(exec).impl(), "Test262:AsyncTestComplete"))
1130             test262AsyncPassed = true;
1131         return JSValue::encode(jsUndefined());
1132     }
1133
1134     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1135         if (i)
1136             putchar(' ');
1137
1138         printf("%s", exec->uncheckedArgument(i).toString(exec)->view(exec).get().utf8().data());
1139     }
1140
1141     putchar('\n');
1142     fflush(stdout);
1143     return JSValue::encode(jsUndefined());
1144 }
1145
1146 #ifndef NDEBUG
1147 EncodedJSValue JSC_HOST_CALL functionDumpCallFrame(ExecState* exec)
1148 {
1149     VMEntryFrame* topVMEntryFrame = exec->vm().topVMEntryFrame;
1150     ExecState* callerFrame = exec->callerFrame(topVMEntryFrame);
1151     if (callerFrame)
1152         exec->vm().interpreter->dumpCallFrame(callerFrame);
1153     return JSValue::encode(jsUndefined());
1154 }
1155 #endif
1156
1157 EncodedJSValue JSC_HOST_CALL functionDebug(ExecState* exec)
1158 {
1159     fprintf(stderr, "--> %s\n", exec->argument(0).toString(exec)->view(exec).get().utf8().data());
1160     return JSValue::encode(jsUndefined());
1161 }
1162
1163 EncodedJSValue JSC_HOST_CALL functionDataLogValue(ExecState* exec)
1164 {
1165     dataLog("value is: ", exec->argument(0), "\n");
1166     return JSValue::encode(jsUndefined());
1167 }
1168
1169 EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState* exec)
1170 {
1171     if (exec->argumentCount() < 1)
1172         return JSValue::encode(jsUndefined());
1173     return JSValue::encode(jsString(exec, toString(exec->argument(0))));
1174 }
1175
1176 EncodedJSValue JSC_HOST_CALL functionDescribeArray(ExecState* exec)
1177 {
1178     if (exec->argumentCount() < 1)
1179         return JSValue::encode(jsUndefined());
1180     JSObject* object = jsDynamicCast<JSObject*>(exec->argument(0));
1181     if (!object)
1182         return JSValue::encode(jsNontrivialString(exec, ASCIILiteral("<not object>")));
1183     return JSValue::encode(jsNontrivialString(exec, toString("<Public length: ", object->getArrayLength(), "; vector length: ", object->getVectorLength(), ">")));
1184 }
1185
1186 class FunctionJSCStackFunctor {
1187 public:
1188     FunctionJSCStackFunctor(StringBuilder& trace)
1189         : m_trace(trace)
1190     {
1191     }
1192
1193     StackVisitor::Status operator()(StackVisitor& visitor) const
1194     {
1195         m_trace.append(String::format("    %zu   %s\n", visitor->index(), visitor->toString().utf8().data()));
1196         return StackVisitor::Continue;
1197     }
1198
1199 private:
1200     StringBuilder& m_trace;
1201 };
1202
1203 EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState* exec)
1204 {
1205     StringBuilder trace;
1206     trace.appendLiteral("--> Stack trace:\n");
1207
1208     FunctionJSCStackFunctor functor(trace);
1209     exec->iterate(functor);
1210     fprintf(stderr, "%s", trace.toString().utf8().data());
1211     return JSValue::encode(jsUndefined());
1212 }
1213
1214 EncodedJSValue JSC_HOST_CALL functionCreateRoot(ExecState* exec)
1215 {
1216     JSLockHolder lock(exec);
1217     return JSValue::encode(Root::create(exec->vm(), exec->lexicalGlobalObject()));
1218 }
1219
1220 EncodedJSValue JSC_HOST_CALL functionCreateElement(ExecState* exec)
1221 {
1222     JSLockHolder lock(exec);
1223     Root* root = jsDynamicCast<Root*>(exec->argument(0));
1224     if (!root)
1225         return JSValue::encode(jsUndefined());
1226     return JSValue::encode(Element::create(exec->vm(), exec->lexicalGlobalObject(), root));
1227 }
1228
1229 EncodedJSValue JSC_HOST_CALL functionGetElement(ExecState* exec)
1230 {
1231     JSLockHolder lock(exec);
1232     Root* root = jsDynamicCast<Root*>(exec->argument(0));
1233     if (!root)
1234         return JSValue::encode(jsUndefined());
1235     Element* result = root->element();
1236     return JSValue::encode(result ? result : jsUndefined());
1237 }
1238
1239 EncodedJSValue JSC_HOST_CALL functionSetElementRoot(ExecState* exec)
1240 {
1241     JSLockHolder lock(exec);
1242     Element* element = jsDynamicCast<Element*>(exec->argument(0));
1243     Root* root = jsDynamicCast<Root*>(exec->argument(1));
1244     if (element && root)
1245         element->setRoot(exec->vm(), root);
1246     return JSValue::encode(jsUndefined());
1247 }
1248
1249 EncodedJSValue JSC_HOST_CALL functionCreateSimpleObject(ExecState* exec)
1250 {
1251     JSLockHolder lock(exec);
1252     return JSValue::encode(SimpleObject::create(exec->vm(), exec->lexicalGlobalObject()));
1253 }
1254
1255 EncodedJSValue JSC_HOST_CALL functionGetHiddenValue(ExecState* exec)
1256 {
1257     JSLockHolder lock(exec);
1258     SimpleObject* simpleObject = jsCast<SimpleObject*>(exec->argument(0).asCell());
1259     return JSValue::encode(simpleObject->hiddenValue());
1260 }
1261
1262 EncodedJSValue JSC_HOST_CALL functionSetHiddenValue(ExecState* exec)
1263 {
1264     JSLockHolder lock(exec);
1265     SimpleObject* simpleObject = jsCast<SimpleObject*>(exec->argument(0).asCell());
1266     JSValue value = exec->argument(1);
1267     simpleObject->setHiddenValue(exec->vm(), value);
1268     return JSValue::encode(jsUndefined());
1269 }
1270
1271 EncodedJSValue JSC_HOST_CALL functionCreateProxy(ExecState* exec)
1272 {
1273     JSLockHolder lock(exec);
1274     JSValue target = exec->argument(0);
1275     if (!target.isObject())
1276         return JSValue::encode(jsUndefined());
1277     JSObject* jsTarget = asObject(target.asCell());
1278     Structure* structure = JSProxy::createStructure(exec->vm(), exec->lexicalGlobalObject(), jsTarget->getPrototypeDirect(), ImpureProxyType);
1279     JSProxy* proxy = JSProxy::create(exec->vm(), structure, jsTarget);
1280     return JSValue::encode(proxy);
1281 }
1282
1283 EncodedJSValue JSC_HOST_CALL functionCreateRuntimeArray(ExecState* exec)
1284 {
1285     JSLockHolder lock(exec);
1286     RuntimeArray* array = RuntimeArray::create(exec);
1287     return JSValue::encode(array);
1288 }
1289
1290 EncodedJSValue JSC_HOST_CALL functionCreateImpureGetter(ExecState* exec)
1291 {
1292     JSLockHolder lock(exec);
1293     JSValue target = exec->argument(0);
1294     JSObject* delegate = nullptr;
1295     if (target.isObject())
1296         delegate = asObject(target.asCell());
1297     Structure* structure = ImpureGetter::createStructure(exec->vm(), exec->lexicalGlobalObject(), jsNull());
1298     ImpureGetter* result = ImpureGetter::create(exec->vm(), structure, delegate);
1299     return JSValue::encode(result);
1300 }
1301
1302 EncodedJSValue JSC_HOST_CALL functionCreateCustomGetterObject(ExecState* exec)
1303 {
1304     JSLockHolder lock(exec);
1305     Structure* structure = CustomGetter::createStructure(exec->vm(), exec->lexicalGlobalObject(), jsNull());
1306     CustomGetter* result = CustomGetter::create(exec->vm(), structure);
1307     return JSValue::encode(result);
1308 }
1309
1310 EncodedJSValue JSC_HOST_CALL functionSetImpureGetterDelegate(ExecState* exec)
1311 {
1312     JSLockHolder lock(exec);
1313     JSValue base = exec->argument(0);
1314     if (!base.isObject())
1315         return JSValue::encode(jsUndefined());
1316     JSValue delegate = exec->argument(1);
1317     if (!delegate.isObject())
1318         return JSValue::encode(jsUndefined());
1319     ImpureGetter* impureGetter = jsCast<ImpureGetter*>(asObject(base.asCell()));
1320     impureGetter->setDelegate(exec->vm(), asObject(delegate.asCell()));
1321     return JSValue::encode(jsUndefined());
1322 }
1323
1324 EncodedJSValue JSC_HOST_CALL functionGCAndSweep(ExecState* exec)
1325 {
1326     JSLockHolder lock(exec);
1327     exec->heap()->collectAllGarbage();
1328     return JSValue::encode(jsNumber(exec->heap()->sizeAfterLastFullCollection()));
1329 }
1330
1331 EncodedJSValue JSC_HOST_CALL functionFullGC(ExecState* exec)
1332 {
1333     JSLockHolder lock(exec);
1334     exec->heap()->collect(FullCollection);
1335     return JSValue::encode(jsNumber(exec->heap()->sizeAfterLastFullCollection()));
1336 }
1337
1338 EncodedJSValue JSC_HOST_CALL functionEdenGC(ExecState* exec)
1339 {
1340     JSLockHolder lock(exec);
1341     exec->heap()->collect(EdenCollection);
1342     return JSValue::encode(jsNumber(exec->heap()->sizeAfterLastEdenCollection()));
1343 }
1344
1345 EncodedJSValue JSC_HOST_CALL functionForceGCSlowPaths(ExecState*)
1346 {
1347     // It's best for this to be the first thing called in the 
1348     // JS program so the option is set to true before we JIT.
1349     Options::forceGCSlowPaths() = true;
1350     return JSValue::encode(jsUndefined());
1351 }
1352
1353 EncodedJSValue JSC_HOST_CALL functionHeapSize(ExecState* exec)
1354 {
1355     JSLockHolder lock(exec);
1356     return JSValue::encode(jsNumber(exec->heap()->size()));
1357 }
1358
1359 // This function is not generally very helpful in 64-bit code as the tag and payload
1360 // share a register. But in 32-bit JITed code the tag may not be checked if an
1361 // optimization removes type checking requirements, such as in ===.
1362 EncodedJSValue JSC_HOST_CALL functionAddressOf(ExecState* exec)
1363 {
1364     JSValue value = exec->argument(0);
1365     if (!value.isCell())
1366         return JSValue::encode(jsUndefined());
1367     // Need to cast to uint64_t so bitwise_cast will play along.
1368     uint64_t asNumber = reinterpret_cast<uint64_t>(value.asCell());
1369     EncodedJSValue returnValue = JSValue::encode(jsNumber(bitwise_cast<double>(asNumber)));
1370     return returnValue;
1371 }
1372
1373 static EncodedJSValue JSC_HOST_CALL functionGetGetterSetter(ExecState* exec)
1374 {
1375     JSValue value = exec->argument(0);
1376     if (!value.isObject())
1377         return JSValue::encode(jsUndefined());
1378
1379     JSValue property = exec->argument(1);
1380     if (!property.isString())
1381         return JSValue::encode(jsUndefined());
1382
1383     Identifier ident = Identifier::fromString(&exec->vm(), property.toString(exec)->value(exec));
1384
1385     PropertySlot slot(value, PropertySlot::InternalMethodType::VMInquiry);
1386     value.getPropertySlot(exec, ident, slot);
1387
1388     JSValue result;
1389     if (slot.isCacheableGetter())
1390         result = slot.getterSetter();
1391     else
1392         result = jsNull();
1393
1394     return JSValue::encode(result);
1395 }
1396
1397 EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*)
1398 {
1399     // We need this function for compatibility with the Mozilla JS tests but for now
1400     // we don't actually do any version-specific handling
1401     return JSValue::encode(jsUndefined());
1402 }
1403
1404 EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec)
1405 {
1406     String fileName = exec->argument(0).toString(exec)->value(exec);
1407     if (exec->hadException())
1408         return JSValue::encode(jsUndefined());
1409     Vector<char> script;
1410     if (!fetchScriptFromLocalFileSystem(fileName, script))
1411         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1412
1413     GlobalObject* globalObject = GlobalObject::create(exec->vm(), GlobalObject::createStructure(exec->vm(), jsNull()), Vector<String>());
1414
1415     JSArray* array = constructEmptyArray(globalObject->globalExec(), 0);
1416     for (unsigned i = 1; i < exec->argumentCount(); ++i)
1417         array->putDirectIndex(globalObject->globalExec(), i - 1, exec->uncheckedArgument(i));
1418     globalObject->putDirect(
1419         exec->vm(), Identifier::fromString(globalObject->globalExec(), "arguments"), array);
1420
1421     NakedPtr<Exception> exception;
1422     StopWatch stopWatch;
1423     stopWatch.start();
1424     evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), exception);
1425     stopWatch.stop();
1426
1427     if (exception) {
1428         exec->vm().throwException(globalObject->globalExec(), exception);
1429         return JSValue::encode(jsUndefined());
1430     }
1431     
1432     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1433 }
1434
1435 EncodedJSValue JSC_HOST_CALL functionLoad(ExecState* exec)
1436 {
1437     String fileName = exec->argument(0).toString(exec)->value(exec);
1438     if (exec->hadException())
1439         return JSValue::encode(jsUndefined());
1440     Vector<char> script;
1441     if (!fetchScriptFromLocalFileSystem(fileName, script))
1442         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1443
1444     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1445     
1446     NakedPtr<Exception> evaluationException;
1447     JSValue result = evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), evaluationException);
1448     if (evaluationException)
1449         exec->vm().throwException(exec, evaluationException);
1450     return JSValue::encode(result);
1451 }
1452
1453 EncodedJSValue JSC_HOST_CALL functionReadFile(ExecState* exec)
1454 {
1455     String fileName = exec->argument(0).toString(exec)->value(exec);
1456     if (exec->hadException())
1457         return JSValue::encode(jsUndefined());
1458     Vector<char> script;
1459     if (!fillBufferWithContentsOfFile(fileName, script))
1460         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1461
1462     return JSValue::encode(jsString(exec, stringFromUTF(script)));
1463 }
1464
1465 EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec)
1466 {
1467     String fileName = exec->argument(0).toString(exec)->value(exec);
1468     if (exec->hadException())
1469         return JSValue::encode(jsUndefined());
1470     Vector<char> script;
1471     if (!fetchScriptFromLocalFileSystem(fileName, script))
1472         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1473
1474     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1475
1476     StopWatch stopWatch;
1477     stopWatch.start();
1478
1479     JSValue syntaxException;
1480     bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script, fileName), &syntaxException);
1481     stopWatch.stop();
1482
1483     if (!validSyntax)
1484         exec->vm().throwException(exec, syntaxException);
1485     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1486 }
1487
1488 #if ENABLE(SAMPLING_FLAGS)
1489 EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState* exec)
1490 {
1491     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1492         unsigned flag = static_cast<unsigned>(exec->uncheckedArgument(i).toNumber(exec));
1493         if ((flag >= 1) && (flag <= 32))
1494             SamplingFlags::setFlag(flag);
1495     }
1496     return JSValue::encode(jsNull());
1497 }
1498
1499 EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec)
1500 {
1501     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1502         unsigned flag = static_cast<unsigned>(exec->uncheckedArgument(i).toNumber(exec));
1503         if ((flag >= 1) && (flag <= 32))
1504             SamplingFlags::clearFlag(flag);
1505     }
1506     return JSValue::encode(jsNull());
1507 }
1508 #endif
1509
1510 EncodedJSValue JSC_HOST_CALL functionShadowChickenFunctionsOnStack(ExecState* exec)
1511 {
1512     return JSValue::encode(exec->vm().shadowChicken().functionsOnStack(exec));
1513 }
1514
1515 EncodedJSValue JSC_HOST_CALL functionSetGlobalConstRedeclarationShouldNotThrow(ExecState* exec)
1516 {
1517     exec->vm().setGlobalConstRedeclarationShouldThrow(false);
1518     return JSValue::encode(jsUndefined());
1519 }
1520
1521 EncodedJSValue JSC_HOST_CALL functionReadline(ExecState* exec)
1522 {
1523     Vector<char, 256> line;
1524     int c;
1525     while ((c = getchar()) != EOF) {
1526         // FIXME: Should we also break on \r? 
1527         if (c == '\n')
1528             break;
1529         line.append(c);
1530     }
1531     line.append('\0');
1532     return JSValue::encode(jsString(exec, line.data()));
1533 }
1534
1535 EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*)
1536 {
1537     return JSValue::encode(jsNumber(currentTime()));
1538 }
1539
1540 EncodedJSValue JSC_HOST_CALL functionNeverInlineFunction(ExecState* exec)
1541 {
1542     return JSValue::encode(setNeverInline(exec));
1543 }
1544
1545 EncodedJSValue JSC_HOST_CALL functionNoDFG(ExecState* exec)
1546 {
1547     return JSValue::encode(setNeverOptimize(exec));
1548 }
1549
1550 EncodedJSValue JSC_HOST_CALL functionNoFTL(ExecState* exec)
1551 {
1552     if (JSFunction* function = jsDynamicCast<JSFunction*>(exec->argument(0))) {
1553         FunctionExecutable* executable = function->jsExecutable();
1554         executable->setNeverFTLOptimize(true);
1555     }
1556
1557     return JSValue::encode(jsUndefined());
1558 }
1559
1560 EncodedJSValue JSC_HOST_CALL functionOptimizeNextInvocation(ExecState* exec)
1561 {
1562     return JSValue::encode(optimizeNextInvocation(exec));
1563 }
1564
1565 EncodedJSValue JSC_HOST_CALL functionNumberOfDFGCompiles(ExecState* exec)
1566 {
1567     return JSValue::encode(numberOfDFGCompiles(exec));
1568 }
1569
1570 EncodedJSValue JSC_HOST_CALL functionReoptimizationRetryCount(ExecState* exec)
1571 {
1572     if (exec->argumentCount() < 1)
1573         return JSValue::encode(jsUndefined());
1574     
1575     CodeBlock* block = getSomeBaselineCodeBlockForFunction(exec->argument(0));
1576     if (!block)
1577         return JSValue::encode(jsNumber(0));
1578     
1579     return JSValue::encode(jsNumber(block->reoptimizationRetryCounter()));
1580 }
1581
1582 EncodedJSValue JSC_HOST_CALL functionTransferArrayBuffer(ExecState* exec)
1583 {
1584     if (exec->argumentCount() < 1)
1585         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Not enough arguments"))));
1586     
1587     JSArrayBuffer* buffer = jsDynamicCast<JSArrayBuffer*>(exec->argument(0));
1588     if (!buffer)
1589         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Expected an array buffer"))));
1590     
1591     ArrayBufferContents dummyContents;
1592     buffer->impl()->transfer(dummyContents);
1593     
1594     return JSValue::encode(jsUndefined());
1595 }
1596
1597 EncodedJSValue JSC_HOST_CALL functionFailNextNewCodeBlock(ExecState* exec)
1598 {
1599     exec->vm().setFailNextNewCodeBlock();
1600     return JSValue::encode(jsUndefined());
1601 }
1602
1603 EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*)
1604 {
1605     jscExit(EXIT_SUCCESS);
1606
1607 #if COMPILER(MSVC)
1608     // Without this, Visual Studio will complain that this method does not return a value.
1609     return JSValue::encode(jsUndefined());
1610 #endif
1611 }
1612
1613 EncodedJSValue JSC_HOST_CALL functionAbort(ExecState*)
1614 {
1615     CRASH();
1616 }
1617
1618 EncodedJSValue JSC_HOST_CALL functionFalse1(ExecState*) { return JSValue::encode(jsBoolean(false)); }
1619 EncodedJSValue JSC_HOST_CALL functionFalse2(ExecState*) { return JSValue::encode(jsBoolean(false)); }
1620
1621 EncodedJSValue JSC_HOST_CALL functionUndefined1(ExecState*) { return JSValue::encode(jsUndefined()); }
1622 EncodedJSValue JSC_HOST_CALL functionUndefined2(ExecState*) { return JSValue::encode(jsUndefined()); }
1623 EncodedJSValue JSC_HOST_CALL functionIsInt32(ExecState* exec)
1624 {
1625     for (size_t i = 0; i < exec->argumentCount(); ++i) {
1626         if (!exec->argument(i).isInt32())
1627             return JSValue::encode(jsBoolean(false));
1628     }
1629     return JSValue::encode(jsBoolean(true));
1630 }
1631
1632 EncodedJSValue JSC_HOST_CALL functionIdentity(ExecState* exec) { return JSValue::encode(exec->argument(0)); }
1633
1634 EncodedJSValue JSC_HOST_CALL functionEffectful42(ExecState*)
1635 {
1636     return JSValue::encode(jsNumber(42));
1637 }
1638
1639 EncodedJSValue JSC_HOST_CALL functionMakeMasquerader(ExecState* exec)
1640 {
1641     return JSValue::encode(Masquerader::create(exec->vm(), exec->lexicalGlobalObject()));
1642 }
1643
1644 EncodedJSValue JSC_HOST_CALL functionHasCustomProperties(ExecState* exec)
1645 {
1646     JSValue value = exec->argument(0);
1647     if (value.isObject())
1648         return JSValue::encode(jsBoolean(asObject(value)->hasCustomProperties()));
1649     return JSValue::encode(jsBoolean(false));
1650 }
1651
1652 EncodedJSValue JSC_HOST_CALL functionDumpTypesForAllVariables(ExecState* exec)
1653 {
1654     exec->vm().dumpTypeProfilerData();
1655     return JSValue::encode(jsUndefined());
1656 }
1657
1658 EncodedJSValue JSC_HOST_CALL functionFindTypeForExpression(ExecState* exec)
1659 {
1660     RELEASE_ASSERT(exec->vm().typeProfiler());
1661     exec->vm().typeProfilerLog()->processLogEntries(ASCIILiteral("jsc Testing API: functionFindTypeForExpression"));
1662
1663     JSValue functionValue = exec->argument(0);
1664     RELEASE_ASSERT(functionValue.isFunction());
1665     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1666
1667     RELEASE_ASSERT(exec->argument(1).isString());
1668     String substring = exec->argument(1).getString(exec);
1669     String sourceCodeText = executable->source().view().toString();
1670     unsigned offset = static_cast<unsigned>(sourceCodeText.find(substring) + executable->source().startOffset());
1671     
1672     String jsonString = exec->vm().typeProfiler()->typeInformationForExpressionAtOffset(TypeProfilerSearchDescriptorNormal, offset, executable->sourceID(), exec->vm());
1673     return JSValue::encode(JSONParse(exec, jsonString));
1674 }
1675
1676 EncodedJSValue JSC_HOST_CALL functionReturnTypeFor(ExecState* exec)
1677 {
1678     RELEASE_ASSERT(exec->vm().typeProfiler());
1679     exec->vm().typeProfilerLog()->processLogEntries(ASCIILiteral("jsc Testing API: functionReturnTypeFor"));
1680
1681     JSValue functionValue = exec->argument(0);
1682     RELEASE_ASSERT(functionValue.isFunction());
1683     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1684
1685     unsigned offset = executable->typeProfilingStartOffset();
1686     String jsonString = exec->vm().typeProfiler()->typeInformationForExpressionAtOffset(TypeProfilerSearchDescriptorFunctionReturn, offset, executable->sourceID(), exec->vm());
1687     return JSValue::encode(JSONParse(exec, jsonString));
1688 }
1689
1690 EncodedJSValue JSC_HOST_CALL functionDumpBasicBlockExecutionRanges(ExecState* exec)
1691 {
1692     RELEASE_ASSERT(exec->vm().controlFlowProfiler());
1693     exec->vm().controlFlowProfiler()->dumpData();
1694     return JSValue::encode(jsUndefined());
1695 }
1696
1697 EncodedJSValue JSC_HOST_CALL functionHasBasicBlockExecuted(ExecState* exec)
1698 {
1699     RELEASE_ASSERT(exec->vm().controlFlowProfiler());
1700
1701     JSValue functionValue = exec->argument(0);
1702     RELEASE_ASSERT(functionValue.isFunction());
1703     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1704
1705     RELEASE_ASSERT(exec->argument(1).isString());
1706     String substring = exec->argument(1).getString(exec);
1707     String sourceCodeText = executable->source().view().toString();
1708     RELEASE_ASSERT(sourceCodeText.contains(substring));
1709     int offset = sourceCodeText.find(substring) + executable->source().startOffset();
1710     
1711     bool hasExecuted = exec->vm().controlFlowProfiler()->hasBasicBlockAtTextOffsetBeenExecuted(offset, executable->sourceID(), exec->vm());
1712     return JSValue::encode(jsBoolean(hasExecuted));
1713 }
1714
1715 EncodedJSValue JSC_HOST_CALL functionBasicBlockExecutionCount(ExecState* exec)
1716 {
1717     RELEASE_ASSERT(exec->vm().controlFlowProfiler());
1718
1719     JSValue functionValue = exec->argument(0);
1720     RELEASE_ASSERT(functionValue.isFunction());
1721     FunctionExecutable* executable = (jsDynamicCast<JSFunction*>(functionValue.asCell()->getObject()))->jsExecutable();
1722
1723     RELEASE_ASSERT(exec->argument(1).isString());
1724     String substring = exec->argument(1).getString(exec);
1725     String sourceCodeText = executable->source().view().toString();
1726     RELEASE_ASSERT(sourceCodeText.contains(substring));
1727     int offset = sourceCodeText.find(substring) + executable->source().startOffset();
1728     
1729     size_t executionCount = exec->vm().controlFlowProfiler()->basicBlockExecutionCountAtTextOffset(offset, executable->sourceID(), exec->vm());
1730     return JSValue::encode(JSValue(executionCount));
1731 }
1732
1733 EncodedJSValue JSC_HOST_CALL functionEnableExceptionFuzz(ExecState*)
1734 {
1735     Options::useExceptionFuzz() = true;
1736     return JSValue::encode(jsUndefined());
1737 }
1738
1739 EncodedJSValue JSC_HOST_CALL functionDrainMicrotasks(ExecState* exec)
1740 {
1741     exec->vm().drainMicrotasks();
1742     return JSValue::encode(jsUndefined());
1743 }
1744
1745 EncodedJSValue JSC_HOST_CALL functionIs32BitPlatform(ExecState*)
1746 {
1747 #if USE(JSVALUE64)
1748     return JSValue::encode(JSValue(JSC::JSValue::JSFalse));
1749 #else
1750     return JSValue::encode(JSValue(JSC::JSValue::JSTrue));
1751 #endif
1752 }
1753
1754 #if ENABLE(WEBASSEMBLY)
1755 EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState* exec)
1756 {
1757     String fileName = exec->argument(0).toString(exec)->value(exec);
1758     if (exec->hadException())
1759         return JSValue::encode(jsUndefined());
1760     Vector<char> buffer;
1761     if (!fillBufferWithContentsOfFile(fileName, buffer))
1762         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1763     RefPtr<WebAssemblySourceProvider> sourceProvider = WebAssemblySourceProvider::create(reinterpret_cast<Vector<uint8_t>&>(buffer), fileName);
1764     SourceCode source(sourceProvider);
1765     JSObject* imports = exec->argument(1).getObject();
1766     JSArrayBuffer* arrayBuffer = jsDynamicCast<JSArrayBuffer*>(exec->argument(2));
1767
1768     String errorMessage;
1769     JSWASMModule* module = parseWebAssembly(exec, source, imports, arrayBuffer, errorMessage);
1770     if (!module)
1771         return JSValue::encode(exec->vm().throwException(exec, createSyntaxError(exec, errorMessage)));
1772     return JSValue::encode(module);
1773 }
1774 #endif
1775
1776 EncodedJSValue JSC_HOST_CALL functionLoadModule(ExecState* exec)
1777 {
1778     String fileName = exec->argument(0).toString(exec)->value(exec);
1779     if (exec->hadException())
1780         return JSValue::encode(jsUndefined());
1781     Vector<char> script;
1782     if (!fetchScriptFromLocalFileSystem(fileName, script))
1783         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
1784
1785     JSInternalPromise* promise = loadAndEvaluateModule(exec, fileName);
1786     if (exec->hadException())
1787         return JSValue::encode(jsUndefined());
1788
1789     JSValue error;
1790     JSFunction* errorHandler = JSNativeStdFunction::create(exec->vm(), exec->lexicalGlobalObject(), 1, String(), [&](ExecState* exec) {
1791         error = exec->argument(0);
1792         return JSValue::encode(jsUndefined());
1793     });
1794
1795     promise->then(exec, nullptr, errorHandler);
1796     exec->vm().drainMicrotasks();
1797     if (error)
1798         return JSValue::encode(exec->vm().throwException(exec, error));
1799     return JSValue::encode(jsUndefined());
1800 }
1801
1802 EncodedJSValue JSC_HOST_CALL functionCreateBuiltin(ExecState* exec)
1803 {
1804     if (exec->argumentCount() < 1 || !exec->argument(0).isString())
1805         return JSValue::encode(jsUndefined());
1806
1807     String functionText = exec->argument(0).toString(exec)->value(exec);
1808     if (exec->hadException())
1809         return JSValue::encode(JSValue());
1810
1811     VM& vm = exec->vm();
1812     const SourceCode& source = makeSource(functionText);
1813     JSFunction* func = JSFunction::createBuiltinFunction(vm, createBuiltinExecutable(vm, source, Identifier::fromString(&vm, "foo"), ConstructorKind::None, ConstructAbility::CannotConstruct)->link(vm, source), exec->lexicalGlobalObject());
1814
1815     return JSValue::encode(func);
1816 }
1817
1818 EncodedJSValue JSC_HOST_CALL functionCreateGlobalObject(ExecState* exec)
1819 {
1820     VM& vm = exec->vm();
1821     return JSValue::encode(GlobalObject::create(vm, GlobalObject::createStructure(vm, jsNull()), Vector<String>()));
1822 }
1823
1824 EncodedJSValue JSC_HOST_CALL functionCheckModuleSyntax(ExecState* exec)
1825 {
1826     String source = exec->argument(0).toString(exec)->value(exec);
1827     if (exec->hadException())
1828         return JSValue::encode(jsUndefined());
1829
1830     StopWatch stopWatch;
1831     stopWatch.start();
1832
1833     ParserError error;
1834     bool validSyntax = checkModuleSyntax(exec, makeSource(source), error);
1835     stopWatch.stop();
1836
1837     if (!validSyntax)
1838         exec->vm().throwException(exec, jsNontrivialString(exec, toString("SyntaxError: ", error.message(), ":", error.line())));
1839     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1840 }
1841
1842 EncodedJSValue JSC_HOST_CALL functionPlatformSupportsSamplingProfiler(ExecState*)
1843 {
1844 #if ENABLE(SAMPLING_PROFILER)
1845     return JSValue::encode(JSValue(JSC::JSValue::JSTrue));
1846 #else
1847     return JSValue::encode(JSValue(JSC::JSValue::JSFalse));
1848 #endif
1849 }
1850
1851 EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshot(ExecState* exec)
1852 {
1853     JSLockHolder lock(exec);
1854
1855     HeapSnapshotBuilder snapshotBuilder(exec->vm().ensureHeapProfiler());
1856     snapshotBuilder.buildSnapshot();
1857
1858     String jsonString = snapshotBuilder.json();
1859     EncodedJSValue result = JSValue::encode(JSONParse(exec, jsonString));
1860     RELEASE_ASSERT(!exec->hadException());
1861     return result;
1862 }
1863
1864 #if ENABLE(SAMPLING_PROFILER)
1865 EncodedJSValue JSC_HOST_CALL functionStartSamplingProfiler(ExecState* exec)
1866 {
1867     SamplingProfiler& samplingProfiler = exec->vm().ensureSamplingProfiler(WTF::Stopwatch::create());
1868     samplingProfiler.noticeCurrentThreadAsJSCExecutionThread();
1869     samplingProfiler.start();
1870     return JSValue::encode(jsUndefined());
1871 }
1872
1873 EncodedJSValue JSC_HOST_CALL functionSamplingProfilerStackTraces(ExecState* exec)
1874 {
1875     if (!exec->vm().samplingProfiler())
1876         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Sampling profiler was never started"))));
1877
1878     String jsonString = exec->vm().samplingProfiler()->stackTracesAsJSON();
1879     EncodedJSValue result = JSValue::encode(JSONParse(exec, jsonString));
1880     RELEASE_ASSERT(!exec->hadException());
1881     return result;
1882 }
1883 #endif // ENABLE(SAMPLING_PROFILER)
1884
1885 // Use SEH for Release builds only to get rid of the crash report dialog
1886 // (luckily the same tests fail in Release and Debug builds so far). Need to
1887 // be in a separate main function because the jscmain function requires object
1888 // unwinding.
1889
1890 #if COMPILER(MSVC) && !defined(_DEBUG)
1891 #define TRY       __try {
1892 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
1893 #else
1894 #define TRY
1895 #define EXCEPT(x)
1896 #endif
1897
1898 int jscmain(int argc, char** argv);
1899
1900 static double s_desiredTimeout;
1901
1902 static NO_RETURN_DUE_TO_CRASH void timeoutThreadMain(void*)
1903 {
1904     auto timeout = std::chrono::microseconds(static_cast<std::chrono::microseconds::rep>(s_desiredTimeout * 1000000));
1905     std::this_thread::sleep_for(timeout);
1906     
1907     dataLog("Timed out after ", s_desiredTimeout, " seconds!\n");
1908     CRASH();
1909 }
1910
1911 int main(int argc, char** argv)
1912 {
1913 #if PLATFORM(IOS) && CPU(ARM_THUMB2)
1914     // Enabled IEEE754 denormal support.
1915     fenv_t env;
1916     fegetenv( &env );
1917     env.__fpscr &= ~0x01000000u;
1918     fesetenv( &env );
1919 #endif
1920
1921 #if OS(WINDOWS)
1922     // Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for
1923     // testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the
1924     // error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.
1925     ::SetErrorMode(0);
1926
1927 #if defined(_DEBUG)
1928     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
1929     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
1930     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
1931     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
1932     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
1933     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
1934 #endif
1935
1936     timeBeginPeriod(1);
1937 #endif
1938
1939 #if PLATFORM(EFL)
1940     ecore_init();
1941 #endif
1942
1943     // Need to initialize WTF threading before we start any threads. Cannot initialize JSC
1944     // threading yet, since that would do somethings that we'd like to defer until after we
1945     // have a chance to parse options.
1946     WTF::initializeThreading();
1947
1948     if (char* timeoutString = getenv("JSCTEST_timeout")) {
1949         if (sscanf(timeoutString, "%lf", &s_desiredTimeout) != 1) {
1950             dataLog(
1951                 "WARNING: timeout string is malformed, got ", timeoutString,
1952                 " but expected a number. Not using a timeout.\n");
1953         } else
1954             createThread(timeoutThreadMain, 0, "jsc Timeout Thread");
1955     }
1956
1957 #if PLATFORM(IOS)
1958     Options::crashIfCantAllocateJITMemory() = true;
1959 #endif
1960
1961     // We can't use destructors in the following code because it uses Windows
1962     // Structured Exception Handling
1963     int res = 0;
1964     TRY
1965         res = jscmain(argc, argv);
1966     EXCEPT(res = 3)
1967     if (Options::logHeapStatisticsAtExit())
1968         HeapStatistics::reportSuccess();
1969
1970 #if PLATFORM(EFL)
1971     ecore_shutdown();
1972 #endif
1973
1974     jscExit(res);
1975 }
1976
1977 static void dumpException(GlobalObject* globalObject, JSValue exception)
1978 {
1979     printf("Exception: %s\n", exception.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
1980     Identifier stackID = Identifier::fromString(globalObject->globalExec(), "stack");
1981     JSValue stackValue = exception.get(globalObject->globalExec(), stackID);
1982     if (!stackValue.isUndefinedOrNull())
1983         printf("%s\n", stackValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
1984 }
1985
1986 static void dumpException(GlobalObject* globalObject, NakedPtr<Exception> evaluationException)
1987 {
1988     if (evaluationException)
1989         dumpException(globalObject, evaluationException->value());
1990 }
1991
1992 static bool checkUncaughtException(VM& vm, GlobalObject* globalObject, NakedPtr<Exception> evaluationException, const String& expectedExceptionName)
1993 {
1994     if (!evaluationException) {
1995         printf("Expected uncaught exception with name '%s' but none was thrown\n", expectedExceptionName.utf8().data());
1996         return false;
1997     }
1998
1999     JSValue exception = evaluationException->value();
2000     JSValue exceptionName = exception.get(globalObject->globalExec(), vm.propertyNames->name);
2001
2002     if (JSString* exceptionNameStr = jsDynamicCast<JSString*>(exceptionName)) {
2003         const String& name = exceptionNameStr->value(globalObject->globalExec());
2004         if (name == expectedExceptionName)
2005             return true;
2006         printf("Expected uncaught exception with name '%s' but got one with name '%s'\n", expectedExceptionName.utf8().data(), name.utf8().data());
2007         dumpException(globalObject, exception);
2008         return false;
2009     }
2010     printf("Expected uncaught exception with name '%s' but exception value did not have a name property\n", expectedExceptionName.utf8().data());
2011     dumpException(globalObject, exception);
2012     return false;
2013 }
2014
2015 static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scripts, const String& uncaughtExceptionName, bool dump, bool module)
2016 {
2017     String fileName;
2018     Vector<char> scriptBuffer;
2019
2020     if (dump)
2021         JSC::Options::dumpGeneratedBytecodes() = true;
2022
2023     VM& vm = globalObject->vm();
2024     bool success = true;
2025
2026     JSFunction* errorHandler = JSNativeStdFunction::create(vm, globalObject, 1, String(), [&](ExecState* exec) {
2027         success = false;
2028         dumpException(globalObject, exec->argument(0));
2029         return JSValue::encode(jsUndefined());
2030     });
2031
2032 #if ENABLE(SAMPLING_FLAGS)
2033     SamplingFlags::start();
2034 #endif
2035
2036     for (size_t i = 0; i < scripts.size(); i++) {
2037         JSInternalPromise* promise = nullptr;
2038         if (scripts[i].isFile) {
2039             fileName = scripts[i].argument;
2040             if (scripts[i].parseAsStrict)
2041                 scriptBuffer.append("\"use strict\";\n", strlen("\"use strict\";\n"));
2042
2043             if (module)
2044                 promise = loadAndEvaluateModule(globalObject->globalExec(), fileName);
2045             else {
2046                 if (!fetchScriptFromLocalFileSystem(fileName, scriptBuffer))
2047                     return false; // fail early so we can catch missing files
2048             }
2049         } else {
2050             size_t commandLineLength = strlen(scripts[i].argument);
2051             scriptBuffer.resize(commandLineLength);
2052             std::copy(scripts[i].argument, scripts[i].argument + commandLineLength, scriptBuffer.begin());
2053             fileName = ASCIILiteral("[Command Line]");
2054         }
2055
2056         if (module) {
2057             if (!promise)
2058                 promise = loadAndEvaluateModule(globalObject->globalExec(), jscSource(scriptBuffer, fileName));
2059             vm.clearException();
2060             promise->then(globalObject->globalExec(), nullptr, errorHandler);
2061             vm.drainMicrotasks();
2062         } else {
2063             NakedPtr<Exception> evaluationException;
2064             JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(scriptBuffer, fileName), JSValue(), evaluationException);
2065             if (!uncaughtExceptionName || i != scripts.size() - 1) {
2066                 success = success && !evaluationException;
2067                 if (dump && !evaluationException)
2068                     printf("End: %s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
2069                 dumpException(globalObject, evaluationException);
2070             } else
2071                 success = success && checkUncaughtException(vm, globalObject, evaluationException, uncaughtExceptionName);
2072
2073         }
2074
2075         scriptBuffer.clear();
2076         vm.clearException();
2077     }
2078
2079 #if ENABLE(REGEXP_TRACING)
2080     vm.dumpRegExpTrace();
2081 #endif
2082     return success;
2083 }
2084
2085 #define RUNNING_FROM_XCODE 0
2086
2087 static void runInteractive(GlobalObject* globalObject)
2088 {
2089     String interpreterName(ASCIILiteral("Interpreter"));
2090     
2091     bool shouldQuit = false;
2092     while (!shouldQuit) {
2093 #if HAVE(READLINE) && !RUNNING_FROM_XCODE
2094         ParserError error;
2095         String source;
2096         do {
2097             error = ParserError();
2098             char* line = readline(source.isEmpty() ? interactivePrompt : "... ");
2099             shouldQuit = !line;
2100             if (!line)
2101                 break;
2102             source = source + line;
2103             source = source + '\n';
2104             checkSyntax(globalObject->vm(), makeSource(source, interpreterName), error);
2105             if (!line[0])
2106                 break;
2107             add_history(line);
2108         } while (error.syntaxErrorType() == ParserError::SyntaxErrorRecoverable);
2109         
2110         if (error.isValid()) {
2111             printf("%s:%d\n", error.message().utf8().data(), error.line());
2112             continue;
2113         }
2114         
2115         
2116         NakedPtr<Exception> evaluationException;
2117         JSValue returnValue = evaluate(globalObject->globalExec(), makeSource(source, interpreterName), JSValue(), evaluationException);
2118 #else
2119         printf("%s", interactivePrompt);
2120         Vector<char, 256> line;
2121         int c;
2122         while ((c = getchar()) != EOF) {
2123             // FIXME: Should we also break on \r? 
2124             if (c == '\n')
2125                 break;
2126             line.append(c);
2127         }
2128         if (line.isEmpty())
2129             break;
2130
2131         NakedPtr<Exception> evaluationException;
2132         JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(line, interpreterName), JSValue(), evaluationException);
2133 #endif
2134         if (evaluationException)
2135             printf("Exception: %s\n", evaluationException->value().toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
2136         else
2137             printf("%s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
2138
2139         globalObject->globalExec()->clearException();
2140         globalObject->vm().drainMicrotasks();
2141     }
2142     printf("\n");
2143 }
2144
2145 static NO_RETURN void printUsageStatement(bool help = false)
2146 {
2147     fprintf(stderr, "Usage: jsc [options] [files] [-- arguments]\n");
2148     fprintf(stderr, "  -d         Dumps bytecode (debug builds only)\n");
2149     fprintf(stderr, "  -e         Evaluate argument as script code\n");
2150     fprintf(stderr, "  -f         Specifies a source file (deprecated)\n");
2151     fprintf(stderr, "  -h|--help  Prints this help message\n");
2152     fprintf(stderr, "  -i         Enables interactive mode (default if no files are specified)\n");
2153     fprintf(stderr, "  -m         Execute as a module\n");
2154 #if HAVE(SIGNAL_H)
2155     fprintf(stderr, "  -s         Installs signal handlers that exit on a crash (Unix platforms only)\n");
2156 #endif
2157     fprintf(stderr, "  -p <file>  Outputs profiling data to a file\n");
2158     fprintf(stderr, "  -x         Output exit code before terminating\n");
2159     fprintf(stderr, "\n");
2160     fprintf(stderr, "  --sample                   Collects and outputs sampling profiler data\n");
2161     fprintf(stderr, "  --test262-async            Check that some script calls the print function with the string 'Test262:AsyncTestComplete'\n");
2162     fprintf(stderr, "  --strict-file=<file>       Parse the given file as if it were in strict mode (this option may be passed more than once)\n");
2163     fprintf(stderr, "  --exception=<name>         Check the last script exits with an uncaught exception with the specified name\n");
2164     fprintf(stderr, "  --options                  Dumps all JSC VM options and exits\n");
2165     fprintf(stderr, "  --dumpOptions              Dumps all non-default JSC VM options before continuing\n");
2166     fprintf(stderr, "  --<jsc VM option>=<value>  Sets the specified JSC VM option\n");
2167     fprintf(stderr, "\n");
2168
2169     jscExit(help ? EXIT_SUCCESS : EXIT_FAILURE);
2170 }
2171
2172 void CommandLine::parseArguments(int argc, char** argv)
2173 {
2174     Options::initialize();
2175     
2176     int i = 1;
2177     JSC::Options::DumpLevel dumpOptionsLevel = JSC::Options::DumpLevel::None;
2178     bool needToExit = false;
2179
2180     bool hasBadJSCOptions = false;
2181     for (; i < argc; ++i) {
2182         const char* arg = argv[i];
2183         if (!strcmp(arg, "-f")) {
2184             if (++i == argc)
2185                 printUsageStatement();
2186             m_scripts.append(Script(false, true, argv[i]));
2187             continue;
2188         }
2189         if (!strcmp(arg, "-e")) {
2190             if (++i == argc)
2191                 printUsageStatement();
2192             m_scripts.append(Script(false, false, argv[i]));
2193             continue;
2194         }
2195         if (!strcmp(arg, "-i")) {
2196             m_interactive = true;
2197             continue;
2198         }
2199         if (!strcmp(arg, "-d")) {
2200             m_dump = true;
2201             continue;
2202         }
2203         if (!strcmp(arg, "-p")) {
2204             if (++i == argc)
2205                 printUsageStatement();
2206             m_profile = true;
2207             m_profilerOutput = argv[i];
2208             continue;
2209         }
2210         if (!strcmp(arg, "-m")) {
2211             m_module = true;
2212             continue;
2213         }
2214         if (!strcmp(arg, "-s")) {
2215 #if HAVE(SIGNAL_H)
2216             signal(SIGILL, _exit);
2217             signal(SIGFPE, _exit);
2218             signal(SIGBUS, _exit);
2219             signal(SIGSEGV, _exit);
2220 #endif
2221             continue;
2222         }
2223         if (!strcmp(arg, "-x")) {
2224             m_exitCode = true;
2225             continue;
2226         }
2227         if (!strcmp(arg, "--")) {
2228             ++i;
2229             break;
2230         }
2231         if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
2232             printUsageStatement(true);
2233
2234         if (!strcmp(arg, "--options")) {
2235             dumpOptionsLevel = JSC::Options::DumpLevel::Verbose;
2236             needToExit = true;
2237             continue;
2238         }
2239         if (!strcmp(arg, "--dumpOptions")) {
2240             dumpOptionsLevel = JSC::Options::DumpLevel::Overridden;
2241             continue;
2242         }
2243         if (!strcmp(arg, "--sample")) {
2244             JSC::Options::useSamplingProfiler() = true;
2245             JSC::Options::collectSamplingProfilerDataForJSCShell() = true;
2246             m_dumpSamplingProfilerData = true;
2247             continue;
2248         }
2249
2250         if (!strcmp(arg, "--test262-async")) {
2251             test262AsyncTest = true;
2252             continue;
2253         }
2254
2255         static const unsigned strictFileStrLength = strlen("--strict-file=");
2256         if (!strncmp(arg, "--strict-file=", strictFileStrLength)) {
2257             m_scripts.append(Script(true, true, argv[i] + strictFileStrLength));
2258             continue;
2259         }
2260
2261         static const unsigned exceptionStrLength = strlen("--exception=");
2262         if (!strncmp(arg, "--exception=", exceptionStrLength)) {
2263             m_uncaughtExceptionName = String(arg + exceptionStrLength);
2264             continue;
2265         }
2266
2267         // See if the -- option is a JSC VM option.
2268         if (strstr(arg, "--") == arg) {
2269             if (!JSC::Options::setOption(&arg[2])) {
2270                 hasBadJSCOptions = true;
2271                 dataLog("ERROR: invalid option: ", arg, "\n");
2272             }
2273             continue;
2274         }
2275
2276         // This arg is not recognized by the VM nor by jsc. Pass it on to the
2277         // script.
2278         m_scripts.append(Script(false, true, argv[i]));
2279     }
2280
2281     if (hasBadJSCOptions && JSC::Options::validateOptions())
2282         CRASH();
2283
2284     if (m_scripts.isEmpty())
2285         m_interactive = true;
2286
2287     for (; i < argc; ++i)
2288         m_arguments.append(argv[i]);
2289
2290     if (dumpOptionsLevel != JSC::Options::DumpLevel::None) {
2291         const char* optionsTitle = (dumpOptionsLevel == JSC::Options::DumpLevel::Overridden)
2292             ? "Modified JSC runtime options:"
2293             : "All JSC runtime options:";
2294         JSC::Options::dumpAllOptions(stderr, dumpOptionsLevel, optionsTitle);
2295     }
2296     JSC::Options::ensureOptionsAreCoherent();
2297     if (needToExit)
2298         jscExit(EXIT_SUCCESS);
2299 }
2300
2301 // We make this function no inline so that globalObject won't be on the stack if we do a GC in jscmain.
2302 static int NEVER_INLINE runJSC(VM* vm, CommandLine options)
2303 {
2304     JSLockHolder locker(vm);
2305
2306     int result;
2307     if (options.m_profile && !vm->m_perBytecodeProfiler)
2308         vm->m_perBytecodeProfiler = std::make_unique<Profiler::Database>(*vm);
2309
2310     GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.m_arguments);
2311     bool success = runWithScripts(globalObject, options.m_scripts, options.m_uncaughtExceptionName, options.m_dump, options.m_module);
2312     if (options.m_interactive && success)
2313         runInteractive(globalObject);
2314
2315     vm->drainMicrotasks();
2316     result = success && (test262AsyncTest == test262AsyncPassed) ? 0 : 3;
2317
2318     if (options.m_exitCode)
2319         printf("jsc exiting %d\n", result);
2320
2321     if (options.m_profile) {
2322         if (!vm->m_perBytecodeProfiler->save(options.m_profilerOutput.utf8().data()))
2323             fprintf(stderr, "could not save profiler output.\n");
2324     }
2325
2326 #if ENABLE(JIT)
2327     if (Options::useExceptionFuzz())
2328         printf("JSC EXCEPTION FUZZ: encountered %u checks.\n", numberOfExceptionFuzzChecks());
2329     bool fireAtEnabled =
2330     Options::fireExecutableAllocationFuzzAt() || Options::fireExecutableAllocationFuzzAtOrAfter();
2331     if (Options::useExecutableAllocationFuzz() && (!fireAtEnabled || Options::verboseExecutableAllocationFuzz()))
2332         printf("JSC EXECUTABLE ALLOCATION FUZZ: encountered %u checks.\n", numberOfExecutableAllocationFuzzChecks());
2333     if (Options::useOSRExitFuzz()) {
2334         printf("JSC OSR EXIT FUZZ: encountered %u static checks.\n", numberOfStaticOSRExitFuzzChecks());
2335         printf("JSC OSR EXIT FUZZ: encountered %u dynamic checks.\n", numberOfOSRExitFuzzChecks());
2336     }
2337
2338     auto compileTimeStats = JIT::compileTimeStats();
2339     Vector<CString> compileTimeKeys;
2340     for (auto& entry : compileTimeStats)
2341         compileTimeKeys.append(entry.key);
2342     std::sort(compileTimeKeys.begin(), compileTimeKeys.end());
2343     for (CString key : compileTimeKeys)
2344         printf("%40s: %.3lf ms\n", key.data(), compileTimeStats.get(key));
2345 #endif
2346
2347     return result;
2348 }
2349
2350 int jscmain(int argc, char** argv)
2351 {
2352     // Note that the options parsing can affect VM creation, and thus
2353     // comes first.
2354     CommandLine options(argc, argv);
2355
2356     // Initialize JSC before getting VM.
2357 #if ENABLE(SAMPLING_REGIONS)
2358     WTF::initializeMainThread();
2359 #endif
2360     JSC::initializeThreading();
2361
2362     VM* vm = &VM::create(LargeHeap).leakRef();
2363     int result;
2364     result = runJSC(vm, options);
2365
2366     if (Options::gcAtEnd()) {
2367         // We need to hold the API lock to do a GC.
2368         JSLockHolder locker(vm);
2369         vm->heap.collectAllGarbage();
2370     }
2371
2372     if (options.m_dumpSamplingProfilerData) {
2373 #if ENABLE(SAMPLING_PROFILER)
2374         JSLockHolder locker(vm);
2375         vm->samplingProfiler()->reportTopFunctions();
2376         vm->samplingProfiler()->reportTopBytecodes();
2377 #else
2378         dataLog("Sampling profiler is not enabled on this platform\n");
2379 #endif
2380     }
2381
2382     printSuperSamplerState();
2383
2384     return result;
2385 }
2386
2387 #if OS(WINDOWS)
2388 extern "C" __declspec(dllexport) int WINAPI dllLauncherEntryPoint(int argc, const char* argv[])
2389 {
2390     return main(argc, const_cast<char**>(argv));
2391 }
2392 #endif