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