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