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