Cache bytecode to disk
[WebKit-https.git] / Source / JavaScriptCore / jsc.cpp
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2004-2018 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 "ArrayBuffer.h"
26 #include "ArrayPrototype.h"
27 #include "BuiltinNames.h"
28 #include "ButterflyInlines.h"
29 #include "CatchScope.h"
30 #include "CodeBlock.h"
31 #include "CodeCache.h"
32 #include "Completion.h"
33 #include "ConfigFile.h"
34 #include "Disassembler.h"
35 #include "Exception.h"
36 #include "ExceptionHelpers.h"
37 #include "HeapProfiler.h"
38 #include "HeapSnapshotBuilder.h"
39 #include "InitializeThreading.h"
40 #include "Interpreter.h"
41 #include "JIT.h"
42 #include "JSArray.h"
43 #include "JSArrayBuffer.h"
44 #include "JSBigInt.h"
45 #include "JSCInlines.h"
46 #include "JSFunction.h"
47 #include "JSInternalPromise.h"
48 #include "JSInternalPromiseDeferred.h"
49 #include "JSLock.h"
50 #include "JSModuleLoader.h"
51 #include "JSNativeStdFunction.h"
52 #include "JSONObject.h"
53 #include "JSSourceCode.h"
54 #include "JSString.h"
55 #include "JSTypedArrays.h"
56 #include "JSWebAssemblyInstance.h"
57 #include "JSWebAssemblyMemory.h"
58 #include "LLIntThunks.h"
59 #include "ObjectConstructor.h"
60 #include "ParserError.h"
61 #include "ProfilerDatabase.h"
62 #include "PromiseDeferredTimer.h"
63 #include "ProtoCallFrame.h"
64 #include "ReleaseHeapAccessScope.h"
65 #include "SamplingProfiler.h"
66 #include "StackVisitor.h"
67 #include "StructureInlines.h"
68 #include "StructureRareDataInlines.h"
69 #include "SuperSampler.h"
70 #include "TestRunnerUtils.h"
71 #include "TypedArrayInlines.h"
72 #include "WasmContext.h"
73 #include "WasmFaultSignalHandler.h"
74 #include "WasmMemory.h"
75 #include <locale.h>
76 #include <math.h>
77 #include <stdio.h>
78 #include <stdlib.h>
79 #include <string.h>
80 #include <sys/stat.h>
81 #include <sys/types.h>
82 #include <thread>
83 #include <type_traits>
84 #include <wtf/Box.h>
85 #include <wtf/CommaPrinter.h>
86 #include <wtf/MainThread.h>
87 #include <wtf/MemoryPressureHandler.h>
88 #include <wtf/MonotonicTime.h>
89 #include <wtf/NeverDestroyed.h>
90 #include <wtf/StringPrintStream.h>
91 #include <wtf/URL.h>
92 #include <wtf/WallTime.h>
93 #include <wtf/text/StringBuilder.h>
94
95 #if OS(WINDOWS)
96 #include <direct.h>
97 #include <fcntl.h>
98 #include <io.h>
99 #include <wtf/text/win/WCharStringExtras.h>
100 #else
101 #include <unistd.h>
102 #endif
103
104 #if PLATFORM(COCOA)
105 #include <crt_externs.h>
106 #endif
107
108 #if HAVE(READLINE)
109 // readline/history.h has a Function typedef which conflicts with the WTF::Function template from WTF/Forward.h
110 // We #define it to something else to avoid this conflict.
111 #define Function ReadlineFunction
112 #include <readline/history.h>
113 #include <readline/readline.h>
114 #undef Function
115 #endif
116
117 #if HAVE(SYS_TIME_H)
118 #include <sys/time.h>
119 #endif
120
121 #if HAVE(SIGNAL_H)
122 #include <signal.h>
123 #endif
124
125 #if COMPILER(MSVC)
126 #include <crtdbg.h>
127 #include <mmsystem.h>
128 #include <windows.h>
129 #endif
130
131 #if PLATFORM(IOS_FAMILY) && CPU(ARM_THUMB2)
132 #include <fenv.h>
133 #include <arm/arch.h>
134 #endif
135
136 #if __has_include(<WebKitAdditions/MemoryFootprint.h>)
137 #include <WebKitAdditions/MemoryFootprint.h>
138 #else
139 struct MemoryFootprint {
140     uint64_t current;
141     uint64_t peak;
142     
143     static MemoryFootprint now()
144     {
145         return { 0L, 0L };
146     }
147     
148     static void resetPeak()
149     {
150     }
151 };
152 #endif
153
154 #if !defined(PATH_MAX)
155 #define PATH_MAX 4096
156 #endif
157
158 using namespace JSC;
159 using namespace WTF;
160
161 namespace {
162
163 NO_RETURN_WITH_VALUE static void jscExit(int status)
164 {
165     waitForAsynchronousDisassembly();
166     
167 #if ENABLE(DFG_JIT)
168     if (DFG::isCrashing()) {
169         for (;;) {
170 #if OS(WINDOWS)
171             Sleep(1000);
172 #else
173             pause();
174 #endif
175         }
176     }
177 #endif // ENABLE(DFG_JIT)
178     exit(status);
179 }
180
181 class Masquerader : public JSNonFinalObject {
182 public:
183     Masquerader(VM& vm, Structure* structure)
184         : Base(vm, structure)
185     {
186     }
187
188     typedef JSNonFinalObject Base;
189     static const unsigned StructureFlags = Base::StructureFlags | JSC::MasqueradesAsUndefined;
190
191     static Masquerader* create(VM& vm, JSGlobalObject* globalObject)
192     {
193         globalObject->masqueradesAsUndefinedWatchpoint()->fireAll(vm, "Masquerading object allocated");
194         Structure* structure = createStructure(vm, globalObject, jsNull());
195         Masquerader* result = new (NotNull, allocateCell<Masquerader>(vm.heap, sizeof(Masquerader))) Masquerader(vm, structure);
196         result->finishCreation(vm);
197         return result;
198     }
199
200     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
201     {
202         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
203     }
204
205     DECLARE_INFO;
206 };
207
208 const ClassInfo Masquerader::s_info = { "Masquerader", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(Masquerader) };
209 static unsigned asyncTestPasses { 0 };
210 static unsigned asyncTestExpectedPasses { 0 };
211
212 }
213
214 template<typename Vector>
215 static bool fillBufferWithContentsOfFile(const String& fileName, Vector& buffer);
216 static RefPtr<Uint8Array> fillBufferWithContentsOfFile(const String& fileName);
217
218 class CommandLine;
219 class GlobalObject;
220 class Workers;
221
222 template<typename Func>
223 int runJSC(const CommandLine&, bool isWorker, const Func&);
224 static void checkException(ExecState*, GlobalObject*, bool isLastFile, bool hasException, JSValue, CommandLine&, bool& success);
225
226 class Message : public ThreadSafeRefCounted<Message> {
227 public:
228     Message(ArrayBufferContents&&, int32_t);
229     ~Message();
230     
231     ArrayBufferContents&& releaseContents() { return WTFMove(m_contents); }
232     int32_t index() const { return m_index; }
233
234 private:
235     ArrayBufferContents m_contents;
236     int32_t m_index { 0 };
237 };
238
239 class Worker : public BasicRawSentinelNode<Worker> {
240 public:
241     Worker(Workers&);
242     ~Worker();
243     
244     void enqueue(const AbstractLocker&, RefPtr<Message>);
245     RefPtr<Message> dequeue();
246     
247     static Worker& current();
248
249 private:
250     static ThreadSpecific<Worker*>& currentWorker();
251
252     Workers& m_workers;
253     Deque<RefPtr<Message>> m_messages;
254 };
255
256 class Workers {
257 public:
258     Workers();
259     ~Workers();
260     
261     template<typename Func>
262     void broadcast(const Func&);
263     
264     void report(const String&);
265     String tryGetReport();
266     String getReport();
267     
268     static Workers& singleton();
269     
270 private:
271     friend class Worker;
272     
273     Lock m_lock;
274     Condition m_condition;
275     SentinelLinkedList<Worker, BasicRawSentinelNode<Worker>> m_workers;
276     Deque<String> m_reports;
277 };
278
279
280 static EncodedJSValue JSC_HOST_CALL functionCreateGlobalObject(ExecState*);
281
282 static EncodedJSValue JSC_HOST_CALL functionPrintStdOut(ExecState*);
283 static EncodedJSValue JSC_HOST_CALL functionPrintStdErr(ExecState*);
284 static EncodedJSValue JSC_HOST_CALL functionDebug(ExecState*);
285 static EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState*);
286 static EncodedJSValue JSC_HOST_CALL functionDescribeArray(ExecState*);
287 static EncodedJSValue JSC_HOST_CALL functionSleepSeconds(ExecState*);
288 static EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState*);
289 static EncodedJSValue JSC_HOST_CALL functionGCAndSweep(ExecState*);
290 static EncodedJSValue JSC_HOST_CALL functionFullGC(ExecState*);
291 static EncodedJSValue JSC_HOST_CALL functionEdenGC(ExecState*);
292 static EncodedJSValue JSC_HOST_CALL functionForceGCSlowPaths(ExecState*);
293 static EncodedJSValue JSC_HOST_CALL functionHeapSize(ExecState*);
294 static EncodedJSValue JSC_HOST_CALL functionCreateMemoryFootprint(ExecState*);
295 static EncodedJSValue JSC_HOST_CALL functionResetMemoryPeak(ExecState*);
296 static EncodedJSValue JSC_HOST_CALL functionAddressOf(ExecState*);
297 static EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*);
298 static EncodedJSValue JSC_HOST_CALL functionRun(ExecState*);
299 static EncodedJSValue JSC_HOST_CALL functionRunString(ExecState*);
300 static EncodedJSValue JSC_HOST_CALL functionLoad(ExecState*);
301 static EncodedJSValue JSC_HOST_CALL functionLoadString(ExecState*);
302 static EncodedJSValue JSC_HOST_CALL functionReadFile(ExecState*);
303 static EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState*);
304 static EncodedJSValue JSC_HOST_CALL functionReadline(ExecState*);
305 static EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*);
306 static EncodedJSValue JSC_HOST_CALL functionNeverInlineFunction(ExecState*);
307 static EncodedJSValue JSC_HOST_CALL functionNoDFG(ExecState*);
308 static EncodedJSValue JSC_HOST_CALL functionNoFTL(ExecState*);
309 static EncodedJSValue JSC_HOST_CALL functionNoOSRExitFuzzing(ExecState*);
310 static EncodedJSValue JSC_HOST_CALL functionOptimizeNextInvocation(ExecState*);
311 static EncodedJSValue JSC_HOST_CALL functionNumberOfDFGCompiles(ExecState*);
312 static EncodedJSValue JSC_HOST_CALL functionJSCOptions(ExecState*);
313 static EncodedJSValue JSC_HOST_CALL functionReoptimizationRetryCount(ExecState*);
314 static EncodedJSValue JSC_HOST_CALL functionTransferArrayBuffer(ExecState*);
315 static EncodedJSValue JSC_HOST_CALL functionFailNextNewCodeBlock(ExecState*);
316 static NO_RETURN_WITH_VALUE EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*);
317 static EncodedJSValue JSC_HOST_CALL functionFalse(ExecState*);
318 static EncodedJSValue JSC_HOST_CALL functionUndefined1(ExecState*);
319 static EncodedJSValue JSC_HOST_CALL functionUndefined2(ExecState*);
320 static EncodedJSValue JSC_HOST_CALL functionIsInt32(ExecState*);
321 static EncodedJSValue JSC_HOST_CALL functionIsPureNaN(ExecState*);
322 static EncodedJSValue JSC_HOST_CALL functionEffectful42(ExecState*);
323 static EncodedJSValue JSC_HOST_CALL functionIdentity(ExecState*);
324 static EncodedJSValue JSC_HOST_CALL functionMakeMasquerader(ExecState*);
325 static EncodedJSValue JSC_HOST_CALL functionHasCustomProperties(ExecState*);
326 static EncodedJSValue JSC_HOST_CALL functionDumpTypesForAllVariables(ExecState*);
327 static EncodedJSValue JSC_HOST_CALL functionDrainMicrotasks(ExecState*);
328 static EncodedJSValue JSC_HOST_CALL functionIs32BitPlatform(ExecState*);
329 static EncodedJSValue JSC_HOST_CALL functionCheckModuleSyntax(ExecState*);
330 static EncodedJSValue JSC_HOST_CALL functionPlatformSupportsSamplingProfiler(ExecState*);
331 static EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshot(ExecState*);
332 static EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshotForGCDebugging(ExecState*);
333 static EncodedJSValue JSC_HOST_CALL functionResetSuperSamplerState(ExecState*);
334 static EncodedJSValue JSC_HOST_CALL functionEnsureArrayStorage(ExecState*);
335 #if ENABLE(SAMPLING_PROFILER)
336 static EncodedJSValue JSC_HOST_CALL functionStartSamplingProfiler(ExecState*);
337 static EncodedJSValue JSC_HOST_CALL functionSamplingProfilerStackTraces(ExecState*);
338 #endif
339
340 static EncodedJSValue JSC_HOST_CALL functionMaxArguments(ExecState*);
341 static EncodedJSValue JSC_HOST_CALL functionAsyncTestStart(ExecState*);
342 static EncodedJSValue JSC_HOST_CALL functionAsyncTestPassed(ExecState*);
343
344 #if ENABLE(WEBASSEMBLY)
345 static EncodedJSValue JSC_HOST_CALL functionWebAssemblyMemoryMode(ExecState*);
346 #endif
347
348 #if ENABLE(SAMPLING_FLAGS)
349 static EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*);
350 static EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState*);
351 #endif
352
353 static EncodedJSValue JSC_HOST_CALL functionGetRandomSeed(ExecState*);
354 static EncodedJSValue JSC_HOST_CALL functionSetRandomSeed(ExecState*);
355 static EncodedJSValue JSC_HOST_CALL functionIsRope(ExecState*);
356 static EncodedJSValue JSC_HOST_CALL functionCallerSourceOrigin(ExecState*);
357 static EncodedJSValue JSC_HOST_CALL functionDollarCreateRealm(ExecState*);
358 static EncodedJSValue JSC_HOST_CALL functionDollarDetachArrayBuffer(ExecState*);
359 static EncodedJSValue JSC_HOST_CALL functionDollarEvalScript(ExecState*);
360 static EncodedJSValue JSC_HOST_CALL functionDollarAgentStart(ExecState*);
361 static EncodedJSValue JSC_HOST_CALL functionDollarAgentReceiveBroadcast(ExecState*);
362 static EncodedJSValue JSC_HOST_CALL functionDollarAgentReport(ExecState*);
363 static EncodedJSValue JSC_HOST_CALL functionDollarAgentSleep(ExecState*);
364 static EncodedJSValue JSC_HOST_CALL functionDollarAgentBroadcast(ExecState*);
365 static EncodedJSValue JSC_HOST_CALL functionDollarAgentGetReport(ExecState*);
366 static EncodedJSValue JSC_HOST_CALL functionDollarAgentLeaving(ExecState*);
367 static EncodedJSValue JSC_HOST_CALL functionDollarAgentMonotonicNow(ExecState*);
368 static EncodedJSValue JSC_HOST_CALL functionWaitForReport(ExecState*);
369 static EncodedJSValue JSC_HOST_CALL functionHeapCapacity(ExecState*);
370 static EncodedJSValue JSC_HOST_CALL functionFlashHeapAccess(ExecState*);
371 static EncodedJSValue JSC_HOST_CALL functionDisableRichSourceInfo(ExecState*);
372 static EncodedJSValue JSC_HOST_CALL functionMallocInALoop(ExecState*);
373 static EncodedJSValue JSC_HOST_CALL functionTotalCompileTime(ExecState*);
374
375 struct Script {
376     enum class StrictMode {
377         Strict,
378         Sloppy
379     };
380
381     enum class ScriptType {
382         Script,
383         Module
384     };
385
386     enum class CodeSource {
387         File,
388         CommandLine
389     };
390
391     StrictMode strictMode;
392     CodeSource codeSource;
393     ScriptType scriptType;
394     char* argument;
395
396     Script(StrictMode strictMode, CodeSource codeSource, ScriptType scriptType, char *argument)
397         : strictMode(strictMode)
398         , codeSource(codeSource)
399         , scriptType(scriptType)
400         , argument(argument)
401     {
402         if (strictMode == StrictMode::Strict)
403             ASSERT(codeSource == CodeSource::File);
404     }
405 };
406
407 class CommandLine {
408 public:
409     CommandLine(int argc, char** argv)
410     {
411         parseArguments(argc, argv);
412     }
413
414     bool m_interactive { false };
415     bool m_dump { false };
416     bool m_module { false };
417     bool m_exitCode { false };
418     Vector<Script> m_scripts;
419     Vector<String> m_arguments;
420     bool m_profile { false };
421     String m_profilerOutput;
422     String m_uncaughtExceptionName;
423     bool m_treatWatchdogExceptionAsSuccess { false };
424     bool m_alwaysDumpUncaughtException { false };
425     bool m_dumpMemoryFootprint { false };
426     bool m_dumpSamplingProfilerData { false };
427     bool m_enableRemoteDebugging { false };
428
429     void parseArguments(int, char**);
430 };
431
432 static const char interactivePrompt[] = ">>> ";
433
434 class StopWatch {
435 public:
436     void start();
437     void stop();
438     long getElapsedMS(); // call stop() first
439
440 private:
441     MonotonicTime m_startTime;
442     MonotonicTime m_stopTime;
443 };
444
445 void StopWatch::start()
446 {
447     m_startTime = MonotonicTime::now();
448 }
449
450 void StopWatch::stop()
451 {
452     m_stopTime = MonotonicTime::now();
453 }
454
455 long StopWatch::getElapsedMS()
456 {
457     return (m_stopTime - m_startTime).millisecondsAs<long>();
458 }
459
460 template<typename Vector>
461 static inline String stringFromUTF(const Vector& utf8)
462 {
463     return String::fromUTF8WithLatin1Fallback(utf8.data(), utf8.size());
464 }
465
466 class GlobalObject : public JSGlobalObject {
467 private:
468     GlobalObject(VM&, Structure*);
469
470 public:
471     typedef JSGlobalObject Base;
472
473     static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)
474     {
475         GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure);
476         object->finishCreation(vm, arguments);
477         return object;
478     }
479
480     static const bool needsDestruction = false;
481
482     DECLARE_INFO;
483     static const GlobalObjectMethodTable s_globalObjectMethodTable;
484
485     static Structure* createStructure(VM& vm, JSValue prototype)
486     {
487         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
488     }
489
490     static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags::createAllEnabled(); }
491
492 protected:
493     void finishCreation(VM& vm, const Vector<String>& arguments)
494     {
495         Base::finishCreation(vm);
496
497         addFunction(vm, "debug", functionDebug, 1);
498         addFunction(vm, "describe", functionDescribe, 1);
499         addFunction(vm, "describeArray", functionDescribeArray, 1);
500         addFunction(vm, "print", functionPrintStdOut, 1);
501         addFunction(vm, "printErr", functionPrintStdErr, 1);
502         addFunction(vm, "quit", functionQuit, 0);
503         addFunction(vm, "gc", functionGCAndSweep, 0);
504         addFunction(vm, "fullGC", functionFullGC, 0);
505         addFunction(vm, "edenGC", functionEdenGC, 0);
506         addFunction(vm, "forceGCSlowPaths", functionForceGCSlowPaths, 0);
507         addFunction(vm, "gcHeapSize", functionHeapSize, 0);
508         addFunction(vm, "MemoryFootprint", functionCreateMemoryFootprint, 0);
509         addFunction(vm, "resetMemoryPeak", functionResetMemoryPeak, 0);
510         addFunction(vm, "addressOf", functionAddressOf, 1);
511         addFunction(vm, "version", functionVersion, 1);
512         addFunction(vm, "run", functionRun, 1);
513         addFunction(vm, "runString", functionRunString, 1);
514         addFunction(vm, "load", functionLoad, 1);
515         addFunction(vm, "loadString", functionLoadString, 1);
516         addFunction(vm, "readFile", functionReadFile, 2);
517         addFunction(vm, "read", functionReadFile, 2);
518         addFunction(vm, "checkSyntax", functionCheckSyntax, 1);
519         addFunction(vm, "sleepSeconds", functionSleepSeconds, 1);
520         addFunction(vm, "jscStack", functionJSCStack, 1);
521         addFunction(vm, "readline", functionReadline, 0);
522         addFunction(vm, "preciseTime", functionPreciseTime, 0);
523         addFunction(vm, "neverInlineFunction", functionNeverInlineFunction, 1);
524         addFunction(vm, "noInline", functionNeverInlineFunction, 1);
525         addFunction(vm, "noDFG", functionNoDFG, 1);
526         addFunction(vm, "noFTL", functionNoFTL, 1);
527         addFunction(vm, "noOSRExitFuzzing", functionNoOSRExitFuzzing, 1);
528         addFunction(vm, "numberOfDFGCompiles", functionNumberOfDFGCompiles, 1);
529         addFunction(vm, "jscOptions", functionJSCOptions, 0);
530         addFunction(vm, "optimizeNextInvocation", functionOptimizeNextInvocation, 1);
531         addFunction(vm, "reoptimizationRetryCount", functionReoptimizationRetryCount, 1);
532         addFunction(vm, "transferArrayBuffer", functionTransferArrayBuffer, 1);
533         addFunction(vm, "failNextNewCodeBlock", functionFailNextNewCodeBlock, 1);
534 #if ENABLE(SAMPLING_FLAGS)
535         addFunction(vm, "setSamplingFlags", functionSetSamplingFlags, 1);
536         addFunction(vm, "clearSamplingFlags", functionClearSamplingFlags, 1);
537 #endif
538
539         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "OSRExit"), 0, functionUndefined1, OSRExitIntrinsic, static_cast<unsigned>(PropertyAttribute::DontEnum));
540         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "isFinalTier"), 0, functionFalse, IsFinalTierIntrinsic, static_cast<unsigned>(PropertyAttribute::DontEnum));
541         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "predictInt32"), 0, functionUndefined2, SetInt32HeapPredictionIntrinsic, static_cast<unsigned>(PropertyAttribute::DontEnum));
542         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "isInt32"), 0, functionIsInt32, CheckInt32Intrinsic, static_cast<unsigned>(PropertyAttribute::DontEnum));
543         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "isPureNaN"), 0, functionIsPureNaN, CheckInt32Intrinsic, static_cast<unsigned>(PropertyAttribute::DontEnum));
544         putDirectNativeFunction(vm, this, Identifier::fromString(&vm, "fiatInt52"), 0, functionIdentity, FiatInt52Intrinsic, static_cast<unsigned>(PropertyAttribute::DontEnum));
545         
546         addFunction(vm, "effectful42", functionEffectful42, 0);
547         addFunction(vm, "makeMasquerader", functionMakeMasquerader, 0);
548         addFunction(vm, "hasCustomProperties", functionHasCustomProperties, 0);
549
550         addFunction(vm, "createGlobalObject", functionCreateGlobalObject, 0);
551
552         addFunction(vm, "dumpTypesForAllVariables", functionDumpTypesForAllVariables , 0);
553
554         addFunction(vm, "drainMicrotasks", functionDrainMicrotasks, 0);
555
556         addFunction(vm, "getRandomSeed", functionGetRandomSeed, 0);
557         addFunction(vm, "setRandomSeed", functionSetRandomSeed, 1);
558         addFunction(vm, "isRope", functionIsRope, 1);
559         addFunction(vm, "callerSourceOrigin", functionCallerSourceOrigin, 0);
560
561         addFunction(vm, "is32BitPlatform", functionIs32BitPlatform, 0);
562
563         addFunction(vm, "checkModuleSyntax", functionCheckModuleSyntax, 1);
564
565         addFunction(vm, "platformSupportsSamplingProfiler", functionPlatformSupportsSamplingProfiler, 0);
566         addFunction(vm, "generateHeapSnapshot", functionGenerateHeapSnapshot, 0);
567         addFunction(vm, "generateHeapSnapshotForGCDebugging", functionGenerateHeapSnapshotForGCDebugging, 0);
568         addFunction(vm, "resetSuperSamplerState", functionResetSuperSamplerState, 0);
569         addFunction(vm, "ensureArrayStorage", functionEnsureArrayStorage, 0);
570 #if ENABLE(SAMPLING_PROFILER)
571         addFunction(vm, "startSamplingProfiler", functionStartSamplingProfiler, 0);
572         addFunction(vm, "samplingProfilerStackTraces", functionSamplingProfilerStackTraces, 0);
573 #endif
574
575         addFunction(vm, "maxArguments", functionMaxArguments, 0);
576
577         addFunction(vm, "asyncTestStart", functionAsyncTestStart, 1);
578         addFunction(vm, "asyncTestPassed", functionAsyncTestPassed, 1);
579
580 #if ENABLE(WEBASSEMBLY)
581         addFunction(vm, "WebAssemblyMemoryMode", functionWebAssemblyMemoryMode, 1);
582 #endif
583
584         if (!arguments.isEmpty()) {
585             JSArray* array = constructEmptyArray(globalExec(), 0);
586             for (size_t i = 0; i < arguments.size(); ++i)
587                 array->putDirectIndex(globalExec(), i, jsString(globalExec(), arguments[i]));
588             putDirect(vm, Identifier::fromString(globalExec(), "arguments"), array);
589         }
590
591         putDirect(vm, Identifier::fromString(globalExec(), "console"), jsUndefined());
592         
593         Structure* plainObjectStructure = JSFinalObject::createStructure(vm, this, objectPrototype(), 0);
594         
595         JSObject* dollar = JSFinalObject::create(vm, plainObjectStructure);
596         putDirect(vm, Identifier::fromString(globalExec(), "$"), dollar);
597         putDirect(vm, Identifier::fromString(globalExec(), "$262"), dollar);
598         
599         addFunction(vm, dollar, "createRealm", functionDollarCreateRealm, 0);
600         addFunction(vm, dollar, "detachArrayBuffer", functionDollarDetachArrayBuffer, 1);
601         addFunction(vm, dollar, "evalScript", functionDollarEvalScript, 1);
602         
603         dollar->putDirect(vm, Identifier::fromString(globalExec(), "global"), this);
604         
605         JSObject* agent = JSFinalObject::create(vm, plainObjectStructure);
606         dollar->putDirect(vm, Identifier::fromString(globalExec(), "agent"), agent);
607         
608         // The test262 INTERPRETING.md document says that some of these functions are just in the main
609         // thread and some are in the other threads. We just put them in all threads.
610         addFunction(vm, agent, "start", functionDollarAgentStart, 1);
611         addFunction(vm, agent, "receiveBroadcast", functionDollarAgentReceiveBroadcast, 1);
612         addFunction(vm, agent, "report", functionDollarAgentReport, 1);
613         addFunction(vm, agent, "sleep", functionDollarAgentSleep, 1);
614         addFunction(vm, agent, "broadcast", functionDollarAgentBroadcast, 1);
615         addFunction(vm, agent, "getReport", functionDollarAgentGetReport, 0);
616         addFunction(vm, agent, "leaving", functionDollarAgentLeaving, 0);
617         addFunction(vm, agent, "monotonicNow", functionDollarAgentMonotonicNow, 0);
618
619         addFunction(vm, "waitForReport", functionWaitForReport, 0);
620
621         addFunction(vm, "heapCapacity", functionHeapCapacity, 0);
622         addFunction(vm, "flashHeapAccess", functionFlashHeapAccess, 0);
623
624         addFunction(vm, "disableRichSourceInfo", functionDisableRichSourceInfo, 0);
625         addFunction(vm, "mallocInALoop", functionMallocInALoop, 0);
626         addFunction(vm, "totalCompileTime", functionTotalCompileTime, 0);
627     }
628     
629     void addFunction(VM& vm, JSObject* object, const char* name, NativeFunction function, unsigned arguments)
630     {
631         Identifier identifier = Identifier::fromString(&vm, name);
632         object->putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function));
633     }
634
635     void addFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)
636     {
637         addFunction(vm, this, name, function, arguments);
638     }
639     
640     static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject*, ExecState*, JSModuleLoader*, JSString*, JSValue, const SourceOrigin&);
641     static Identifier moduleLoaderResolve(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
642     static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
643     static JSObject* moduleLoaderCreateImportMetaProperties(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSModuleRecord*, JSValue);
644 };
645
646 static bool supportsRichSourceInfo = true;
647 static bool shellSupportsRichSourceInfo(const JSGlobalObject*)
648 {
649     return supportsRichSourceInfo;
650 }
651
652 const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(GlobalObject) };
653 const GlobalObjectMethodTable GlobalObject::s_globalObjectMethodTable = {
654     &shellSupportsRichSourceInfo,
655     &shouldInterruptScript,
656     &javaScriptRuntimeFlags,
657     nullptr, // queueTaskToEventLoop
658     &shouldInterruptScriptBeforeTimeout,
659     &moduleLoaderImportModule,
660     &moduleLoaderResolve,
661     &moduleLoaderFetch,
662     &moduleLoaderCreateImportMetaProperties,
663     nullptr, // moduleLoaderEvaluate
664     nullptr, // promiseRejectionTracker
665     nullptr, // defaultLanguage
666     nullptr, // compileStreaming
667     nullptr, // instantinateStreaming
668 };
669
670 GlobalObject::GlobalObject(VM& vm, Structure* structure)
671     : JSGlobalObject(vm, structure, &s_globalObjectMethodTable)
672 {
673 }
674
675 static UChar pathSeparator()
676 {
677 #if OS(WINDOWS)
678     return '\\';
679 #else
680     return '/';
681 #endif
682 }
683
684 struct DirectoryName {
685     // In unix, it is "/". In Windows, it becomes a drive letter like "C:\"
686     String rootName;
687
688     // If the directory name is "/home/WebKit", this becomes "home/WebKit". If the directory name is "/", this becomes "".
689     String queryName;
690 };
691
692 struct ModuleName {
693     ModuleName(const String& moduleName);
694
695     bool startsWithRoot() const
696     {
697         return !queries.isEmpty() && queries[0].isEmpty();
698     }
699
700     Vector<String> queries;
701 };
702
703 ModuleName::ModuleName(const String& moduleName)
704 {
705     // A module name given from code is represented as the UNIX style path. Like, `./A/B.js`.
706     queries = moduleName.splitAllowingEmptyEntries('/');
707 }
708
709 static Optional<DirectoryName> extractDirectoryName(const String& absolutePathToFile)
710 {
711     size_t firstSeparatorPosition = absolutePathToFile.find(pathSeparator());
712     if (firstSeparatorPosition == notFound)
713         return WTF::nullopt;
714     DirectoryName directoryName;
715     directoryName.rootName = absolutePathToFile.substring(0, firstSeparatorPosition + 1); // Include the separator.
716     size_t lastSeparatorPosition = absolutePathToFile.reverseFind(pathSeparator());
717     ASSERT_WITH_MESSAGE(lastSeparatorPosition != notFound, "If the separator is not found, this function already returns when performing the forward search.");
718     if (firstSeparatorPosition == lastSeparatorPosition)
719         directoryName.queryName = StringImpl::empty();
720     else {
721         size_t queryStartPosition = firstSeparatorPosition + 1;
722         size_t queryLength = lastSeparatorPosition - queryStartPosition; // Not include the last separator.
723         directoryName.queryName = absolutePathToFile.substring(queryStartPosition, queryLength);
724     }
725     return directoryName;
726 }
727
728 static Optional<DirectoryName> currentWorkingDirectory()
729 {
730 #if OS(WINDOWS)
731     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364934.aspx
732     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx#maxpath
733     // The _MAX_PATH in Windows is 260. If the path of the current working directory is longer than that, _getcwd truncates the result.
734     // And other I/O functions taking a path name also truncate it. To avoid this situation,
735     //
736     // (1). When opening the file in Windows for modules, we always use the abosolute path and add "\\?\" prefix to the path name.
737     // (2). When retrieving the current working directory, use GetCurrentDirectory instead of _getcwd.
738     //
739     // In the path utility functions inside the JSC shell, we does not handle the UNC and UNCW including the network host name.
740     DWORD bufferLength = ::GetCurrentDirectoryW(0, nullptr);
741     if (!bufferLength)
742         return WTF::nullopt;
743     // In Windows, wchar_t is the UTF-16LE.
744     // https://msdn.microsoft.com/en-us/library/dd374081.aspx
745     // https://msdn.microsoft.com/en-us/library/windows/desktop/ff381407.aspx
746     Vector<wchar_t> buffer(bufferLength);
747     DWORD lengthNotIncludingNull = ::GetCurrentDirectoryW(bufferLength, buffer.data());
748     String directoryString = wcharToString(buffer.data(), lengthNotIncludingNull);
749     // We don't support network path like \\host\share\<path name>.
750     if (directoryString.startsWith("\\\\"))
751         return WTF::nullopt;
752 #else
753     Vector<char> buffer(PATH_MAX);
754     if (!getcwd(buffer.data(), PATH_MAX))
755         return WTF::nullopt;
756     String directoryString = String::fromUTF8(buffer.data());
757 #endif
758     if (directoryString.isEmpty())
759         return WTF::nullopt;
760
761     if (directoryString[directoryString.length() - 1] == pathSeparator())
762         return extractDirectoryName(directoryString);
763     // Append the seperator to represents the file name. extractDirectoryName only accepts the absolute file name.
764     return extractDirectoryName(makeString(directoryString, pathSeparator()));
765 }
766
767 static String resolvePath(const DirectoryName& directoryName, const ModuleName& moduleName)
768 {
769     Vector<String> directoryPieces = directoryName.queryName.split(pathSeparator());
770
771     // Only first '/' is recognized as the path from the root.
772     if (moduleName.startsWithRoot())
773         directoryPieces.clear();
774
775     for (const auto& query : moduleName.queries) {
776         if (query == String(".."_s)) {
777             if (!directoryPieces.isEmpty())
778                 directoryPieces.removeLast();
779         } else if (!query.isEmpty() && query != String("."_s))
780             directoryPieces.append(query);
781     }
782
783     StringBuilder builder;
784     builder.append(directoryName.rootName);
785     for (size_t i = 0; i < directoryPieces.size(); ++i) {
786         builder.append(directoryPieces[i]);
787         if (i + 1 != directoryPieces.size())
788             builder.append(pathSeparator());
789     }
790     return builder.toString();
791 }
792
793 static String absolutePath(const String& fileName)
794 {
795     auto directoryName = currentWorkingDirectory();
796     if (!directoryName)
797         return fileName;
798     return resolvePath(directoryName.value(), ModuleName(fileName.impl()));
799 }
800
801 JSInternalPromise* GlobalObject::moduleLoaderImportModule(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSString* moduleNameValue, JSValue parameters, const SourceOrigin& sourceOrigin)
802 {
803     VM& vm = globalObject->vm();
804     auto throwScope = DECLARE_THROW_SCOPE(vm);
805
806     auto* deferred = JSInternalPromiseDeferred::tryCreate(exec, globalObject);
807     RETURN_IF_EXCEPTION(throwScope, nullptr);
808
809     auto catchScope = DECLARE_CATCH_SCOPE(vm);
810     auto reject = [&] (JSValue rejectionReason) {
811         catchScope.clearException();
812         auto result = deferred->reject(exec, rejectionReason);
813         catchScope.clearException();
814         return result;
815     };
816
817     if (sourceOrigin.isNull())
818         return reject(createError(exec, "Could not resolve the module specifier."_s));
819
820     const auto& referrer = sourceOrigin.string();
821     const auto& moduleName = moduleNameValue->value(exec);
822     if (UNLIKELY(catchScope.exception()))
823         return reject(catchScope.exception());
824
825     auto directoryName = extractDirectoryName(referrer.impl());
826     if (!directoryName)
827         return reject(createError(exec, makeString("Could not resolve the referrer name '", String(referrer.impl()), "'.")));
828
829     auto result = JSC::importModule(exec, Identifier::fromString(&vm, resolvePath(directoryName.value(), ModuleName(moduleName))), parameters, jsUndefined());
830     if (UNLIKELY(catchScope.exception()))
831         return reject(catchScope.exception());
832     return result;
833 }
834
835 Identifier GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue)
836 {
837     VM& vm = globalObject->vm();
838     auto scope = DECLARE_THROW_SCOPE(vm);
839
840     scope.releaseAssertNoException();
841     const Identifier key = keyValue.toPropertyKey(exec);
842     RETURN_IF_EXCEPTION(scope, { });
843
844     if (key.isSymbol())
845         return key;
846
847     if (referrerValue.isUndefined()) {
848         auto directoryName = currentWorkingDirectory();
849         if (!directoryName) {
850             throwException(exec, scope, createError(exec, "Could not resolve the current working directory."_s));
851             return { };
852         }
853         return Identifier::fromString(&vm, resolvePath(directoryName.value(), ModuleName(key.impl())));
854     }
855
856     const Identifier referrer = referrerValue.toPropertyKey(exec);
857     RETURN_IF_EXCEPTION(scope, { });
858
859     if (referrer.isSymbol()) {
860         auto directoryName = currentWorkingDirectory();
861         if (!directoryName) {
862             throwException(exec, scope, createError(exec, "Could not resolve the current working directory."_s));
863             return { };
864         }
865         return Identifier::fromString(&vm, resolvePath(directoryName.value(), ModuleName(key.impl())));
866     }
867
868     // If the referrer exists, we assume that the referrer is the correct absolute path.
869     auto directoryName = extractDirectoryName(referrer.impl());
870     if (!directoryName) {
871         throwException(exec, scope, createError(exec, makeString("Could not resolve the referrer name '", String(referrer.impl()), "'.")));
872         return { };
873     }
874     return Identifier::fromString(&vm, resolvePath(directoryName.value(), ModuleName(key.impl())));
875 }
876
877 template<typename Vector>
878 static void convertShebangToJSComment(Vector& buffer)
879 {
880     if (buffer.size() >= 2) {
881         if (buffer[0] == '#' && buffer[1] == '!')
882             buffer[0] = buffer[1] = '/';
883     }
884 }
885
886 static RefPtr<Uint8Array> fillBufferWithContentsOfFile(FILE* file)
887 {
888     if (fseek(file, 0, SEEK_END) == -1)
889         return nullptr;
890     long bufferCapacity = ftell(file);
891     if (bufferCapacity == -1)
892         return nullptr;
893     if (fseek(file, 0, SEEK_SET) == -1)
894         return nullptr;
895     auto result = Uint8Array::tryCreate(bufferCapacity);
896     if (!result)
897         return nullptr;
898     size_t readSize = fread(result->data(), 1, bufferCapacity, file);
899     if (readSize != static_cast<size_t>(bufferCapacity))
900         return nullptr;
901     return result;
902 }
903
904 static RefPtr<Uint8Array> fillBufferWithContentsOfFile(const String& fileName)
905 {
906     FILE* f = fopen(fileName.utf8().data(), "rb");
907     if (!f) {
908         fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
909         return nullptr;
910     }
911
912     RefPtr<Uint8Array> result = fillBufferWithContentsOfFile(f);
913     fclose(f);
914
915     return result;
916 }
917
918 template<typename Vector>
919 static bool fillBufferWithContentsOfFile(FILE* file, Vector& buffer)
920 {
921     // We might have injected "use strict"; at the top.
922     size_t initialSize = buffer.size();
923     if (fseek(file, 0, SEEK_END) == -1)
924         return false;
925     long bufferCapacity = ftell(file);
926     if (bufferCapacity == -1)
927         return false;
928     if (fseek(file, 0, SEEK_SET) == -1)
929         return false;
930     buffer.resize(bufferCapacity + initialSize);
931     size_t readSize = fread(buffer.data() + initialSize, 1, buffer.size(), file);
932     return readSize == buffer.size() - initialSize;
933 }
934
935 static bool fillBufferWithContentsOfFile(const String& fileName, Vector<char>& buffer)
936 {
937     FILE* f = fopen(fileName.utf8().data(), "rb");
938     if (!f) {
939         fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
940         return false;
941     }
942
943     bool result = fillBufferWithContentsOfFile(f, buffer);
944     fclose(f);
945
946     return result;
947 }
948
949 static bool fetchScriptFromLocalFileSystem(const String& fileName, Vector<char>& buffer)
950 {
951     if (!fillBufferWithContentsOfFile(fileName, buffer))
952         return false;
953     convertShebangToJSComment(buffer);
954     return true;
955 }
956
957 template<typename Vector>
958 static inline SourceCode jscSource(const Vector& utf8, const SourceOrigin& sourceOrigin, const String& filename)
959 {
960     // FIXME: This should use an absolute file URL https://bugs.webkit.org/show_bug.cgi?id=193077
961     String str = stringFromUTF(utf8);
962     return makeSource(str, sourceOrigin, URL({ }, filename));
963 }
964
965 template<typename Vector>
966 static bool fetchModuleFromLocalFileSystem(const String& fileName, Vector& buffer)
967 {
968     // We assume that fileName is always an absolute path.
969 #if OS(WINDOWS)
970     // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx#maxpath
971     // Use long UNC to pass the long path name to the Windows APIs.
972     String longUNCPathName = WTF::makeString("\\\\?\\", fileName);
973     auto pathName = stringToNullTerminatedWChar(longUNCPathName);
974     struct _stat status { };
975     if (_wstat(pathName.data(), &status))
976         return false;
977     if ((status.st_mode & S_IFMT) != S_IFREG)
978         return false;
979
980     FILE* f = _wfopen(pathName.data(), L"rb");
981 #else
982     auto pathName = fileName.utf8();
983     struct stat status { };
984     if (stat(pathName.data(), &status))
985         return false;
986     if ((status.st_mode & S_IFMT) != S_IFREG)
987         return false;
988
989     FILE* f = fopen(pathName.data(), "r");
990 #endif
991     if (!f) {
992         fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
993         return false;
994     }
995
996     bool result = fillBufferWithContentsOfFile(f, buffer);
997     if (result)
998         convertShebangToJSComment(buffer);
999     fclose(f);
1000
1001     return result;
1002 }
1003
1004 JSInternalPromise* GlobalObject::moduleLoaderFetch(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue key, JSValue, JSValue)
1005 {
1006     VM& vm = globalObject->vm();
1007     auto throwScope = DECLARE_THROW_SCOPE(vm);
1008     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(exec, globalObject);
1009     RETURN_IF_EXCEPTION(throwScope, nullptr);
1010
1011     auto catchScope = DECLARE_CATCH_SCOPE(vm);
1012     auto reject = [&] (JSValue rejectionReason) {
1013         catchScope.clearException();
1014         auto result = deferred->reject(exec, rejectionReason);
1015         catchScope.clearException();
1016         return result;
1017     };
1018
1019     String moduleKey = key.toWTFString(exec);
1020     if (UNLIKELY(catchScope.exception()))
1021         return reject(catchScope.exception());
1022
1023     // Here, now we consider moduleKey as the fileName.
1024     Vector<uint8_t> buffer;
1025     if (!fetchModuleFromLocalFileSystem(moduleKey, buffer))
1026         return reject(createError(exec, makeString("Could not open file '", moduleKey, "'.")));
1027
1028
1029     URL moduleURL = URL({ }, moduleKey);
1030 #if ENABLE(WEBASSEMBLY)
1031     // FileSystem does not have mime-type header. The JSC shell recognizes WebAssembly's magic header.
1032     if (buffer.size() >= 4) {
1033         if (buffer[0] == '\0' && buffer[1] == 'a' && buffer[2] == 's' && buffer[3] == 'm') {
1034             auto source = SourceCode(WebAssemblySourceProvider::create(WTFMove(buffer), SourceOrigin { moduleKey }, WTFMove(moduleURL)));
1035             catchScope.releaseAssertNoException();
1036             auto sourceCode = JSSourceCode::create(vm, WTFMove(source));
1037             catchScope.releaseAssertNoException();
1038             auto result = deferred->resolve(exec, sourceCode);
1039             catchScope.clearException();
1040             return result;
1041         }
1042     }
1043 #endif
1044
1045     auto sourceCode = JSSourceCode::create(vm, makeSource(stringFromUTF(buffer), SourceOrigin { moduleKey }, WTFMove(moduleURL), TextPosition(), SourceProviderSourceType::Module));
1046     catchScope.releaseAssertNoException();
1047     auto result = deferred->resolve(exec, sourceCode);
1048     catchScope.clearException();
1049     return result;
1050 }
1051
1052 JSObject* GlobalObject::moduleLoaderCreateImportMetaProperties(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue key, JSModuleRecord*, JSValue)
1053 {
1054     VM& vm = exec->vm();
1055     auto scope = DECLARE_THROW_SCOPE(vm);
1056
1057     JSObject* metaProperties = constructEmptyObject(exec, globalObject->nullPrototypeObjectStructure());
1058     RETURN_IF_EXCEPTION(scope, nullptr);
1059
1060     metaProperties->putDirect(vm, Identifier::fromString(&vm, "filename"), key);
1061     RETURN_IF_EXCEPTION(scope, nullptr);
1062
1063     return metaProperties;
1064 }
1065
1066 static CString cStringFromViewWithString(ExecState* exec, ThrowScope& scope, StringViewWithUnderlyingString& viewWithString)
1067 {
1068     Expected<CString, UTF8ConversionError> expectedString = viewWithString.view.tryGetUtf8();
1069     if (expectedString)
1070         return expectedString.value();
1071     switch (expectedString.error()) {
1072     case UTF8ConversionError::OutOfMemory:
1073         throwOutOfMemoryError(exec, scope);
1074         break;
1075     case UTF8ConversionError::IllegalSource:
1076         scope.throwException(exec, createError(exec, "Illegal source encountered during UTF8 conversion"));
1077         break;
1078     case UTF8ConversionError::SourceExhausted:
1079         scope.throwException(exec, createError(exec, "Source exhausted during UTF8 conversion"));
1080         break;
1081     default:
1082         RELEASE_ASSERT_NOT_REACHED();
1083     }
1084     return { };
1085 }
1086
1087 static EncodedJSValue printInternal(ExecState* exec, FILE* out)
1088 {
1089     VM& vm = exec->vm();
1090     auto scope = DECLARE_THROW_SCOPE(vm);
1091
1092     if (asyncTestExpectedPasses) {
1093         JSValue value = exec->argument(0);
1094         if (value.isString() && WTF::equal(asString(value)->value(exec).impl(), "Test262:AsyncTestComplete")) {
1095             asyncTestPasses++;
1096             return JSValue::encode(jsUndefined());
1097         }
1098     }
1099
1100     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1101         if (i)
1102             if (EOF == fputc(' ', out))
1103                 goto fail;
1104
1105         auto viewWithString = exec->uncheckedArgument(i).toString(exec)->viewWithUnderlyingString(exec);
1106         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1107         auto string = cStringFromViewWithString(exec, scope, viewWithString);
1108         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1109         if (fprintf(out, "%s", string.data()) < 0)
1110             goto fail;
1111     }
1112
1113     fputc('\n', out);
1114 fail:
1115     fflush(out);
1116     return JSValue::encode(jsUndefined());
1117 }
1118
1119 EncodedJSValue JSC_HOST_CALL functionPrintStdOut(ExecState* exec) { return printInternal(exec, stdout); }
1120 EncodedJSValue JSC_HOST_CALL functionPrintStdErr(ExecState* exec) { return printInternal(exec, stderr); }
1121
1122 EncodedJSValue JSC_HOST_CALL functionDebug(ExecState* exec)
1123 {
1124     VM& vm = exec->vm();
1125     auto scope = DECLARE_THROW_SCOPE(vm);
1126     auto viewWithString = exec->argument(0).toString(exec)->viewWithUnderlyingString(exec);
1127     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1128     auto string = cStringFromViewWithString(exec, scope, viewWithString);
1129     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1130     fprintf(stderr, "--> %s\n", string.data());
1131     return JSValue::encode(jsUndefined());
1132 }
1133
1134 EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState* exec)
1135 {
1136     if (exec->argumentCount() < 1)
1137         return JSValue::encode(jsUndefined());
1138     return JSValue::encode(jsString(exec, toString(exec->argument(0))));
1139 }
1140
1141 EncodedJSValue JSC_HOST_CALL functionDescribeArray(ExecState* exec)
1142 {
1143     if (exec->argumentCount() < 1)
1144         return JSValue::encode(jsUndefined());
1145     VM& vm = exec->vm();
1146     JSObject* object = jsDynamicCast<JSObject*>(vm, exec->argument(0));
1147     if (!object)
1148         return JSValue::encode(jsNontrivialString(exec, "<not object>"_s));
1149     return JSValue::encode(jsNontrivialString(exec, toString("<Butterfly: ", RawPointer(object->butterfly()), "; public length: ", object->getArrayLength(), "; vector length: ", object->getVectorLength(), ">")));
1150 }
1151
1152 EncodedJSValue JSC_HOST_CALL functionSleepSeconds(ExecState* exec)
1153 {
1154     VM& vm = exec->vm();
1155     auto scope = DECLARE_THROW_SCOPE(vm);
1156
1157     if (exec->argumentCount() >= 1) {
1158         Seconds seconds = Seconds(exec->argument(0).toNumber(exec));
1159         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1160         sleep(seconds);
1161     }
1162     
1163     return JSValue::encode(jsUndefined());
1164 }
1165
1166 class FunctionJSCStackFunctor {
1167 public:
1168     FunctionJSCStackFunctor(StringBuilder& trace)
1169         : m_trace(trace)
1170     {
1171     }
1172
1173     StackVisitor::Status operator()(StackVisitor& visitor) const
1174     {
1175         m_trace.append(String::format("    %zu   %s\n", visitor->index(), visitor->toString().utf8().data()));
1176         return StackVisitor::Continue;
1177     }
1178
1179 private:
1180     StringBuilder& m_trace;
1181 };
1182
1183 EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState* exec)
1184 {
1185     StringBuilder trace;
1186     trace.appendLiteral("--> Stack trace:\n");
1187
1188     FunctionJSCStackFunctor functor(trace);
1189     exec->iterate(functor);
1190     fprintf(stderr, "%s", trace.toString().utf8().data());
1191     return JSValue::encode(jsUndefined());
1192 }
1193
1194 EncodedJSValue JSC_HOST_CALL functionGCAndSweep(ExecState* exec)
1195 {
1196     VM& vm = exec->vm();
1197     JSLockHolder lock(vm);
1198     vm.heap.collectNow(Sync, CollectionScope::Full);
1199     return JSValue::encode(jsNumber(vm.heap.sizeAfterLastFullCollection()));
1200 }
1201
1202 EncodedJSValue JSC_HOST_CALL functionFullGC(ExecState* exec)
1203 {
1204     VM& vm = exec->vm();
1205     JSLockHolder lock(vm);
1206     vm.heap.collectSync(CollectionScope::Full);
1207     return JSValue::encode(jsNumber(vm.heap.sizeAfterLastFullCollection()));
1208 }
1209
1210 EncodedJSValue JSC_HOST_CALL functionEdenGC(ExecState* exec)
1211 {
1212     VM& vm = exec->vm();
1213     JSLockHolder lock(vm);
1214     vm.heap.collectSync(CollectionScope::Eden);
1215     return JSValue::encode(jsNumber(vm.heap.sizeAfterLastEdenCollection()));
1216 }
1217
1218 EncodedJSValue JSC_HOST_CALL functionForceGCSlowPaths(ExecState*)
1219 {
1220     // It's best for this to be the first thing called in the 
1221     // JS program so the option is set to true before we JIT.
1222     Options::forceGCSlowPaths() = true;
1223     return JSValue::encode(jsUndefined());
1224 }
1225
1226 EncodedJSValue JSC_HOST_CALL functionHeapSize(ExecState* exec)
1227 {
1228     VM& vm = exec->vm();
1229     JSLockHolder lock(vm);
1230     return JSValue::encode(jsNumber(vm.heap.size()));
1231 }
1232
1233 class JSCMemoryFootprint : public JSDestructibleObject {
1234     using Base = JSDestructibleObject;
1235 public:
1236     JSCMemoryFootprint(VM& vm, Structure* structure)
1237         : Base(vm, structure)
1238     { }
1239
1240     static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
1241     {
1242         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
1243     }
1244
1245     static JSCMemoryFootprint* create(VM& vm, JSGlobalObject* globalObject)
1246     {
1247         Structure* structure = createStructure(vm, globalObject, jsNull());
1248         JSCMemoryFootprint* footprint = new (NotNull, allocateCell<JSCMemoryFootprint>(vm.heap, sizeof(JSCMemoryFootprint))) JSCMemoryFootprint(vm, structure);
1249         footprint->finishCreation(vm);
1250         return footprint;
1251     }
1252
1253     void finishCreation(VM& vm)
1254     {
1255         Base::finishCreation(vm);
1256
1257         auto addProperty = [&] (VM& vm, const char* name, JSValue value) {
1258             JSCMemoryFootprint::addProperty(vm, name, value);
1259         };
1260
1261         MemoryFootprint footprint = MemoryFootprint::now();
1262
1263         addProperty(vm, "current", jsNumber(footprint.current));
1264         addProperty(vm, "peak", jsNumber(footprint.peak));
1265     }
1266
1267     DECLARE_INFO;
1268
1269 private:
1270     void addProperty(VM& vm, const char* name, JSValue value)
1271     {
1272         Identifier identifier = Identifier::fromString(&vm, name);
1273         putDirect(vm, identifier, value);
1274     }
1275 };
1276
1277 const ClassInfo JSCMemoryFootprint::s_info = { "MemoryFootprint", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCMemoryFootprint) };
1278
1279 EncodedJSValue JSC_HOST_CALL functionCreateMemoryFootprint(ExecState* exec)
1280 {
1281     VM& vm = exec->vm();
1282     JSLockHolder lock(vm);
1283     return JSValue::encode(JSCMemoryFootprint::create(vm, exec->lexicalGlobalObject()));
1284 }
1285
1286 EncodedJSValue JSC_HOST_CALL functionResetMemoryPeak(ExecState*)
1287 {
1288     MemoryFootprint::resetPeak();
1289     return JSValue::encode(jsUndefined());
1290 }
1291
1292 // This function is not generally very helpful in 64-bit code as the tag and payload
1293 // share a register. But in 32-bit JITed code the tag may not be checked if an
1294 // optimization removes type checking requirements, such as in ===.
1295 EncodedJSValue JSC_HOST_CALL functionAddressOf(ExecState* exec)
1296 {
1297     JSValue value = exec->argument(0);
1298     if (!value.isCell())
1299         return JSValue::encode(jsUndefined());
1300     // Need to cast to uint64_t so bitwise_cast will play along.
1301     uint64_t asNumber = reinterpret_cast<uint64_t>(value.asCell());
1302     EncodedJSValue returnValue = JSValue::encode(jsNumber(bitwise_cast<double>(asNumber)));
1303     return returnValue;
1304 }
1305
1306 EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*)
1307 {
1308     // We need this function for compatibility with the Mozilla JS tests but for now
1309     // we don't actually do any version-specific handling
1310     return JSValue::encode(jsUndefined());
1311 }
1312
1313 EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec)
1314 {
1315     VM& vm = exec->vm();
1316     auto scope = DECLARE_THROW_SCOPE(vm);
1317
1318     String fileName = exec->argument(0).toWTFString(exec);
1319     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1320     Vector<char> script;
1321     if (!fetchScriptFromLocalFileSystem(fileName, script))
1322         return JSValue::encode(throwException(exec, scope, createError(exec, "Could not open file."_s)));
1323
1324     GlobalObject* globalObject = GlobalObject::create(vm, GlobalObject::createStructure(vm, jsNull()), Vector<String>());
1325
1326     JSArray* array = constructEmptyArray(globalObject->globalExec(), 0);
1327     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1328     for (unsigned i = 1; i < exec->argumentCount(); ++i) {
1329         array->putDirectIndex(globalObject->globalExec(), i - 1, exec->uncheckedArgument(i));
1330         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1331     }
1332     globalObject->putDirect(
1333         vm, Identifier::fromString(globalObject->globalExec(), "arguments"), array);
1334
1335     NakedPtr<Exception> exception;
1336     StopWatch stopWatch;
1337     stopWatch.start();
1338     evaluate(globalObject->globalExec(), jscSource(script, SourceOrigin { absolutePath(fileName) }, fileName), JSValue(), exception);
1339     stopWatch.stop();
1340
1341     if (exception) {
1342         throwException(globalObject->globalExec(), scope, exception);
1343         return JSValue::encode(jsUndefined());
1344     }
1345     
1346     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1347 }
1348
1349 EncodedJSValue JSC_HOST_CALL functionRunString(ExecState* exec)
1350 {
1351     VM& vm = exec->vm();
1352     auto scope = DECLARE_THROW_SCOPE(vm);
1353
1354     String source = exec->argument(0).toWTFString(exec);
1355     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1356
1357     GlobalObject* globalObject = GlobalObject::create(vm, GlobalObject::createStructure(vm, jsNull()), Vector<String>());
1358
1359     JSArray* array = constructEmptyArray(globalObject->globalExec(), 0);
1360     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1361     for (unsigned i = 1; i < exec->argumentCount(); ++i) {
1362         array->putDirectIndex(globalObject->globalExec(), i - 1, exec->uncheckedArgument(i));
1363         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1364     }
1365     globalObject->putDirect(
1366         vm, Identifier::fromString(globalObject->globalExec(), "arguments"), array);
1367
1368     NakedPtr<Exception> exception;
1369     evaluate(globalObject->globalExec(), makeSource(source, exec->callerSourceOrigin()), JSValue(), exception);
1370
1371     if (exception) {
1372         scope.throwException(globalObject->globalExec(), exception);
1373         return JSValue::encode(jsUndefined());
1374     }
1375     
1376     return JSValue::encode(globalObject);
1377 }
1378
1379 EncodedJSValue JSC_HOST_CALL functionLoad(ExecState* exec)
1380 {
1381     VM& vm = exec->vm();
1382     auto scope = DECLARE_THROW_SCOPE(vm);
1383
1384     String fileName = exec->argument(0).toWTFString(exec);
1385     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1386     Vector<char> script;
1387     if (!fetchScriptFromLocalFileSystem(fileName, script))
1388         return JSValue::encode(throwException(exec, scope, createError(exec, "Could not open file."_s)));
1389
1390     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1391     
1392     NakedPtr<Exception> evaluationException;
1393     JSValue result = evaluate(globalObject->globalExec(), jscSource(script, SourceOrigin { absolutePath(fileName) }, fileName), JSValue(), evaluationException);
1394     if (evaluationException)
1395         throwException(exec, scope, evaluationException);
1396     return JSValue::encode(result);
1397 }
1398
1399 EncodedJSValue JSC_HOST_CALL functionLoadString(ExecState* exec)
1400 {
1401     VM& vm = exec->vm();
1402     auto scope = DECLARE_THROW_SCOPE(vm);
1403
1404     String sourceCode = exec->argument(0).toWTFString(exec);
1405     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1406     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1407
1408     NakedPtr<Exception> evaluationException;
1409     JSValue result = evaluate(globalObject->globalExec(), makeSource(sourceCode, exec->callerSourceOrigin()), JSValue(), evaluationException);
1410     if (evaluationException)
1411         throwException(exec, scope, evaluationException);
1412     return JSValue::encode(result);
1413 }
1414
1415 EncodedJSValue JSC_HOST_CALL functionReadFile(ExecState* exec)
1416 {
1417     VM& vm = exec->vm();
1418     auto scope = DECLARE_THROW_SCOPE(vm);
1419
1420     String fileName = exec->argument(0).toWTFString(exec);
1421     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1422
1423     bool isBinary = false;
1424     if (exec->argumentCount() > 1) {
1425         String type = exec->argument(1).toWTFString(exec);
1426         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1427         if (type != "binary")
1428             return throwVMError(exec, scope, "Expected 'binary' as second argument.");
1429         isBinary = true;
1430     }
1431
1432     RefPtr<Uint8Array> content = fillBufferWithContentsOfFile(fileName);
1433     if (!content)
1434         return throwVMError(exec, scope, "Could not open file.");
1435
1436     if (!isBinary)
1437         return JSValue::encode(jsString(exec, String::fromUTF8WithLatin1Fallback(content->data(), content->length())));
1438
1439     Structure* structure = exec->lexicalGlobalObject()->typedArrayStructure(TypeUint8);
1440     JSObject* result = JSUint8Array::create(vm, structure, WTFMove(content));
1441     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1442
1443     return JSValue::encode(result);
1444 }
1445
1446 EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec)
1447 {
1448     VM& vm = exec->vm();
1449     auto scope = DECLARE_THROW_SCOPE(vm);
1450
1451     String fileName = exec->argument(0).toWTFString(exec);
1452     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1453     Vector<char> script;
1454     if (!fetchScriptFromLocalFileSystem(fileName, script))
1455         return JSValue::encode(throwException(exec, scope, createError(exec, "Could not open file."_s)));
1456
1457     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1458
1459     StopWatch stopWatch;
1460     stopWatch.start();
1461
1462     JSValue syntaxException;
1463     bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script, SourceOrigin { absolutePath(fileName) }, fileName), &syntaxException);
1464     stopWatch.stop();
1465
1466     if (!validSyntax)
1467         throwException(exec, scope, syntaxException);
1468     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
1469 }
1470
1471 #if ENABLE(SAMPLING_FLAGS)
1472 EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState* exec)
1473 {
1474     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1475         unsigned flag = static_cast<unsigned>(exec->uncheckedArgument(i).toNumber(exec));
1476         if ((flag >= 1) && (flag <= 32))
1477             SamplingFlags::setFlag(flag);
1478     }
1479     return JSValue::encode(jsNull());
1480 }
1481
1482 EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec)
1483 {
1484     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
1485         unsigned flag = static_cast<unsigned>(exec->uncheckedArgument(i).toNumber(exec));
1486         if ((flag >= 1) && (flag <= 32))
1487             SamplingFlags::clearFlag(flag);
1488     }
1489     return JSValue::encode(jsNull());
1490 }
1491 #endif
1492
1493 EncodedJSValue JSC_HOST_CALL functionGetRandomSeed(ExecState* exec)
1494 {
1495     return JSValue::encode(jsNumber(exec->lexicalGlobalObject()->weakRandom().seed()));
1496 }
1497
1498 EncodedJSValue JSC_HOST_CALL functionSetRandomSeed(ExecState* exec)
1499 {
1500     VM& vm = exec->vm();
1501     auto scope = DECLARE_THROW_SCOPE(vm);
1502
1503     unsigned seed = exec->argument(0).toUInt32(exec);
1504     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1505     exec->lexicalGlobalObject()->weakRandom().setSeed(seed);
1506     return JSValue::encode(jsUndefined());
1507 }
1508
1509 EncodedJSValue JSC_HOST_CALL functionIsRope(ExecState* exec)
1510 {
1511     JSValue argument = exec->argument(0);
1512     if (!argument.isString())
1513         return JSValue::encode(jsBoolean(false));
1514     const StringImpl* impl = asString(argument)->tryGetValueImpl();
1515     return JSValue::encode(jsBoolean(!impl));
1516 }
1517
1518 EncodedJSValue JSC_HOST_CALL functionCallerSourceOrigin(ExecState* state)
1519 {
1520     SourceOrigin sourceOrigin = state->callerSourceOrigin();
1521     if (sourceOrigin.isNull())
1522         return JSValue::encode(jsNull());
1523     return JSValue::encode(jsString(state, sourceOrigin.string()));
1524 }
1525
1526 EncodedJSValue JSC_HOST_CALL functionReadline(ExecState* exec)
1527 {
1528     Vector<char, 256> line;
1529     int c;
1530     while ((c = getchar()) != EOF) {
1531         // FIXME: Should we also break on \r? 
1532         if (c == '\n')
1533             break;
1534         line.append(c);
1535     }
1536     line.append('\0');
1537     return JSValue::encode(jsString(exec, line.data()));
1538 }
1539
1540 EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*)
1541 {
1542     return JSValue::encode(jsNumber(WallTime::now().secondsSinceEpoch().value()));
1543 }
1544
1545 EncodedJSValue JSC_HOST_CALL functionNeverInlineFunction(ExecState* exec)
1546 {
1547     return JSValue::encode(setNeverInline(exec));
1548 }
1549
1550 EncodedJSValue JSC_HOST_CALL functionNoDFG(ExecState* exec)
1551 {
1552     return JSValue::encode(setNeverOptimize(exec));
1553 }
1554
1555 EncodedJSValue JSC_HOST_CALL functionNoFTL(ExecState* exec)
1556 {
1557     if (exec->argumentCount()) {
1558         FunctionExecutable* executable = getExecutableForFunction(exec->argument(0));
1559         if (executable)
1560             executable->setNeverFTLOptimize(true);
1561     }
1562     return JSValue::encode(jsUndefined());
1563 }
1564
1565 EncodedJSValue JSC_HOST_CALL functionNoOSRExitFuzzing(ExecState* exec)
1566 {
1567     return JSValue::encode(setCannotUseOSRExitFuzzing(exec));
1568 }
1569
1570 EncodedJSValue JSC_HOST_CALL functionOptimizeNextInvocation(ExecState* exec)
1571 {
1572     return JSValue::encode(optimizeNextInvocation(exec));
1573 }
1574
1575 EncodedJSValue JSC_HOST_CALL functionNumberOfDFGCompiles(ExecState* exec)
1576 {
1577     return JSValue::encode(numberOfDFGCompiles(exec));
1578 }
1579
1580 Message::Message(ArrayBufferContents&& contents, int32_t index)
1581     : m_contents(WTFMove(contents))
1582     , m_index(index)
1583 {
1584 }
1585
1586 Message::~Message()
1587 {
1588 }
1589
1590 Worker::Worker(Workers& workers)
1591     : m_workers(workers)
1592 {
1593     auto locker = holdLock(m_workers.m_lock);
1594     m_workers.m_workers.append(this);
1595     
1596     *currentWorker() = this;
1597 }
1598
1599 Worker::~Worker()
1600 {
1601     auto locker = holdLock(m_workers.m_lock);
1602     RELEASE_ASSERT(isOnList());
1603     remove();
1604 }
1605
1606 void Worker::enqueue(const AbstractLocker&, RefPtr<Message> message)
1607 {
1608     m_messages.append(message);
1609 }
1610
1611 RefPtr<Message> Worker::dequeue()
1612 {
1613     auto locker = holdLock(m_workers.m_lock);
1614     while (m_messages.isEmpty())
1615         m_workers.m_condition.wait(m_workers.m_lock);
1616     return m_messages.takeFirst();
1617 }
1618
1619 Worker& Worker::current()
1620 {
1621     return **currentWorker();
1622 }
1623
1624 ThreadSpecific<Worker*>& Worker::currentWorker()
1625 {
1626     static ThreadSpecific<Worker*>* result;
1627     static std::once_flag flag;
1628     std::call_once(
1629         flag,
1630         [] () {
1631             result = new ThreadSpecific<Worker*>();
1632         });
1633     return *result;
1634 }
1635
1636 Workers::Workers()
1637 {
1638 }
1639
1640 Workers::~Workers()
1641 {
1642     UNREACHABLE_FOR_PLATFORM();
1643 }
1644
1645 template<typename Func>
1646 void Workers::broadcast(const Func& func)
1647 {
1648     auto locker = holdLock(m_lock);
1649     for (Worker* worker = m_workers.begin(); worker != m_workers.end(); worker = worker->next()) {
1650         if (worker != &Worker::current())
1651             func(locker, *worker);
1652     }
1653     m_condition.notifyAll();
1654 }
1655
1656 void Workers::report(const String& string)
1657 {
1658     auto locker = holdLock(m_lock);
1659     m_reports.append(string.isolatedCopy());
1660     m_condition.notifyAll();
1661 }
1662
1663 String Workers::tryGetReport()
1664 {
1665     auto locker = holdLock(m_lock);
1666     if (m_reports.isEmpty())
1667         return String();
1668     return m_reports.takeFirst();
1669 }
1670
1671 String Workers::getReport()
1672 {
1673     auto locker = holdLock(m_lock);
1674     while (m_reports.isEmpty())
1675         m_condition.wait(m_lock);
1676     return m_reports.takeFirst();
1677 }
1678
1679 Workers& Workers::singleton()
1680 {
1681     static Workers* result;
1682     static std::once_flag flag;
1683     std::call_once(
1684         flag,
1685         [] {
1686             result = new Workers();
1687         });
1688     return *result;
1689 }
1690
1691 EncodedJSValue JSC_HOST_CALL functionDollarCreateRealm(ExecState* exec)
1692 {
1693     VM& vm = exec->vm();
1694     GlobalObject* result = GlobalObject::create(vm, GlobalObject::createStructure(vm, jsNull()), Vector<String>());
1695     return JSValue::encode(result->getDirect(vm, Identifier::fromString(exec, "$")));
1696 }
1697
1698 EncodedJSValue JSC_HOST_CALL functionDollarDetachArrayBuffer(ExecState* exec)
1699 {
1700     return functionTransferArrayBuffer(exec);
1701 }
1702
1703 EncodedJSValue JSC_HOST_CALL functionDollarEvalScript(ExecState* exec)
1704 {
1705     VM& vm = exec->vm();
1706     auto scope = DECLARE_THROW_SCOPE(vm);
1707
1708     String sourceCode = exec->argument(0).toWTFString(exec);
1709     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1710     
1711     GlobalObject* globalObject = jsDynamicCast<GlobalObject*>(vm,
1712         exec->thisValue().get(exec, Identifier::fromString(exec, "global")));
1713     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1714     if (!globalObject)
1715         return JSValue::encode(throwException(exec, scope, createError(exec, "Expected global to point to a global object"_s)));
1716     
1717     NakedPtr<Exception> evaluationException;
1718     JSValue result = evaluate(globalObject->globalExec(), makeSource(sourceCode, exec->callerSourceOrigin()), JSValue(), evaluationException);
1719     if (evaluationException)
1720         throwException(exec, scope, evaluationException);
1721     return JSValue::encode(result);
1722 }
1723
1724 EncodedJSValue JSC_HOST_CALL functionDollarAgentStart(ExecState* exec)
1725 {
1726     VM& vm = exec->vm();
1727     auto scope = DECLARE_THROW_SCOPE(vm);
1728
1729     String sourceCode = exec->argument(0).toWTFString(exec).isolatedCopy();
1730     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1731     
1732     Lock didStartLock;
1733     Condition didStartCondition;
1734     bool didStart = false;
1735     
1736     Thread::create(
1737         "JSC Agent",
1738         [sourceCode, &didStartLock, &didStartCondition, &didStart] () {
1739             CommandLine commandLine(0, nullptr);
1740             commandLine.m_interactive = false;
1741             runJSC(
1742                 commandLine, true,
1743                 [&] (VM&, GlobalObject* globalObject, bool& success) {
1744                     // Notify the thread that started us that we have registered a worker.
1745                     {
1746                         auto locker = holdLock(didStartLock);
1747                         didStart = true;
1748                         didStartCondition.notifyOne();
1749                     }
1750                     
1751                     NakedPtr<Exception> evaluationException;
1752                     JSValue result;
1753                     result = evaluate(globalObject->globalExec(), makeSource(sourceCode, SourceOrigin("worker"_s)), JSValue(), evaluationException);
1754                     if (evaluationException)
1755                         result = evaluationException->value();
1756                     checkException(globalObject->globalExec(), globalObject, true, evaluationException, result, commandLine, success);
1757                     if (!success)
1758                         exit(1);
1759                 });
1760         })->detach();
1761     
1762     {
1763         auto locker = holdLock(didStartLock);
1764         while (!didStart)
1765             didStartCondition.wait(didStartLock);
1766     }
1767     
1768     return JSValue::encode(jsUndefined());
1769 }
1770
1771 EncodedJSValue JSC_HOST_CALL functionDollarAgentReceiveBroadcast(ExecState* exec)
1772 {
1773     VM& vm = exec->vm();
1774     auto scope = DECLARE_THROW_SCOPE(vm);
1775
1776     JSValue callback = exec->argument(0);
1777     CallData callData;
1778     CallType callType = getCallData(vm, callback, callData);
1779     if (callType == CallType::None)
1780         return JSValue::encode(throwException(exec, scope, createError(exec, "Expected callback"_s)));
1781     
1782     RefPtr<Message> message;
1783     {
1784         ReleaseHeapAccessScope releaseAccess(vm.heap);
1785         message = Worker::current().dequeue();
1786     }
1787     
1788     auto nativeBuffer = ArrayBuffer::create(message->releaseContents());
1789     ArrayBufferSharingMode sharingMode = nativeBuffer->sharingMode();
1790     JSArrayBuffer* jsBuffer = JSArrayBuffer::create(vm, exec->lexicalGlobalObject()->arrayBufferStructure(sharingMode), WTFMove(nativeBuffer));
1791     
1792     MarkedArgumentBuffer args;
1793     args.append(jsBuffer);
1794     args.append(jsNumber(message->index()));
1795     if (UNLIKELY(args.hasOverflowed()))
1796         return JSValue::encode(throwOutOfMemoryError(exec, scope));
1797     RELEASE_AND_RETURN(scope, JSValue::encode(call(exec, callback, callType, callData, jsNull(), args)));
1798 }
1799
1800 EncodedJSValue JSC_HOST_CALL functionDollarAgentReport(ExecState* exec)
1801 {
1802     VM& vm = exec->vm();
1803     auto scope = DECLARE_THROW_SCOPE(vm);
1804
1805     String report = exec->argument(0).toWTFString(exec);
1806     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1807     
1808     Workers::singleton().report(report);
1809     
1810     return JSValue::encode(jsUndefined());
1811 }
1812
1813 EncodedJSValue JSC_HOST_CALL functionDollarAgentSleep(ExecState* exec)
1814 {
1815     VM& vm = exec->vm();
1816     auto scope = DECLARE_THROW_SCOPE(vm);
1817
1818     if (exec->argumentCount() >= 1) {
1819         Seconds seconds = Seconds::fromMilliseconds(exec->argument(0).toNumber(exec));
1820         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1821         sleep(seconds);
1822     }
1823     return JSValue::encode(jsUndefined());
1824 }
1825
1826 EncodedJSValue JSC_HOST_CALL functionDollarAgentBroadcast(ExecState* exec)
1827 {
1828     VM& vm = exec->vm();
1829     auto scope = DECLARE_THROW_SCOPE(vm);
1830
1831     JSArrayBuffer* jsBuffer = jsDynamicCast<JSArrayBuffer*>(vm, exec->argument(0));
1832     if (!jsBuffer || !jsBuffer->isShared())
1833         return JSValue::encode(throwException(exec, scope, createError(exec, "Expected SharedArrayBuffer"_s)));
1834     
1835     int32_t index = exec->argument(1).toInt32(exec);
1836     RETURN_IF_EXCEPTION(scope, encodedJSValue());
1837     
1838     Workers::singleton().broadcast(
1839         [&] (const AbstractLocker& locker, Worker& worker) {
1840             ArrayBuffer* nativeBuffer = jsBuffer->impl();
1841             ArrayBufferContents contents;
1842             nativeBuffer->transferTo(vm, contents); // "transferTo" means "share" if the buffer is shared.
1843             RefPtr<Message> message = adoptRef(new Message(WTFMove(contents), index));
1844             worker.enqueue(locker, message);
1845         });
1846     
1847     return JSValue::encode(jsUndefined());
1848 }
1849
1850 EncodedJSValue JSC_HOST_CALL functionDollarAgentGetReport(ExecState* exec)
1851 {
1852     VM& vm = exec->vm();
1853
1854     String string = Workers::singleton().tryGetReport();
1855     if (!string)
1856         return JSValue::encode(jsNull());
1857     
1858     return JSValue::encode(jsString(&vm, string));
1859 }
1860
1861 EncodedJSValue JSC_HOST_CALL functionDollarAgentLeaving(ExecState*)
1862 {
1863     return JSValue::encode(jsUndefined());
1864 }
1865
1866 EncodedJSValue JSC_HOST_CALL functionDollarAgentMonotonicNow(ExecState*)
1867 {
1868     return JSValue::encode(jsNumber(MonotonicTime::now().secondsSinceEpoch().milliseconds()));
1869 }
1870
1871 EncodedJSValue JSC_HOST_CALL functionWaitForReport(ExecState* exec)
1872 {
1873     VM& vm = exec->vm();
1874
1875     String string;
1876     {
1877         ReleaseHeapAccessScope releaseAccess(vm.heap);
1878         string = Workers::singleton().getReport();
1879     }
1880     if (!string)
1881         return JSValue::encode(jsNull());
1882     
1883     return JSValue::encode(jsString(&vm, string));
1884 }
1885
1886 EncodedJSValue JSC_HOST_CALL functionHeapCapacity(ExecState* exec)
1887 {
1888     VM& vm = exec->vm();
1889     return JSValue::encode(jsNumber(vm.heap.capacity()));
1890 }
1891
1892 EncodedJSValue JSC_HOST_CALL functionFlashHeapAccess(ExecState* exec)
1893 {
1894     VM& vm = exec->vm();
1895     auto scope = DECLARE_THROW_SCOPE(vm);
1896     
1897     double sleepTimeMs = 0;
1898     if (exec->argumentCount() >= 1) {
1899         sleepTimeMs = exec->argument(0).toNumber(exec);
1900         RETURN_IF_EXCEPTION(scope, encodedJSValue());
1901     }
1902
1903     vm.heap.releaseAccess();
1904     if (sleepTimeMs)
1905         sleep(Seconds::fromMilliseconds(sleepTimeMs));
1906     vm.heap.acquireAccess();
1907     return JSValue::encode(jsUndefined());
1908 }
1909
1910 EncodedJSValue JSC_HOST_CALL functionDisableRichSourceInfo(ExecState*)
1911 {
1912     supportsRichSourceInfo = false;
1913     return JSValue::encode(jsUndefined());
1914 }
1915
1916 EncodedJSValue JSC_HOST_CALL functionMallocInALoop(ExecState*)
1917 {
1918     Vector<void*> ptrs;
1919     for (unsigned i = 0; i < 5000; ++i)
1920         ptrs.append(fastMalloc(1024 * 2));
1921     for (void* ptr : ptrs)
1922         fastFree(ptr);
1923     return JSValue::encode(jsUndefined());
1924 }
1925
1926 EncodedJSValue JSC_HOST_CALL functionTotalCompileTime(ExecState*)
1927 {
1928 #if ENABLE(JIT)
1929     return JSValue::encode(jsNumber(JIT::totalCompileTime().milliseconds()));
1930 #else
1931     return JSValue::encode(jsNumber(0));
1932 #endif
1933 }
1934
1935 template<typename ValueType>
1936 typename std::enable_if<!std::is_fundamental<ValueType>::value>::type addOption(VM&, JSObject*, const Identifier&, ValueType) { }
1937
1938 template<typename ValueType>
1939 typename std::enable_if<std::is_fundamental<ValueType>::value>::type addOption(VM& vm, JSObject* optionsObject, const Identifier& identifier, ValueType value)
1940 {
1941     optionsObject->putDirect(vm, identifier, JSValue(value));
1942 }
1943
1944 EncodedJSValue JSC_HOST_CALL functionJSCOptions(ExecState* exec)
1945 {
1946     VM& vm = exec->vm();
1947     JSObject* optionsObject = constructEmptyObject(exec);
1948 #define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
1949     addOption(vm, optionsObject, Identifier::fromString(exec, #name_), Options::name_());
1950     JSC_OPTIONS(FOR_EACH_OPTION)
1951 #undef FOR_EACH_OPTION
1952     return JSValue::encode(optionsObject);
1953 }
1954
1955 EncodedJSValue JSC_HOST_CALL functionReoptimizationRetryCount(ExecState* exec)
1956 {
1957     if (exec->argumentCount() < 1)
1958         return JSValue::encode(jsUndefined());
1959     
1960     CodeBlock* block = getSomeBaselineCodeBlockForFunction(exec->argument(0));
1961     if (!block)
1962         return JSValue::encode(jsNumber(0));
1963     
1964     return JSValue::encode(jsNumber(block->reoptimizationRetryCounter()));
1965 }
1966
1967 EncodedJSValue JSC_HOST_CALL functionTransferArrayBuffer(ExecState* exec)
1968 {
1969     VM& vm = exec->vm();
1970     auto scope = DECLARE_THROW_SCOPE(vm);
1971
1972     if (exec->argumentCount() < 1)
1973         return JSValue::encode(throwException(exec, scope, createError(exec, "Not enough arguments"_s)));
1974     
1975     JSArrayBuffer* buffer = jsDynamicCast<JSArrayBuffer*>(vm, exec->argument(0));
1976     if (!buffer)
1977         return JSValue::encode(throwException(exec, scope, createError(exec, "Expected an array buffer"_s)));
1978     
1979     ArrayBufferContents dummyContents;
1980     buffer->impl()->transferTo(vm, dummyContents);
1981     
1982     return JSValue::encode(jsUndefined());
1983 }
1984
1985 EncodedJSValue JSC_HOST_CALL functionFailNextNewCodeBlock(ExecState* exec)
1986 {
1987     VM& vm = exec->vm();
1988     vm.setFailNextNewCodeBlock();
1989     return JSValue::encode(jsUndefined());
1990 }
1991
1992 EncodedJSValue JSC_HOST_CALL functionQuit(ExecState* exec)
1993 {
1994     VM& vm = exec->vm();
1995     vm.codeCache()->write(vm);
1996
1997     jscExit(EXIT_SUCCESS);
1998
1999 #if COMPILER(MSVC)
2000     // Without this, Visual Studio will complain that this method does not return a value.
2001     return JSValue::encode(jsUndefined());
2002 #endif
2003 }
2004
2005 EncodedJSValue JSC_HOST_CALL functionFalse(ExecState*) { return JSValue::encode(jsBoolean(false)); }
2006
2007 EncodedJSValue JSC_HOST_CALL functionUndefined1(ExecState*) { return JSValue::encode(jsUndefined()); }
2008 EncodedJSValue JSC_HOST_CALL functionUndefined2(ExecState*) { return JSValue::encode(jsUndefined()); }
2009 EncodedJSValue JSC_HOST_CALL functionIsInt32(ExecState* exec)
2010 {
2011     for (size_t i = 0; i < exec->argumentCount(); ++i) {
2012         if (!exec->argument(i).isInt32())
2013             return JSValue::encode(jsBoolean(false));
2014     }
2015     return JSValue::encode(jsBoolean(true));
2016 }
2017
2018 EncodedJSValue JSC_HOST_CALL functionIsPureNaN(ExecState* exec)
2019 {
2020     for (size_t i = 0; i < exec->argumentCount(); ++i) {
2021         JSValue value = exec->argument(i);
2022         if (!value.isNumber())
2023             return JSValue::encode(jsBoolean(false));
2024         double number = value.asNumber();
2025         if (!std::isnan(number))
2026             return JSValue::encode(jsBoolean(false));
2027         if (isImpureNaN(number))
2028             return JSValue::encode(jsBoolean(false));
2029     }
2030     return JSValue::encode(jsBoolean(true));
2031 }
2032
2033 EncodedJSValue JSC_HOST_CALL functionIdentity(ExecState* exec) { return JSValue::encode(exec->argument(0)); }
2034
2035 EncodedJSValue JSC_HOST_CALL functionEffectful42(ExecState*)
2036 {
2037     return JSValue::encode(jsNumber(42));
2038 }
2039
2040 EncodedJSValue JSC_HOST_CALL functionMakeMasquerader(ExecState* exec)
2041 {
2042     VM& vm = exec->vm();
2043     return JSValue::encode(Masquerader::create(vm, exec->lexicalGlobalObject()));
2044 }
2045
2046 EncodedJSValue JSC_HOST_CALL functionHasCustomProperties(ExecState* exec)
2047 {
2048     JSValue value = exec->argument(0);
2049     if (value.isObject())
2050         return JSValue::encode(jsBoolean(asObject(value)->hasCustomProperties(exec->vm())));
2051     return JSValue::encode(jsBoolean(false));
2052 }
2053
2054 EncodedJSValue JSC_HOST_CALL functionDumpTypesForAllVariables(ExecState* exec)
2055 {
2056     VM& vm = exec->vm();
2057     vm.dumpTypeProfilerData();
2058     return JSValue::encode(jsUndefined());
2059 }
2060
2061 EncodedJSValue JSC_HOST_CALL functionDrainMicrotasks(ExecState* exec)
2062 {
2063     VM& vm = exec->vm();
2064     vm.drainMicrotasks();
2065     return JSValue::encode(jsUndefined());
2066 }
2067
2068 EncodedJSValue JSC_HOST_CALL functionIs32BitPlatform(ExecState*)
2069 {
2070 #if USE(JSVALUE64)
2071     return JSValue::encode(JSValue(JSC::JSValue::JSFalse));
2072 #else
2073     return JSValue::encode(JSValue(JSC::JSValue::JSTrue));
2074 #endif
2075 }
2076
2077 EncodedJSValue JSC_HOST_CALL functionCreateGlobalObject(ExecState* exec)
2078 {
2079     VM& vm = exec->vm();
2080     return JSValue::encode(GlobalObject::create(vm, GlobalObject::createStructure(vm, jsNull()), Vector<String>()));
2081 }
2082
2083 EncodedJSValue JSC_HOST_CALL functionCheckModuleSyntax(ExecState* exec)
2084 {
2085     VM& vm = exec->vm();
2086     auto scope = DECLARE_THROW_SCOPE(vm);
2087
2088     String source = exec->argument(0).toWTFString(exec);
2089     RETURN_IF_EXCEPTION(scope, encodedJSValue());
2090
2091     StopWatch stopWatch;
2092     stopWatch.start();
2093
2094     ParserError error;
2095     bool validSyntax = checkModuleSyntax(exec, makeSource(source, { }, URL(), TextPosition(), SourceProviderSourceType::Module), error);
2096     RETURN_IF_EXCEPTION(scope, encodedJSValue());
2097     stopWatch.stop();
2098
2099     if (!validSyntax)
2100         throwException(exec, scope, jsNontrivialString(exec, toString("SyntaxError: ", error.message(), ":", error.line())));
2101     return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
2102 }
2103
2104 EncodedJSValue JSC_HOST_CALL functionPlatformSupportsSamplingProfiler(ExecState*)
2105 {
2106 #if ENABLE(SAMPLING_PROFILER)
2107     return JSValue::encode(JSValue(JSC::JSValue::JSTrue));
2108 #else
2109     return JSValue::encode(JSValue(JSC::JSValue::JSFalse));
2110 #endif
2111 }
2112
2113 EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshot(ExecState* exec)
2114 {
2115     VM& vm = exec->vm();
2116     JSLockHolder lock(vm);
2117     auto scope = DECLARE_THROW_SCOPE(vm);
2118
2119     HeapSnapshotBuilder snapshotBuilder(vm.ensureHeapProfiler());
2120     snapshotBuilder.buildSnapshot();
2121
2122     String jsonString = snapshotBuilder.json();
2123     EncodedJSValue result = JSValue::encode(JSONParse(exec, jsonString));
2124     scope.releaseAssertNoException();
2125     return result;
2126 }
2127
2128 EncodedJSValue JSC_HOST_CALL functionGenerateHeapSnapshotForGCDebugging(ExecState* exec)
2129 {
2130     VM& vm = exec->vm();
2131     JSLockHolder lock(vm);
2132     auto scope = DECLARE_THROW_SCOPE(vm);
2133     String jsonString;
2134     {
2135         DeferGCForAWhile deferGC(vm.heap); // Prevent concurrent GC from interfering with the full GC that the snapshot does.
2136
2137         HeapSnapshotBuilder snapshotBuilder(vm.ensureHeapProfiler(), HeapSnapshotBuilder::SnapshotType::GCDebuggingSnapshot);
2138         snapshotBuilder.buildSnapshot();
2139
2140         jsonString = snapshotBuilder.json();
2141     }
2142     scope.releaseAssertNoException();
2143     return JSValue::encode(jsString(&vm, jsonString));
2144 }
2145
2146 EncodedJSValue JSC_HOST_CALL functionResetSuperSamplerState(ExecState*)
2147 {
2148     resetSuperSamplerState();
2149     return JSValue::encode(jsUndefined());
2150 }
2151
2152 EncodedJSValue JSC_HOST_CALL functionEnsureArrayStorage(ExecState* exec)
2153 {
2154     VM& vm = exec->vm();
2155     for (unsigned i = 0; i < exec->argumentCount(); ++i) {
2156         if (JSObject* object = jsDynamicCast<JSObject*>(vm, exec->argument(i)))
2157             object->ensureArrayStorage(vm);
2158     }
2159     return JSValue::encode(jsUndefined());
2160 }
2161
2162 #if ENABLE(SAMPLING_PROFILER)
2163 EncodedJSValue JSC_HOST_CALL functionStartSamplingProfiler(ExecState* exec)
2164 {
2165     VM& vm = exec->vm();
2166     SamplingProfiler& samplingProfiler = vm.ensureSamplingProfiler(WTF::Stopwatch::create());
2167     samplingProfiler.noticeCurrentThreadAsJSCExecutionThread();
2168     samplingProfiler.start();
2169     return JSValue::encode(jsUndefined());
2170 }
2171
2172 EncodedJSValue JSC_HOST_CALL functionSamplingProfilerStackTraces(ExecState* exec)
2173 {
2174     VM& vm = exec->vm();
2175     auto scope = DECLARE_THROW_SCOPE(vm);
2176
2177     if (!vm.samplingProfiler())
2178         return JSValue::encode(throwException(exec, scope, createError(exec, "Sampling profiler was never started"_s)));
2179
2180     String jsonString = vm.samplingProfiler()->stackTracesAsJSON();
2181     EncodedJSValue result = JSValue::encode(JSONParse(exec, jsonString));
2182     scope.releaseAssertNoException();
2183     return result;
2184 }
2185 #endif // ENABLE(SAMPLING_PROFILER)
2186
2187 EncodedJSValue JSC_HOST_CALL functionMaxArguments(ExecState*)
2188 {
2189     return JSValue::encode(jsNumber(JSC::maxArguments));
2190 }
2191
2192 EncodedJSValue JSC_HOST_CALL functionAsyncTestStart(ExecState* exec)
2193 {
2194     VM& vm = exec->vm();
2195     auto scope = DECLARE_THROW_SCOPE(vm);
2196
2197     JSValue numberOfAsyncPasses = exec->argument(0);
2198     if (!numberOfAsyncPasses.isUInt32())
2199         return throwVMError(exec, scope, "Expected first argument to a uint32"_s);
2200
2201     asyncTestExpectedPasses += numberOfAsyncPasses.asUInt32();
2202     return encodedJSUndefined();
2203 }
2204
2205 EncodedJSValue JSC_HOST_CALL functionAsyncTestPassed(ExecState*)
2206 {
2207     asyncTestPasses++;
2208     return encodedJSUndefined();
2209 }
2210
2211 #if ENABLE(WEBASSEMBLY)
2212
2213 static EncodedJSValue JSC_HOST_CALL functionWebAssemblyMemoryMode(ExecState* exec)
2214 {
2215     VM& vm = exec->vm();
2216     auto scope = DECLARE_THROW_SCOPE(vm);
2217     
2218     if (!Options::useWebAssembly())
2219         return throwVMTypeError(exec, scope, "WebAssemblyMemoryMode should only be called if the useWebAssembly option is set"_s);
2220
2221     if (JSObject* object = exec->argument(0).getObject()) {
2222         if (auto* memory = jsDynamicCast<JSWebAssemblyMemory*>(vm, object))
2223             return JSValue::encode(jsString(&vm, makeString(memory->memory().mode())));
2224         if (auto* instance = jsDynamicCast<JSWebAssemblyInstance*>(vm, object))
2225             return JSValue::encode(jsString(&vm, makeString(instance->memoryMode())));
2226     }
2227
2228     return throwVMTypeError(exec, scope, "WebAssemblyMemoryMode expects either a WebAssembly.Memory or WebAssembly.Instance"_s);
2229 }
2230
2231 #endif // ENABLE(WEBASSEMBLY)
2232
2233 // Use SEH for Release builds only to get rid of the crash report dialog
2234 // (luckily the same tests fail in Release and Debug builds so far). Need to
2235 // be in a separate main function because the jscmain function requires object
2236 // unwinding.
2237
2238 #if COMPILER(MSVC) && !defined(_DEBUG)
2239 #define TRY       __try {
2240 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
2241 #else
2242 #define TRY
2243 #define EXCEPT(x)
2244 #endif
2245
2246 int jscmain(int argc, char** argv);
2247
2248 static double s_desiredTimeout;
2249 static double s_timeoutMultiplier = 1.0;
2250
2251 static void startTimeoutThreadIfNeeded()
2252 {
2253     if (char* timeoutString = getenv("JSCTEST_timeout")) {
2254         if (sscanf(timeoutString, "%lf", &s_desiredTimeout) != 1) {
2255             dataLog("WARNING: timeout string is malformed, got ", timeoutString,
2256                 " but expected a number. Not using a timeout.\n");
2257         } else {
2258             Thread::create("jsc Timeout Thread", [] () {
2259                 Seconds timeoutDuration(s_desiredTimeout * s_timeoutMultiplier);
2260                 sleep(timeoutDuration);
2261                 dataLog("Timed out after ", timeoutDuration, " seconds!\n");
2262                 CRASH();
2263             });
2264         }
2265     }
2266 }
2267
2268 int main(int argc, char** argv)
2269 {
2270 #if PLATFORM(IOS_FAMILY) && CPU(ARM_THUMB2)
2271     // Enabled IEEE754 denormal support.
2272     fenv_t env;
2273     fegetenv( &env );
2274     env.__fpscr &= ~0x01000000u;
2275     fesetenv( &env );
2276 #endif
2277
2278 #if OS(WINDOWS)
2279     // Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for
2280     // testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the
2281     // error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.
2282     ::SetErrorMode(0);
2283
2284     _setmode(_fileno(stdout), _O_BINARY);
2285     _setmode(_fileno(stderr), _O_BINARY);
2286
2287 #if defined(_DEBUG)
2288     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
2289     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
2290     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
2291     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
2292     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
2293     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
2294 #endif
2295
2296     timeBeginPeriod(1);
2297 #endif
2298
2299 #if PLATFORM(GTK)
2300     if (!setlocale(LC_ALL, ""))
2301         WTFLogAlways("Locale not supported by C library.\n\tUsing the fallback 'C' locale.");
2302 #endif
2303
2304     // Need to initialize WTF threading before we start any threads. Cannot initialize JSC
2305     // threading yet, since that would do somethings that we'd like to defer until after we
2306     // have a chance to parse options.
2307     WTF::initializeThreading();
2308
2309 #if PLATFORM(IOS_FAMILY)
2310     Options::crashIfCantAllocateJITMemory() = true;
2311 #endif
2312
2313     // We can't use destructors in the following code because it uses Windows
2314     // Structured Exception Handling
2315     int res = 0;
2316     TRY
2317         res = jscmain(argc, argv);
2318     EXCEPT(res = 3)
2319     finalizeStatsAtEndOfTesting();
2320
2321     jscExit(res);
2322 }
2323
2324 static void dumpException(GlobalObject* globalObject, JSValue exception)
2325 {
2326     VM& vm = globalObject->vm();
2327     auto scope = DECLARE_CATCH_SCOPE(vm);
2328
2329 #define CHECK_EXCEPTION() do { \
2330         if (scope.exception()) { \
2331             scope.clearException(); \
2332             return; \
2333         } \
2334     } while (false)
2335
2336     auto exceptionString = exception.toWTFString(globalObject->globalExec());
2337     Expected<CString, UTF8ConversionError> expectedCString = exceptionString.tryGetUtf8();
2338     if (expectedCString)
2339         printf("Exception: %s\n", expectedCString.value().data());
2340     else
2341         printf("Exception: <out of memory while extracting exception string>\n");
2342
2343     Identifier nameID = Identifier::fromString(globalObject->globalExec(), "name");
2344     CHECK_EXCEPTION();
2345     Identifier fileNameID = Identifier::fromString(globalObject->globalExec(), "sourceURL");
2346     CHECK_EXCEPTION();
2347     Identifier lineNumberID = Identifier::fromString(globalObject->globalExec(), "line");
2348     CHECK_EXCEPTION();
2349     Identifier stackID = Identifier::fromString(globalObject->globalExec(), "stack");
2350     CHECK_EXCEPTION();
2351
2352     JSValue nameValue = exception.get(globalObject->globalExec(), nameID);
2353     CHECK_EXCEPTION();
2354     JSValue fileNameValue = exception.get(globalObject->globalExec(), fileNameID);
2355     CHECK_EXCEPTION();
2356     JSValue lineNumberValue = exception.get(globalObject->globalExec(), lineNumberID);
2357     CHECK_EXCEPTION();
2358     JSValue stackValue = exception.get(globalObject->globalExec(), stackID);
2359     CHECK_EXCEPTION();
2360     
2361     if (nameValue.toWTFString(globalObject->globalExec()) == "SyntaxError"
2362         && (!fileNameValue.isUndefinedOrNull() || !lineNumberValue.isUndefinedOrNull())) {
2363         printf(
2364             "at %s:%s\n",
2365             fileNameValue.toWTFString(globalObject->globalExec()).utf8().data(),
2366             lineNumberValue.toWTFString(globalObject->globalExec()).utf8().data());
2367     }
2368     
2369     if (!stackValue.isUndefinedOrNull()) {
2370         auto stackString = stackValue.toWTFString(globalObject->globalExec());
2371         if (stackString.length())
2372             printf("%s\n", stackString.utf8().data());
2373     }
2374
2375 #undef CHECK_EXCEPTION
2376 }
2377
2378 static bool checkUncaughtException(VM& vm, GlobalObject* globalObject, JSValue exception, CommandLine& options)
2379 {
2380     const String& expectedExceptionName = options.m_uncaughtExceptionName;
2381     auto scope = DECLARE_CATCH_SCOPE(vm);
2382     scope.clearException();
2383     if (!exception) {
2384         printf("Expected uncaught exception with name '%s' but none was thrown\n", expectedExceptionName.utf8().data());
2385         return false;
2386     }
2387
2388     ExecState* exec = globalObject->globalExec();
2389     JSValue exceptionClass = globalObject->get(exec, Identifier::fromString(exec, expectedExceptionName));
2390     if (!exceptionClass.isObject() || scope.exception()) {
2391         printf("Expected uncaught exception with name '%s' but given exception class is not defined\n", expectedExceptionName.utf8().data());
2392         return false;
2393     }
2394
2395     bool isInstanceOfExpectedException = jsCast<JSObject*>(exceptionClass)->hasInstance(exec, exception);
2396     if (scope.exception()) {
2397         printf("Expected uncaught exception with name '%s' but given exception class fails performing hasInstance\n", expectedExceptionName.utf8().data());
2398         return false;
2399     }
2400     if (isInstanceOfExpectedException) {
2401         if (options.m_alwaysDumpUncaughtException)
2402             dumpException(globalObject, exception);
2403         return true;
2404     }
2405
2406     printf("Expected uncaught exception with name '%s' but exception value is not instance of this exception class\n", expectedExceptionName.utf8().data());
2407     dumpException(globalObject, exception);
2408     return false;
2409 }
2410
2411 static void checkException(ExecState* exec, GlobalObject* globalObject, bool isLastFile, bool hasException, JSValue value, CommandLine& options, bool& success)
2412 {
2413     VM& vm = globalObject->vm();
2414
2415     if (options.m_treatWatchdogExceptionAsSuccess && value.inherits<TerminatedExecutionError>(vm)) {
2416         ASSERT(hasException);
2417         return;
2418     }
2419
2420     if (!options.m_uncaughtExceptionName || !isLastFile) {
2421         success = success && !hasException;
2422         if (options.m_dump && !hasException)
2423             printf("End: %s\n", value.toWTFString(exec).utf8().data());
2424         if (hasException)
2425             dumpException(globalObject, value);
2426     } else
2427         success = success && checkUncaughtException(vm, globalObject, (hasException) ? value : JSValue(), options);
2428 }
2429
2430 static void runWithOptions(GlobalObject* globalObject, CommandLine& options, bool& success)
2431 {
2432     Vector<Script>& scripts = options.m_scripts;
2433     String fileName;
2434     Vector<char> scriptBuffer;
2435
2436     if (options.m_dump)
2437         JSC::Options::dumpGeneratedBytecodes() = true;
2438
2439     VM& vm = globalObject->vm();
2440     auto scope = DECLARE_CATCH_SCOPE(vm);
2441
2442 #if ENABLE(SAMPLING_FLAGS)
2443     SamplingFlags::start();
2444 #endif
2445
2446     for (size_t i = 0; i < scripts.size(); i++) {
2447         JSInternalPromise* promise = nullptr;
2448         bool isModule = options.m_module || scripts[i].scriptType == Script::ScriptType::Module;
2449         if (scripts[i].codeSource == Script::CodeSource::File) {
2450             fileName = scripts[i].argument;
2451             if (scripts[i].strictMode == Script::StrictMode::Strict)
2452                 scriptBuffer.append("\"use strict\";\n", strlen("\"use strict\";\n"));
2453
2454             if (isModule) {
2455                 promise = loadAndEvaluateModule(globalObject->globalExec(), fileName, jsUndefined(), jsUndefined());
2456                 scope.releaseAssertNoException();
2457             } else {
2458                 if (!fetchScriptFromLocalFileSystem(fileName, scriptBuffer)) {
2459                     success = false; // fail early so we can catch missing files
2460                     return;
2461                 }
2462             }
2463         } else {
2464             size_t commandLineLength = strlen(scripts[i].argument);
2465             scriptBuffer.resize(commandLineLength);
2466             std::copy(scripts[i].argument, scripts[i].argument + commandLineLength, scriptBuffer.begin());
2467             fileName = "[Command Line]"_s;
2468         }
2469
2470         bool isLastFile = i == scripts.size() - 1;
2471         if (isModule) {
2472             if (!promise) {
2473                 // FIXME: This should use an absolute file URL https://bugs.webkit.org/show_bug.cgi?id=193077
2474                 promise = loadAndEvaluateModule(globalObject->globalExec(), makeSource(stringFromUTF(scriptBuffer), SourceOrigin { absolutePath(fileName) }, URL({ }, fileName), TextPosition(), SourceProviderSourceType::Module), jsUndefined());
2475             }
2476             scope.clearException();
2477
2478             JSFunction* fulfillHandler = JSNativeStdFunction::create(vm, globalObject, 1, String(), [&success, &options, isLastFile](ExecState* exec) {
2479                 checkException(exec, jsCast<GlobalObject*>(exec->lexicalGlobalObject()), isLastFile, false, exec->argument(0), options, success);
2480                 return JSValue::encode(jsUndefined());
2481             });
2482
2483             JSFunction* rejectHandler = JSNativeStdFunction::create(vm, globalObject, 1, String(), [&success, &options, isLastFile](ExecState* exec) {
2484                 checkException(exec, jsCast<GlobalObject*>(exec->lexicalGlobalObject()), isLastFile, true, exec->argument(0), options, success);
2485                 return JSValue::encode(jsUndefined());
2486             });
2487
2488             promise->then(globalObject->globalExec(), fulfillHandler, rejectHandler);
2489             scope.releaseAssertNoException();
2490             vm.drainMicrotasks();
2491         } else {
2492             NakedPtr<Exception> evaluationException;
2493             JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(scriptBuffer, SourceOrigin { absolutePath(fileName) }, fileName), JSValue(), evaluationException);
2494             scope.assertNoException();
2495             if (evaluationException)
2496                 returnValue = evaluationException->value();
2497             checkException(globalObject->globalExec(), globalObject, isLastFile, evaluationException, returnValue, options, success);
2498         }
2499
2500         scriptBuffer.clear();
2501         scope.clearException();
2502     }
2503
2504 #if ENABLE(REGEXP_TRACING)
2505     vm.dumpRegExpTrace();
2506 #endif
2507 }
2508
2509 #define RUNNING_FROM_XCODE 0
2510
2511 static void runInteractive(GlobalObject* globalObject)
2512 {
2513     VM& vm = globalObject->vm();
2514     auto scope = DECLARE_CATCH_SCOPE(vm);
2515
2516     Optional<DirectoryName> directoryName = currentWorkingDirectory();
2517     if (!directoryName)
2518         return;
2519     SourceOrigin sourceOrigin(resolvePath(directoryName.value(), ModuleName("interpreter")));
2520     
2521     bool shouldQuit = false;
2522     while (!shouldQuit) {
2523 #if HAVE(READLINE) && !RUNNING_FROM_XCODE
2524         ParserError error;
2525         String source;
2526         do {
2527             error = ParserError();
2528             char* line = readline(source.isEmpty() ? interactivePrompt : "... ");
2529             shouldQuit = !line;
2530             if (!line)
2531                 break;
2532             source = source + String::fromUTF8(line);
2533             source = source + '\n';
2534             checkSyntax(vm, makeSource(source, sourceOrigin), error);
2535             if (!line[0]) {
2536                 free(line);
2537                 break;
2538             }
2539             add_history(line);
2540             free(line);
2541         } while (error.syntaxErrorType() == ParserError::SyntaxErrorRecoverable);
2542         
2543         if (error.isValid()) {
2544             printf("%s:%d\n", error.message().utf8().data(), error.line());
2545             continue;
2546         }
2547         
2548         
2549         NakedPtr<Exception> evaluationException;
2550         JSValue returnValue = evaluate(globalObject->globalExec(), makeSource(source, sourceOrigin), JSValue(), evaluationException);
2551 #else
2552         printf("%s", interactivePrompt);
2553         Vector<char, 256> line;
2554         int c;
2555         while ((c = getchar()) != EOF) {
2556             // FIXME: Should we also break on \r? 
2557             if (c == '\n')
2558                 break;
2559             line.append(c);
2560         }
2561         if (line.isEmpty())
2562             break;
2563
2564         NakedPtr<Exception> evaluationException;
2565         JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(line, sourceOrigin, sourceOrigin.string()), JSValue(), evaluationException);
2566 #endif
2567         if (evaluationException)
2568             printf("Exception: %s\n", evaluationException->value().toWTFString(globalObject->globalExec()).utf8().data());
2569         else
2570             printf("%s\n", returnValue.toWTFString(globalObject->globalExec()).utf8().data());
2571
2572         scope.clearException();
2573         vm.drainMicrotasks();
2574     }
2575     printf("\n");
2576 }
2577
2578 static NO_RETURN void printUsageStatement(bool help = false)
2579 {
2580     fprintf(stderr, "Usage: jsc [options] [files] [-- arguments]\n");
2581     fprintf(stderr, "  -d         Dumps bytecode (debug builds only)\n");
2582     fprintf(stderr, "  -e         Evaluate argument as script code\n");
2583     fprintf(stderr, "  -f         Specifies a source file (deprecated)\n");
2584     fprintf(stderr, "  -h|--help  Prints this help message\n");
2585     fprintf(stderr, "  -i         Enables interactive mode (default if no files are specified)\n");
2586     fprintf(stderr, "  -m         Execute as a module\n");
2587 #if HAVE(SIGNAL_H)
2588     fprintf(stderr, "  -s         Installs signal handlers that exit on a crash (Unix platforms only)\n");
2589 #endif
2590     fprintf(stderr, "  -p <file>  Outputs profiling data to a file\n");
2591     fprintf(stderr, "  -x         Output exit code before terminating\n");
2592     fprintf(stderr, "\n");
2593     fprintf(stderr, "  --sample                   Collects and outputs sampling profiler data\n");
2594     fprintf(stderr, "  --test262-async            Check that some script calls the print function with the string 'Test262:AsyncTestComplete'\n");
2595     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");
2596     fprintf(stderr, "  --module-file=<file>       Parse and evaluate the given file as module (this option may be passed more than once)\n");
2597     fprintf(stderr, "  --exception=<name>         Check the last script exits with an uncaught exception with the specified name\n");
2598     fprintf(stderr, "  --watchdog-exception-ok    Uncaught watchdog exceptions exit with success\n");
2599     fprintf(stderr, "  --dumpException            Dump uncaught exception text\n");
2600     fprintf(stderr, "  --footprint                Dump memory footprint after done executing\n");
2601     fprintf(stderr, "  --options                  Dumps all JSC VM options and exits\n");
2602     fprintf(stderr, "  --dumpOptions              Dumps all non-default JSC VM options before continuing\n");
2603     fprintf(stderr, "  --<jsc VM option>=<value>  Sets the specified JSC VM option\n");
2604     fprintf(stderr, "\n");
2605     fprintf(stderr, "Files with a .mjs extension will always be evaluated as modules.\n");
2606     fprintf(stderr, "\n");
2607
2608     jscExit(help ? EXIT_SUCCESS : EXIT_FAILURE);
2609 }
2610
2611 static bool isMJSFile(char *filename)
2612 {
2613     filename = strrchr(filename, '.');
2614
2615     if (filename)
2616         return !strcmp(filename, ".mjs");
2617
2618     return false;
2619 }
2620
2621 void CommandLine::parseArguments(int argc, char** argv)
2622 {
2623     Options::initialize();
2624     
2625     if (Options::dumpOptions()) {
2626         printf("Command line:");
2627 #if PLATFORM(COCOA)
2628         for (char** envp = *_NSGetEnviron(); *envp; envp++) {
2629             const char* env = *envp;
2630             if (!strncmp("JSC_", env, 4))
2631                 printf(" %s", env);
2632         }
2633 #endif // PLATFORM(COCOA)
2634         for (int i = 0; i < argc; ++i)
2635             printf(" %s", argv[i]);
2636         printf("\n");
2637     }
2638
2639     int i = 1;
2640     JSC::Options::DumpLevel dumpOptionsLevel = JSC::Options::DumpLevel::None;
2641     bool needToExit = false;
2642
2643     bool hasBadJSCOptions = false;
2644     for (; i < argc; ++i) {
2645         const char* arg = argv[i];
2646         if (!strcmp(arg, "-f")) {
2647             if (++i == argc)
2648                 printUsageStatement();
2649             m_scripts.append(Script(Script::StrictMode::Sloppy, Script::CodeSource::File, Script::ScriptType::Script, argv[i]));
2650             continue;
2651         }
2652         if (!strcmp(arg, "-e")) {
2653             if (++i == argc)
2654                 printUsageStatement();
2655             m_scripts.append(Script(Script::StrictMode::Sloppy, Script::CodeSource::CommandLine, Script::ScriptType::Script, argv[i]));
2656             continue;
2657         }
2658         if (!strcmp(arg, "-i")) {
2659             m_interactive = true;
2660             continue;
2661         }
2662         if (!strcmp(arg, "-d")) {
2663             m_dump = true;
2664             continue;
2665         }
2666         if (!strcmp(arg, "-p")) {
2667             if (++i == argc)
2668                 printUsageStatement();
2669             m_profile = true;
2670             m_profilerOutput = argv[i];
2671             continue;
2672         }
2673         if (!strcmp(arg, "-m")) {
2674             m_module = true;
2675             continue;
2676         }
2677         if (!strcmp(arg, "-s")) {
2678 #if HAVE(SIGNAL_H)
2679             signal(SIGILL, _exit);
2680             signal(SIGFPE, _exit);
2681             signal(SIGBUS, _exit);
2682             signal(SIGSEGV, _exit);
2683 #endif
2684             continue;
2685         }
2686         if (!strcmp(arg, "-x")) {
2687             m_exitCode = true;
2688             continue;
2689         }
2690         if (!strcmp(arg, "--")) {
2691             ++i;
2692             break;
2693         }
2694         if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
2695             printUsageStatement(true);
2696
2697         if (!strcmp(arg, "--options")) {
2698             dumpOptionsLevel = JSC::Options::DumpLevel::Verbose;
2699             needToExit = true;
2700             continue;
2701         }
2702         if (!strcmp(arg, "--dumpOptions")) {
2703             dumpOptionsLevel = JSC::Options::DumpLevel::Overridden;
2704             continue;
2705         }
2706         if (!strcmp(arg, "--sample")) {
2707             JSC::Options::useSamplingProfiler() = true;
2708             JSC::Options::collectSamplingProfilerDataForJSCShell() = true;
2709             m_dumpSamplingProfilerData = true;
2710             continue;
2711         }
2712
2713         static const char* timeoutMultiplierOptStr = "--timeoutMultiplier=";
2714         static const unsigned timeoutMultiplierOptStrLength = strlen(timeoutMultiplierOptStr);
2715         if (!strncmp(arg, timeoutMultiplierOptStr, timeoutMultiplierOptStrLength)) {
2716             const char* valueStr = &arg[timeoutMultiplierOptStrLength];
2717             if (sscanf(valueStr, "%lf", &s_timeoutMultiplier) != 1)
2718                 dataLog("WARNING: --timeoutMultiplier=", valueStr, " is invalid. Expects a numeric ratio.\n");
2719             continue;
2720         }
2721
2722         if (!strcmp(arg, "--test262-async")) {
2723             asyncTestExpectedPasses++;
2724             continue;
2725         }
2726
2727         if (!strcmp(arg, "--remote-debug")) {
2728             m_enableRemoteDebugging = true;
2729             continue;
2730         }
2731
2732         static const unsigned strictFileStrLength = strlen("--strict-file=");
2733         if (!strncmp(arg, "--strict-file=", strictFileStrLength)) {
2734             m_scripts.append(Script(Script::StrictMode::Strict, Script::CodeSource::File, Script::ScriptType::Script, argv[i] + strictFileStrLength));
2735             continue;
2736         }
2737
2738         static const unsigned moduleFileStrLength = strlen("--module-file=");
2739         if (!strncmp(arg, "--module-file=", moduleFileStrLength)) {
2740             m_scripts.append(Script(Script::StrictMode::Sloppy, Script::CodeSource::File, Script::ScriptType::Module, argv[i] + moduleFileStrLength));
2741             continue;
2742         }
2743
2744         if (!strcmp(arg, "--dumpException")) {
2745             m_alwaysDumpUncaughtException = true;
2746             continue;
2747         }
2748
2749         if (!strcmp(arg, "--footprint")) {
2750             m_dumpMemoryFootprint = true;
2751             continue;
2752         }
2753
2754         static const unsigned exceptionStrLength = strlen("--exception=");
2755         if (!strncmp(arg, "--exception=", exceptionStrLength)) {
2756             m_uncaughtExceptionName = String(arg + exceptionStrLength);
2757             continue;
2758         }
2759
2760         if (!strcmp(arg, "--watchdog-exception-ok")) {
2761             m_treatWatchdogExceptionAsSuccess = true;
2762             continue;
2763         }
2764
2765         // See if the -- option is a JSC VM option.
2766         if (strstr(arg, "--") == arg) {
2767             if (!JSC::Options::setOption(&arg[2])) {
2768                 hasBadJSCOptions = true;
2769                 dataLog("ERROR: invalid option: ", arg, "\n");
2770             }
2771             continue;
2772         }
2773
2774         // This arg is not recognized by the VM nor by jsc. Pass it on to the
2775         // script.
2776         Script::ScriptType scriptType = isMJSFile(argv[i]) ? Script::ScriptType::Module : Script::ScriptType::Script;
2777         m_scripts.append(Script(Script::StrictMode::Sloppy, Script::CodeSource::File, scriptType, argv[i]));
2778     }
2779
2780     if (hasBadJSCOptions && JSC::Options::validateOptions())
2781         CRASH();
2782
2783     if (m_scripts.isEmpty())
2784         m_interactive = true;
2785
2786     for (; i < argc; ++i)
2787         m_arguments.append(argv[i]);
2788
2789     if (dumpOptionsLevel != JSC::Options::DumpLevel::None) {
2790         const char* optionsTitle = (dumpOptionsLevel == JSC::Options::DumpLevel::Overridden)
2791             ? "Modified JSC runtime options:"
2792             : "All JSC runtime options:";
2793         JSC::Options::dumpAllOptions(stderr, dumpOptionsLevel, optionsTitle);
2794     }
2795     JSC::Options::ensureOptionsAreCoherent();
2796     if (needToExit)
2797         jscExit(EXIT_SUCCESS);
2798 }
2799
2800 template<typename Func>
2801 int runJSC(const CommandLine& options, bool isWorker, const Func& func)
2802 {
2803     Worker worker(Workers::singleton());
2804     
2805     VM& vm = VM::create(LargeHeap).leakRef();
2806     int result;
2807     bool success = true;
2808     GlobalObject* globalObject = nullptr;
2809     {
2810         JSLockHolder locker(vm);
2811
2812         if (options.m_profile && !vm.m_perBytecodeProfiler)
2813             vm.m_perBytecodeProfiler = std::make_unique<Profiler::Database>(vm);
2814
2815         globalObject = GlobalObject::create(vm, GlobalObject::createStructure(vm, jsNull()), options.m_arguments);
2816         globalObject->setRemoteDebuggingEnabled(options.m_enableRemoteDebugging);
2817         func(vm, globalObject, success);
2818         vm.drainMicrotasks();
2819     }
2820     vm.promiseDeferredTimer->runRunLoop();
2821     {
2822         JSLockHolder locker(vm);
2823         if (options.m_interactive && success)
2824             runInteractive(globalObject);
2825     }
2826
2827     result = success && (asyncTestExpectedPasses == asyncTestPasses) ? 0 : 3;
2828
2829     if (options.m_exitCode) {
2830         printf("jsc exiting %d", result);
2831         if (asyncTestExpectedPasses != asyncTestPasses)
2832             printf(" because expected: %d async test passes but got: %d async test passes", asyncTestExpectedPasses, asyncTestPasses);
2833         printf("\n");
2834     }
2835
2836     if (options.m_profile) {
2837         JSLockHolder locker(vm);
2838         if (!vm.m_perBytecodeProfiler->save(options.m_profilerOutput.utf8().data()))
2839             fprintf(stderr, "could not save profiler output.\n");
2840     }
2841
2842 #if ENABLE(JIT)
2843     {
2844         JSLockHolder locker(vm);
2845         if (Options::useExceptionFuzz())
2846             printf("JSC EXCEPTION FUZZ: encountered %u checks.\n", numberOfExceptionFuzzChecks());
2847         bool fireAtEnabled =
2848         Options::fireExecutableAllocationFuzzAt() || Options::fireExecutableAllocationFuzzAtOrAfter();
2849         if (Options::useExecutableAllocationFuzz() && (!fireAtEnabled || Options::verboseExecutableAllocationFuzz()))
2850             printf("JSC EXECUTABLE ALLOCATION FUZZ: encountered %u checks.\n", numberOfExecutableAllocationFuzzChecks());
2851         if (Options::useOSRExitFuzz()) {
2852             printf("JSC OSR EXIT FUZZ: encountered %u static checks.\n", numberOfStaticOSRExitFuzzChecks());
2853             printf("JSC OSR EXIT FUZZ: encountered %u dynamic checks.\n", numberOfOSRExitFuzzChecks());
2854         }
2855
2856         
2857         auto compileTimeStats = JIT::compileTimeStats();
2858         Vector<CString> compileTimeKeys;
2859         for (auto& entry : compileTimeStats)
2860             compileTimeKeys.append(entry.key);
2861         std::sort(compileTimeKeys.begin(), compileTimeKeys.end());
2862         for (const CString& key : compileTimeKeys)
2863             printf("%40s: %.3lf ms\n", key.data(), compileTimeStats.get(key).milliseconds());
2864     }
2865 #endif
2866
2867     if (Options::gcAtEnd()) {
2868         // We need to hold the API lock to do a GC.
2869         JSLockHolder locker(&vm);
2870         vm.heap.collectNow(Sync, CollectionScope::Full);
2871     }
2872
2873     if (options.m_dumpSamplingProfilerData) {
2874 #if ENABLE(SAMPLING_PROFILER)
2875         JSLockHolder locker(&vm);
2876         vm.samplingProfiler()->reportTopFunctions();
2877         vm.samplingProfiler()->reportTopBytecodes();
2878 #else
2879         dataLog("Sampling profiler is not enabled on this platform\n");
2880 #endif
2881     }
2882
2883     vm.codeCache()->write(vm);
2884
2885     if (isWorker) {
2886         JSLockHolder locker(vm);
2887         // This is needed because we don't want the worker's main
2888         // thread to die before its compilation threads finish.
2889         vm.deref();
2890     }
2891
2892     return result;
2893 }
2894
2895 int jscmain(int argc, char** argv)
2896 {
2897     // Need to override and enable restricted options before we start parsing options below.
2898     Options::enableRestrictedOptions(true);
2899
2900     // Note that the options parsing can affect VM creation, and thus
2901     // comes first.
2902     CommandLine options(argc, argv);
2903
2904     processConfigFile(Options::configFile(), "jsc");
2905
2906     // Initialize JSC before getting VM.
2907     WTF::initializeMainThread();
2908     JSC::initializeThreading();
2909     startTimeoutThreadIfNeeded();
2910 #if ENABLE(WEBASSEMBLY)
2911     JSC::Wasm::enableFastMemory();
2912 #endif
2913     Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled();
2914
2915 #if PLATFORM(COCOA)
2916     auto& memoryPressureHandler = MemoryPressureHandler::singleton();
2917     {
2918         dispatch_queue_t queue = dispatch_queue_create("jsc shell memory pressure handler", DISPATCH_QUEUE_SERIAL);
2919         memoryPressureHandler.setDispatchQueue(queue);
2920         dispatch_release(queue);
2921     }
2922     Box<Critical> memoryPressureCriticalState = Box<Critical>::create(Critical::No);
2923     Box<Synchronous> memoryPressureSynchronousState = Box<Synchronous>::create(Synchronous::No);
2924     memoryPressureHandler.setLowMemoryHandler([=] (Critical critical, Synchronous synchronous) {
2925         // We set these racily with respect to reading them from the JS execution thread.
2926         *memoryPressureCriticalState = critical;
2927         *memoryPressureSynchronousState = synchronous;
2928     });
2929     memoryPressureHandler.setShouldLogMemoryMemoryPressureEvents(false);
2930     memoryPressureHandler.install();
2931
2932     auto onEachMicrotaskTick = [&] (VM& vm) {
2933         if (*memoryPressureCriticalState == Critical::No)
2934             return;
2935
2936         *memoryPressureCriticalState = Critical::No;
2937         bool isSynchronous = *memoryPressureSynchronousState == Synchronous::Yes;
2938
2939         WTF::releaseFastMallocFreeMemory();
2940         vm.deleteAllCode(DeleteAllCodeIfNotCollecting);
2941
2942         if (!vm.heap.isCurrentThreadBusy()) {
2943             if (isSynchronous) {
2944                 vm.heap.collectNow(Sync, CollectionScope::Full);
2945                 WTF::releaseFastMallocFreeMemory();
2946             } else
2947                 vm.heap.collectNowFullIfNotDoneRecently(Async);
2948         }
2949     };
2950 #endif
2951
2952     int result = runJSC(
2953         options, false,
2954         [&] (VM& vm, GlobalObject* globalObject, bool& success) {
2955             UNUSED_PARAM(vm);
2956 #if PLATFORM(COCOA)
2957             vm.setOnEachMicrotaskTick(WTFMove(onEachMicrotaskTick));
2958 #endif
2959             runWithOptions(globalObject, options, success);
2960         });
2961
2962     printSuperSamplerState();
2963
2964     if (options.m_dumpMemoryFootprint) {
2965         MemoryFootprint footprint = MemoryFootprint::now();
2966
2967         printf("Memory Footprint:\n    Current Footprint: %" PRIu64 "\n    Peak Footprint: %" PRIu64 "\n", footprint.current, footprint.peak);
2968     }
2969
2970     return result;
2971 }
2972
2973 #if OS(WINDOWS)
2974 extern "C" __declspec(dllexport) int WINAPI dllLauncherEntryPoint(int argc, const char* argv[])
2975 {
2976     return main(argc, const_cast<char**>(argv));
2977 }
2978 #endif