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