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