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