MemoryFootprint(const ProcessMemoryFootprint& src)

: ProcessMemoryFootprint(src)

{

}

uint64_t current;

uint64_t peak;

static MemoryFootprint now()

{

return { 0L, 0L };

}

static void resetPeak()

{

}

{

waitForAsynchronousDisassembly();

#if ENABLE(DFG_JIT)

if (DFG::isCrashing()) {

for (;;) {

#if OS(WINDOWS)

Sleep(1000);

#else

pause();

#endif

}

}

#endif // ENABLE(DFG_JIT)

exit(status);

Message(ArrayBufferContents&&, int32_t);

~Message();

ArrayBufferContents&& releaseContents() { return WTFMove(m_contents); }

int32_t index() const { return m_index; }

ArrayBufferContents m_contents;

int32_t m_index { 0 };

Worker(Workers&);

~Worker();

void enqueue(const AbstractLocker&, RefPtr<Message>);

RefPtr<Message> dequeue();

static Worker& current();

static ThreadSpecific<Worker*>& currentWorker();

Workers& m_workers;

Deque<RefPtr<Message>> m_messages;

WTF_MAKE_FAST_ALLOCATED;

WTF_MAKE_NONCOPYABLE(Workers);

Workers();

~Workers();

template<typename Func>

void broadcast(const Func&);

void report(const String&);

String tryGetReport();

String getReport();

static Workers& singleton();

friend class Worker;

Lock m_lock;

Condition m_condition;

SentinelLinkedList<Worker, BasicRawSentinelNode<Worker>> m_workers;

Deque<String> m_reports;

enum class StrictMode {

Strict,

Sloppy

};

enum class ScriptType {

Script,

Module

};

enum class CodeSource {

File,

CommandLine

};

StrictMode strictMode;

CodeSource codeSource;

ScriptType scriptType;

char* argument;

Script(StrictMode strictMode, CodeSource codeSource, ScriptType scriptType, char *argument)

: strictMode(strictMode)

, codeSource(codeSource)

, scriptType(scriptType)

, argument(argument)

{

if (strictMode == StrictMode::Strict)

ASSERT(codeSource == CodeSource::File);

}

CommandLine(int argc, char** argv)

{

parseArguments(argc, argv);

}

enum CommandLineForWorkersTag { CommandLineForWorkers };

CommandLine(CommandLineForWorkersTag)

{

}

Vector<Script> m_scripts;

Vector<String> m_arguments;

String m_profilerOutput;

String m_uncaughtExceptionName;

bool m_interactive { false };

bool m_dump { false };

bool m_module { false };

bool m_exitCode { false };

bool m_destroyVM { false };

bool m_profile { false };

bool m_treatWatchdogExceptionAsSuccess { false };

bool m_alwaysDumpUncaughtException { false };

bool m_dumpMemoryFootprint { false };

bool m_dumpSamplingProfilerData { false };

bool m_enableRemoteDebugging { false };

void parseArguments(int, char**);

void start();

void stop();

long getElapsedMS(); // call stop() first

MonotonicTime m_startTime;

MonotonicTime m_stopTime;

using Base = JSGlobalObject;

static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)

{

GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure);

object->finishCreation(vm, arguments);

return object;

}

DECLARE_INFO;

static const GlobalObjectMethodTable s_globalObjectMethodTable;

static Structure* createStructure(VM& vm, JSValue prototype)

{

return Structure::create(vm, nullptr, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());

}

static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags::createAllEnabled(); }

GlobalObject(VM&, Structure*);

static constexpr unsigned DontEnum = 0 | PropertyAttribute::DontEnum;

void finishCreation(VM& vm, const Vector<String>& arguments)

