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