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