{

Base::finishCreation(vm);

JSC_TO_STRING_TAG_WITHOUT_TRANSITION();

addFunction(vm, "debug", functionDebug, 1);

addFunction(vm, "describe", functionDescribe, 1);

addFunction(vm, "describeArray", functionDescribeArray, 1);

addFunction(vm, "print", functionPrintStdOut, 1);

addFunction(vm, "printErr", functionPrintStdErr, 1);

addFunction(vm, "quit", functionQuit, 0);

addFunction(vm, "gc", functionGCAndSweep, 0);

addFunction(vm, "fullGC", functionFullGC, 0);

addFunction(vm, "edenGC", functionEdenGC, 0);

addFunction(vm, "gcHeapSize", functionHeapSize, 0);

addFunction(vm, "MemoryFootprint", functionCreateMemoryFootprint, 0);

addFunction(vm, "resetMemoryPeak", functionResetMemoryPeak, 0);

addFunction(vm, "addressOf", functionAddressOf, 1);

addFunction(vm, "version", functionVersion, 1);

addFunction(vm, "run", functionRun, 1);

addFunction(vm, "runString", functionRunString, 1);

addFunction(vm, "load", functionLoad, 1);

addFunction(vm, "loadString", functionLoadString, 1);

addFunction(vm, "readFile", functionReadFile, 2);

addFunction(vm, "read", functionReadFile, 2);

addFunction(vm, "checkSyntax", functionCheckSyntax, 1);

addFunction(vm, "sleepSeconds", functionSleepSeconds, 1);

addFunction(vm, "jscStack", functionJSCStack, 1);

addFunction(vm, "readline", functionReadline, 0);

addFunction(vm, "preciseTime", functionPreciseTime, 0);

addFunction(vm, "neverInlineFunction", functionNeverInlineFunction, 1);

addFunction(vm, "noInline", functionNeverInlineFunction, 1);

addFunction(vm, "noDFG", functionNoDFG, 1);

addFunction(vm, "noFTL", functionNoFTL, 1);

addFunction(vm, "noOSRExitFuzzing", functionNoOSRExitFuzzing, 1);

addFunction(vm, "numberOfDFGCompiles", functionNumberOfDFGCompiles, 1);

addFunction(vm, "callerIsOMGCompiled", functionCallerIsOMGCompiled, 0);

addFunction(vm, "jscOptions", functionJSCOptions, 0);

addFunction(vm, "optimizeNextInvocation", functionOptimizeNextInvocation, 1);

addFunction(vm, "reoptimizationRetryCount", functionReoptimizationRetryCount, 1);

addFunction(vm, "transferArrayBuffer", functionTransferArrayBuffer, 1);

addFunction(vm, "failNextNewCodeBlock", functionFailNextNewCodeBlock, 1);

#if ENABLE(SAMPLING_FLAGS)

addFunction(vm, "setSamplingFlags", functionSetSamplingFlags, 1);

addFunction(vm, "clearSamplingFlags", functionClearSamplingFlags, 1);

#endif

putDirectNativeFunction(vm, this, Identifier::fromString(vm, "OSRExit"), 0, functionUndefined1, OSRExitIntrinsic, DontEnum);

putDirectNativeFunction(vm, this, Identifier::fromString(vm, "isFinalTier"), 0, functionFalse, IsFinalTierIntrinsic, DontEnum);

putDirectNativeFunction(vm, this, Identifier::fromString(vm, "predictInt32"), 0, functionUndefined2, SetInt32HeapPredictionIntrinsic, DontEnum);

putDirectNativeFunction(vm, this, Identifier::fromString(vm, "isInt32"), 0, functionIsInt32, CheckInt32Intrinsic, DontEnum);

putDirectNativeFunction(vm, this, Identifier::fromString(vm, "isPureNaN"), 0, functionIsPureNaN, CheckInt32Intrinsic, DontEnum);

putDirectNativeFunction(vm, this, Identifier::fromString(vm, "fiatInt52"), 0, functionIdentity, FiatInt52Intrinsic, DontEnum);

addFunction(vm, "effectful42", functionEffectful42, 0);

addFunction(vm, "makeMasquerader", functionMakeMasquerader, 0);

addFunction(vm, "hasCustomProperties", functionHasCustomProperties, 0);

addFunction(vm, "createGlobalObject", functionCreateGlobalObject, 0);

addFunction(vm, "createHeapBigInt", functionCreateHeapBigInt, 1);

#if USE(BIGINT32)

addFunction(vm, "createBigInt32", functionCreateBigInt32, 1);

#endif

addFunction(vm, "useBigInt32", functionUseBigInt32, 0);

addFunction(vm, "isBigInt32", functionIsBigInt32, 1);

addFunction(vm, "isHeapBigInt", functionIsHeapBigInt, 1);

addFunction(vm, "dumpTypesForAllVariables", functionDumpTypesForAllVariables , 0);

addFunction(vm, "drainMicrotasks", functionDrainMicrotasks, 0);

addFunction(vm, "setTimeout", functionSetTimeout, 2);

addFunction(vm, "releaseWeakRefs", functionReleaseWeakRefs, 0);

addFunction(vm, "finalizationRegistryLiveCount", functionFinalizationRegistryLiveCount, 0);

addFunction(vm, "finalizationRegistryDeadCount", functionFinalizationRegistryDeadCount, 0);

addFunction(vm, "getRandomSeed", functionGetRandomSeed, 0);

addFunction(vm, "setRandomSeed", functionSetRandomSeed, 1);

addFunction(vm, "isRope", functionIsRope, 1);

addFunction(vm, "callerSourceOrigin", functionCallerSourceOrigin, 0);

addFunction(vm, "is32BitPlatform", functionIs32BitPlatform, 0);

addFunction(vm, "checkModuleSyntax", functionCheckModuleSyntax, 1);

addFunction(vm, "platformSupportsSamplingProfiler", functionPlatformSupportsSamplingProfiler, 0);

addFunction(vm, "generateHeapSnapshot", functionGenerateHeapSnapshot, 0);

addFunction(vm, "generateHeapSnapshotForGCDebugging", functionGenerateHeapSnapshotForGCDebugging, 0);

addFunction(vm, "resetSuperSamplerState", functionResetSuperSamplerState, 0);

addFunction(vm, "ensureArrayStorage", functionEnsureArrayStorage, 0);

#if ENABLE(SAMPLING_PROFILER)

addFunction(vm, "startSamplingProfiler", functionStartSamplingProfiler, 0);

addFunction(vm, "samplingProfilerStackTraces", functionSamplingProfilerStackTraces, 0);

#endif

addFunction(vm, "maxArguments", functionMaxArguments, 0);

addFunction(vm, "asyncTestStart", functionAsyncTestStart, 1);

addFunction(vm, "asyncTestPassed", functionAsyncTestPassed, 1);

#if ENABLE(WEBASSEMBLY)

addFunction(vm, "WebAssemblyMemoryMode", functionWebAssemblyMemoryMode, 1);

#endif

if (!arguments.isEmpty()) {

JSArray* array = constructEmptyArray(this, nullptr);

for (size_t i = 0; i < arguments.size(); ++i)

array->putDirectIndex(this, i, jsString(vm, arguments[i]));

putDirect(vm, Identifier::fromString(vm, "arguments"), array, DontEnum);

}

putDirect(vm, Identifier::fromString(vm, "console"), jsUndefined(), DontEnum);

Structure* plainObjectStructure = JSFinalObject::createStructure(vm, this, objectPrototype(), 0);

JSObject* dollar = JSFinalObject::create(vm, plainObjectStructure);

putDirect(vm, Identifier::fromString(vm, "$"), dollar, DontEnum);

putDirect(vm, Identifier::fromString(vm, "$262"), dollar, DontEnum);

addFunction(vm, dollar, "createRealm", functionDollarCreateRealm, 0);

addFunction(vm, dollar, "detachArrayBuffer", functionTransferArrayBuffer, 1);

addFunction(vm, dollar, "evalScript", functionDollarEvalScript, 1);

dollar->putDirect(vm, Identifier::fromString(vm, "global"), this, DontEnum);

dollar->putDirectCustomAccessor(vm, Identifier::fromString(vm, "IsHTMLDDA"),

CustomGetterSetter::create(vm, accessorMakeMasquerader, nullptr),

static_cast<unsigned>(PropertyAttribute::CustomValue)

);

JSObject* agent = JSFinalObject::create(vm, plainObjectStructure);

dollar->putDirect(vm, Identifier::fromString(vm, "agent"), agent, DontEnum);

// The test262 INTERPRETING.md document says that some of these functions are just in the main

// thread and some are in the other threads. We just put them in all threads.

addFunction(vm, agent, "start", functionDollarAgentStart, 1);

addFunction(vm, agent, "receiveBroadcast", functionDollarAgentReceiveBroadcast, 1);

addFunction(vm, agent, "report", functionDollarAgentReport, 1);

addFunction(vm, agent, "sleep", functionDollarAgentSleep, 1);

addFunction(vm, agent, "broadcast", functionDollarAgentBroadcast, 1);

addFunction(vm, agent, "getReport", functionDollarAgentGetReport, 0);

addFunction(vm, agent, "leaving", functionDollarAgentLeaving, 0);

addFunction(vm, agent, "monotonicNow", functionDollarAgentMonotonicNow, 0);

addFunction(vm, "waitForReport", functionWaitForReport, 0);

addFunction(vm, "heapCapacity", functionHeapCapacity, 0);

addFunction(vm, "flashHeapAccess", functionFlashHeapAccess, 0);

addFunction(vm, "disableRichSourceInfo", functionDisableRichSourceInfo, 0);

addFunction(vm, "mallocInALoop", functionMallocInALoop, 0);

addFunction(vm, "totalCompileTime", functionTotalCompileTime, 0);

addFunction(vm, "setUnhandledRejectionCallback", functionSetUnhandledRejectionCallback, 1);

addFunction(vm, "asDoubleNumber", functionAsDoubleNumber, 1);

if (Options::exposeCustomSettersOnGlobalObjectForTesting()) {

{

CustomGetterSetter* custom = CustomGetterSetter::create(vm, nullptr, testCustomAccessorSetter);

Identifier identifier = Identifier::fromString(vm, "testCustomAccessorSetter");

this->putDirectCustomAccessor(vm, identifier, custom, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::CustomAccessor);

}

{

CustomGetterSetter* custom = CustomGetterSetter::create(vm, nullptr, testCustomValueSetter);

Identifier identifier = Identifier::fromString(vm, "testCustomValueSetter");

this->putDirectCustomAccessor(vm, identifier, custom, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::CustomValue);

}

}

}

static bool testCustomSetterImpl(JSGlobalObject* lexicalGlobalObject, GlobalObject* thisObject, EncodedJSValue encodedValue, const char* propertyName)

{

VM& vm = lexicalGlobalObject->vm();

Identifier identifier = Identifier::fromString(vm, propertyName);

thisObject->putDirect(vm, identifier, JSValue::decode(encodedValue), DontEnum);

return true;

}

void addFunction(VM& vm, JSObject* object, const char* name, NativeFunction function, unsigned arguments)

{

Identifier identifier = Identifier::fromString(vm, name);

object->putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function), DontEnum);

}

void addFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)

{

addFunction(vm, this, name, function, arguments);

}

static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject*, JSModuleLoader*, JSString*, JSValue, const SourceOrigin&);

static Identifier moduleLoaderResolve(JSGlobalObject*, JSModuleLoader*, JSValue, JSValue, JSValue);

static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, JSModuleLoader*, JSValue, JSValue, JSValue);

static JSObject* moduleLoaderCreateImportMetaProperties(JSGlobalObject*, JSModuleLoader*, JSValue, JSModuleRecord*, JSValue);

static void reportUncaughtExceptionAtEventLoop(JSGlobalObject*, Exception*);

{

#if OS(WINDOWS)

return '\\';

#else

return '/';

#endif

{

#if OS(WINDOWS)

// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364934.aspx

// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx#maxpath

// The _MAX_PATH in Windows is 260. If the path of the current working directory is longer than that, _getcwd truncates the result.

// And other I/O functions taking a path name also truncate it. To avoid this situation,

//

// (1). When opening the file in Windows for modules, we always use the abosolute path and add "\\?\" prefix to the path name.

// (2). When retrieving the current working directory, use GetCurrentDirectory instead of _getcwd.

//

// In the path utility functions inside the JSC shell, we does not handle the UNC and UNCW including the network host name.

DWORD bufferLength = ::GetCurrentDirectoryW(0, nullptr);

if (!bufferLength)

return { };

// In Windows, wchar_t is the UTF-16LE.

// https://msdn.microsoft.com/en-us/library/dd374081.aspx

// https://msdn.microsoft.com/en-us/library/windows/desktop/ff381407.aspx

Vector<wchar_t> buffer(bufferLength);

DWORD lengthNotIncludingNull = ::GetCurrentDirectoryW(bufferLength, buffer.data());

String directoryString(buffer.data(), lengthNotIncludingNull);

// We don't support network path like \\host\share\<path name>.

if (directoryString.startsWith("\\\\"))

return { };

#else

Vector<char> buffer(PATH_MAX);

if (!getcwd(buffer.data(), PATH_MAX))

return { };

String directoryString = String::fromUTF8(buffer.data());

#endif

if (directoryString.isEmpty())

return { };

// Add a trailing slash if needed so the URL resolves to a directory and not a file.

if (directoryString[directoryString.length() - 1] != pathSeparator())

directoryString = makeString(directoryString, pathSeparator());

return URL::fileURLWithFileSystemPath(directoryString);

{

auto directoryName = currentWorkingDirectory();

if (!directoryName.isValid())

return URL::fileURLWithFileSystemPath(fileName);

return URL(directoryName, fileName);

{

VM& vm = globalObject->vm();

auto scope = DECLARE_THROW_SCOPE(vm);

scope.releaseAssertNoException();

const Identifier key = keyValue.toPropertyKey(globalObject);

RETURN_IF_EXCEPTION(scope, { });

if (key.isSymbol())

return key;

auto resolvePath = [&] (const URL& directoryURL) -> Identifier {

String specifier = key.impl();

if (!specifier.startsWith('/') && !specifier.startsWith("./") && !specifier.startsWith("../")) {

throwTypeError(globalObject, scope, makeString("Module specifier, '"_s, specifier, "' does not start with \"/\", \"./\", or \"../\". Referenced from: "_s, directoryURL.fileSystemPath()));

return { };

}

if (!directoryURL.isLocalFile()) {

throwException(globalObject, scope, createError(globalObject, makeString("Could not resolve the referrer's path: ", directoryURL.string())));

return { };

}

URL resolvedURL(directoryURL, specifier);

if (!resolvedURL.isValid()) {

throwException(globalObject, scope, createError(globalObject, makeString("Resolved module url is not valid: ", resolvedURL.string())));

return { };

}

ASSERT(resolvedURL.isLocalFile());

return Identifier::fromString(vm, resolvedURL.string());

};

if (referrerValue.isUndefined())

return resolvePath(currentWorkingDirectory());

const Identifier referrer = referrerValue.toPropertyKey(globalObject);

RETURN_IF_EXCEPTION(scope, { });

if (referrer.isSymbol())

return resolvePath(currentWorkingDirectory());

// If the referrer exists, we assume that the referrer is the correct file url.

URL url = URL({ }, referrer.impl());

ASSERT(url.isLocalFile());

return resolvePath(url);

{

if (buffer.size() >= 2) {

if (buffer[0] == '#' && buffer[1] == '!')

buffer[0] = buffer[1] = '/';

}

{

if (fseek(file, 0, SEEK_END) == -1)

return nullptr;

long bufferCapacity = ftell(file);

if (bufferCapacity == -1)

return nullptr;

if (fseek(file, 0, SEEK_SET) == -1)

return nullptr;

auto result = Uint8Array::tryCreate(bufferCapacity);

if (!result)

return nullptr;

size_t readSize = fread(result->data(), 1, bufferCapacity, file);

if (readSize != static_cast<size_t>(bufferCapacity))

return nullptr;

return result;

{

FILE* f = fopen(fileName.utf8().data(), "rb");

if (!f) {

fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());

return nullptr;

}

RefPtr<Uint8Array> result = fillBufferWithContentsOfFile(f);

fclose(f);

return result;

{

// We might have injected "use strict"; at the top.

size_t initialSize = buffer.size();

if (fseek(file, 0, SEEK_END) == -1)

return false;

long bufferCapacity = ftell(file);

if (bufferCapacity == -1)

return false;

if (fseek(file, 0, SEEK_SET) == -1)

return false;

buffer.resize(bufferCapacity + initialSize);

size_t readSize = fread(buffer.data() + initialSize, 1, buffer.size(), file);

return readSize == buffer.size() - initialSize;

{

FILE* f = fopen(fileName.utf8().data(), "rb");

if (!f) {

fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());

return false;

}

bool result = fillBufferWithContentsOfFile(f, buffer);

fclose(f);

return result;

{

if (!fillBufferWithContentsOfFile(fileName, buffer))

return false;

convertShebangToJSComment(buffer);

return true;

static Ref<ShellSourceProvider> create(const String& source, const SourceOrigin& sourceOrigin, String&& sourceURL, const TextPosition& startPosition, SourceProviderSourceType sourceType)

{

return adoptRef(*new ShellSourceProvider(source, sourceOrigin, WTFMove(sourceURL), startPosition, sourceType));

}

~ShellSourceProvider() final

{

commitCachedBytecode();

}

RefPtr<CachedBytecode> cachedBytecode() const final

{

if (!m_cachedBytecode)

loadBytecode();

return m_cachedBytecode.copyRef();

}

void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&, CodeSpecializationKind kind, const UnlinkedFunctionCodeBlock* codeBlock) const final