MemoryFootprint(const ProcessMemoryFootprint& src)

: ProcessMemoryFootprint(src)

{

}

uint64_t current;

uint64_t peak;

static MemoryFootprint now()

{

return { 0L, 0L };

}

static void resetPeak()

{

}

{

#if ENABLE(DFG_JIT)

if (DFG::isCrashing()) {

for (;;) {

#if OS(WINDOWS)

Sleep(1000);

#else

pause();

#endif

}

}

#endif // ENABLE(DFG_JIT)

exitProcess(status);

static Ref<Message> create(Vector<uint8_t>&& data, CloneSerializationSideChannels&& sideChannels, int32_t index)

{

return adoptRef(*new Message(WTF::move(data), WTF::move(sideChannels), index));

}

std::span<const uint8_t> data() const { return m_data.span(); }

int32_t LEGACY_NODELETE index() const { return m_index; }

// Every recipient worker gets this same Message and deserializes from it concurrently, which

// is safe because the side channels (other than arrayBufferContents) are read-only.

CloneDeserializationSideChannels sideChannels()

{

return {

// Broadcast never transfers buffers, so there is no transferred-buffer channel.

.arrayBufferContents = nullptr,

.sharedBuffers = &m_sideChannels.sharedBuffers,

#if ENABLE(WEBASSEMBLY)

.wasmModules = &m_sideChannels.wasmModules,

.wasmMemoryHandles = &m_sideChannels.wasmMemoryHandles,

#endif

};

}

Message(Vector<uint8_t>&& data, CloneSerializationSideChannels&& sideChannels, int32_t index)

: m_data(WTF::move(data))

, m_sideChannels(WTF::move(sideChannels))

, m_index(index)

{

}

const Vector<uint8_t> m_data;

CloneSerializationSideChannels m_sideChannels;

int32_t m_index { 0 };

Worker(Workers&, bool isMain);

~Worker();

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

RefPtr<Message> dequeue();

bool LEGACY_NODELETE isMain() const { return m_isMain; }

static Worker& current();

static ThreadSpecific<Worker*>& currentWorker();

Workers& m_workers;

Deque<RefPtr<Message>> m_messages;

const bool m_isMain;

WTF_MAKE_TZONE_ALLOCATED(Workers);

WTF_MAKE_NONCOPYABLE(Workers);

Workers();

~Workers();

template<typename Func>

void broadcast(NOESCAPE 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;

using Base = CloneSerializerBase<JSCCloneSerializer>;

struct Result {

SerializationReturnCode code;

SideChannels sideChannels;

};

static Result serialize(JSGlobalObject* globalObject, JSValue value, Vector<uint8_t>& out, const ArgList& transferList = ArgList())

{

JSCCloneSerializer serializer(globalObject, out);

for (unsigned i = 0; i < transferList.size(); ++i)

serializer.m_transferredArrayBuffers.add(asObject(transferList.at(i)), i);

auto code = serializer.Base::serialize(value);

return { code, serializer.takeSideChannels() };

}

bool dumpDerivedTerminal(JSObject*, SerializationReturnCode&) { return false; }

JSCCloneSerializer(JSGlobalObject* globalObject, Vector<uint8_t>& out)

: Base(globalObject, out)

{

write(currentVersion());

}

using Base = CloneDeserializerBase<JSCCloneDeserializer>;

static DeserializationResult deserialize(JSGlobalObject* globalObject, std::span<const uint8_t> data,

CloneDeserializationSideChannels sideChannels)

{

JSCCloneDeserializer deserializer(globalObject, data, sideChannels);

if (!deserializer.isValid())

return { JSValue(), SerializationReturnCode::ValidationError };

return deserializer.Base::deserialize();

}

bool isTagExposed(SerializationTag) const { return true; }

// An empty JSValue tells CloneDeserializerBase::readTerminal() that the tag it just consumed

// isn't a terminal after all, so it should rewind and let the walker re-read the tag as the

// start of an Array/Object/Map/Set.

JSValue readDerivedTerminal(SerializationTag) { return { }; }

JSCCloneDeserializer(JSGlobalObject* globalObject, std::span<const uint8_t> data, CloneDeserializationSideChannels sideChannels)

: Base(globalObject, globalObject, data, sideChannels)

{

readAndStoreVersion();

}

{

switch (code) {

case SerializationReturnCode::SuccessfullyCompleted:

RELEASE_ASSERT_NOT_REACHED();

case SerializationReturnCode::StackOverflowError:

return throwVMException(globalObject, scope, createStackOverflowError(globalObject));

case SerializationReturnCode::ValidationError:

case SerializationReturnCode::DataCloneError:

return throwVMTypeError(globalObject, scope, "Value could not be cloned."_s);

case SerializationReturnCode::ExistingExceptionError:

ASSERT(scope.exception());

return encodedJSValue();

case SerializationReturnCode::InterruptedExecutionError:

case SerializationReturnCode::UnspecifiedError:

break;

}

return throwVMException(globalObject, scope, createError(globalObject, "Value could not be cloned."_s));

enum class StrictMode {

Strict,

Sloppy

};

enum class ScriptType {

Script,

Module

};

enum class CodeSource {

File,

CommandLine,

#if ENABLE(FUZZILLI)

Reprl,

#endif

};

StrictMode strictMode;

CodeSource codeSource;

ScriptType scriptType;

String argument;

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

: strictMode(strictMode)

, codeSource(codeSource)

, scriptType(scriptType)

, argument(String::fromLatin1(argument))

{

if (strictMode == StrictMode::Strict)

ASSERT(codeSource == CodeSource::File);

}

CommandLine(int argc, char** argv)

{

parseArguments(argc, argv);

}

enum CommandLineForWorkersTag { CommandLineForWorkers };

explicit CommandLine(CommandLineForWorkersTag);

Vector<Script> m_scripts;

Vector<String> m_arguments;

String m_profilerOutput;

String m_uncaughtExceptionName;

bool m_interactive { false };

bool m_module { false };

bool m_exitCode { false };

bool m_destroyVM { false };

bool m_treatWatchdogExceptionAsSuccess { false };

bool m_ignoreUncaughtExceptions { false };

bool m_alwaysDumpUncaughtException { false };

bool m_dumpMemoryFootprint { false };

bool m_dumpLinkBufferStats { false };

bool m_dumpSamplingProfilerData { false };

bool m_inspectable { false };

bool m_canBlockIsFalse { false };

bool m_reprl { false }; // Set to true to use Fuzzilli.

void parseArguments(int, char**, int start = 1);

void start();

void stop();

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

MonotonicTime m_startTime;

MonotonicTime m_stopTime;

using Base = JSGlobalObject;

static constexpr unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertyNames;

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

{

GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(vm)) 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 LEGACY_NODELETE javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags::createAllEnabled(); }

static void getOwnPropertyNames(JSObject* object, JSGlobalObject* globalObject, PropertyNameArrayBuilder& propertyNames, DontEnumPropertiesMode mode)

{

VM& vm = globalObject->vm();

PropertyNameArrayBuilder ownPropertyNames(vm, propertyNames.propertyNameMode(), propertyNames.privateSymbolMode());

Base::getOwnPropertyNames(object, globalObject, ownPropertyNames, mode);

auto* thisObject = uncheckedDowncast<GlobalObject>(object);

auto& filter = thisObject->ensurePropertyFilter();

for (auto& propertyName : ownPropertyNames) {

if (!filter.contains(propertyName.impl()))

propertyNames.add(propertyName);

}

}

GlobalObject(VM&, Structure*);

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

class PropertyFilter : public SideDataRepository::SideData {

WTF_DEPRECATED_MAKE_FAST_ALLOCATED(PropertyFilter);

public:

void add(UniquedStringImpl* uid)

{

auto result = m_names.add(uid);

if (result.isNewEntry)

m_strings.append(uid);

}

bool contains(UniquedStringImpl* name) const { return m_names.contains(name); }

const UncheckedKeyHashSet<UniquedStringImpl*>& LEGACY_NODELETE names() const { return m_names; }

private:

Vector<AtomString> m_strings; // To keep the UniqueStringImpls alive.

UncheckedKeyHashSet<UniquedStringImpl*> m_names;

};

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

{

// This shouldn't actually throw in practice, it's a test object. That said, it creates

// arrays and such that can generally throw.

auto scope = DECLARE_TOP_EXCEPTION_SCOPE(vm);

auto& filter = ensurePropertyFilter();

auto addFunction = [&] (VM& vm, ASCIILiteral name, NativeFunction function, unsigned arguments, unsigned attributes = static_cast<unsigned>(PropertyAttribute::DontEnum)) {

addFunctionImpl(filter, vm, name, function, arguments, attributes);

};

auto addFunctionToObject = [&] (VM& vm, JSObject* owner, ASCIILiteral name, NativeFunction function, unsigned arguments, unsigned attributes = static_cast<unsigned>(PropertyAttribute::DontEnum)) {

addFunctionToObjectImpl(filter, vm, owner, name, function, arguments, attributes);

};

auto putDirect = [&] (VM& vm, PropertyName propertyName, JSValue value, unsigned attributes = 0) -> bool {

return putDirectImpl(filter, vm, propertyName, value, attributes);

};

auto putDirectWithoutTransition = [&] (VM& vm, PropertyName propertyName, JSValue value, unsigned attributes) {

putDirectWithoutTransitionImpl(filter, vm, propertyName, value, attributes);

};

auto putDirectNativeFunction = [&] (VM& vm, JSGlobalObject* globalObject, const PropertyName& propertyName, unsigned functionLength, NativeFunction nativeFunction, ImplementationVisibility implementationVisibility, Intrinsic intrinsic, unsigned attributes) -> bool {

return putDirectNativeFunctionImpl(filter, vm, globalObject, propertyName, functionLength, nativeFunction, implementationVisibility, intrinsic, attributes);

};

Base::finishCreation(vm);

JSC_TO_STRING_TAG_WITHOUT_TRANSITION();

// Set loop counts based on enabled engine tiers. When concurrent JIT is off,

// clamp to a small multiple of the top tier's warm-up threshold so eager

// modes don't balloon stress-test runtime on the main thread.

auto clampLoopCount = [](uint32_t defaultCount, uint32_t noCJITCap) {

return Options::useConcurrentJIT() ? defaultCount : std::min(defaultCount, noCJITCap);

};

unsigned testLoopCount = clampLoopCount(10000, Options::thresholdForFTLOptimizeAfterWarmUp() * 3);

if (!Options::useDFGJIT())

testLoopCount = clampLoopCount(1000, Options::thresholdForOptimizeAfterWarmUp() * 3);

if (!Options::useBaselineJIT())

testLoopCount = clampLoopCount(100, Options::thresholdForJITAfterWarmUp() * 3);

unsigned wasmTestLoopCount = clampLoopCount(10000, Options::thresholdForOMGOptimizeAfterWarmUp() * 3);

if (!Options::useOMGJIT())

wasmTestLoopCount = clampLoopCount(1000, Options::thresholdForBBQOptimizeAfterWarmUp() * 3);

if (!Options::useBBQJIT())

wasmTestLoopCount = 100;

putDirect(vm, Identifier::fromString(vm, "testLoopCount"_s), jsNumber(testLoopCount), DontEnum);

putDirect(vm, Identifier::fromString(vm, "wasmTestLoopCount"_s), jsNumber(wasmTestLoopCount), DontEnum);

addFunction(vm, "atob"_s, functionAtob, 1);

addFunction(vm, "btoa"_s, functionBtoa, 1);

addFunction(vm, "structuredClone"_s, functionStructuredClone, 1);

addFunction(vm, "disassembleBase64"_s, functionDisassembleBase64, 1);

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

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

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

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

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

addFunction(vm, "prettyPrint"_s, functionPrettyPrint, 1);

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

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

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

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

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

addFunction(vm, "memoryUsageStatistics"_s, functionMemoryUsageStatistics, 0);

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

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

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

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

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

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

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

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

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

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

addFunction(vm, "writeFile"_s, functionWriteFile, 2);

addFunction(vm, "write"_s, functionWriteFile, 2);

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

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

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

addFunction(vm, "openFile"_s, functionOpenFile, 1);

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

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

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

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

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

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

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

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

addFunction(vm, "callerIsBBQOrOMGCompiled"_s, functionCallerIsBBQOrOMGCompiled, 0);

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

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

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

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

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

#if ENABLE(SAMPLING_FLAGS)

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

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

#endif

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

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

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

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

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

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

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

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

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

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

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

#if USE(BIGINT32)

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

#endif

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

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

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

addFunction(vm, "is8BitString"_s, functionIs8BitString, 1);

addFunction(vm, "createNonRopeNonAtomString"_s, functionCreateNonRopeNonAtomString, 1);

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

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

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

addFunction(vm, "dumpBytecodeProfile"_s, functionDumpBytecodeProfile, 1);

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

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

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

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

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

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

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

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

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

addFunction(vm, "checkScriptSyntax"_s, functionCheckScriptSyntax, 1);

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

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

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

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

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

addFunction(vm, "createNoopNativeFunctionWithCapture"_s, functionCreateNoopNativeFunctionWithCapture, 1);

#if ENABLE(SAMPLING_PROFILER)

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

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

#endif

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

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

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

#if ENABLE(WEBASSEMBLY)

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

addFunction(vm, "createWebAssemblyMemoryWithMode"_s, functionCreateWebAssemblyMemoryWithMode, 2);

#endif

if (!arguments.isEmpty()) {

JSArray* array = constructEmptyArray(this, nullptr);

scope.assertNoException();

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

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

scope.assertNoException();

}

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

}

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

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

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

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

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

addFunctionToObject(vm, dollar, "createRealm"_s, functionDollarCreateRealm, 0, static_cast<unsigned>(PropertyAttribute::None));

addFunctionToObject(vm, dollar, "detachArrayBuffer"_s, functionTransferArrayBuffer, 1, static_cast<unsigned>(PropertyAttribute::None));

addFunctionToObject(vm, dollar, "evalScript"_s, functionDollarEvalScript, 1, static_cast<unsigned>(PropertyAttribute::None));

addFunctionToObject(vm, dollar, "gc"_s, functionDollarGC, 0, static_cast<unsigned>(PropertyAttribute::None));

addFunctionToObject(vm, dollar, "clearKeptObjects"_s, functionDollarClearKeptObjects, 0, static_cast<unsigned>(PropertyAttribute::None));

addFunctionToObject(vm, dollar, "globalObjectFor"_s, functionDollarGlobalObjectFor, 1, static_cast<unsigned>(PropertyAttribute::None));

dollar->putDirect(vm, Identifier::fromString(vm, "global"_s), globalThis());

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

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

static_cast<unsigned>(PropertyAttribute::CustomValue)

);

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

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

// 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.

addFunctionToObject(vm, agent, "start"_s, functionDollarAgentStart, 1);

addFunctionToObject(vm, agent, "receiveBroadcast"_s, functionDollarAgentReceiveBroadcast, 1);

addFunctionToObject(vm, agent, "report"_s, functionDollarAgentReport, 1);

addFunctionToObject(vm, agent, "sleep"_s, functionDollarAgentSleep, 1);

addFunctionToObject(vm, agent, "broadcast"_s, functionDollarAgentBroadcast, 1);

addFunctionToObject(vm, agent, "getReport"_s, functionDollarAgentGetReport, 0);

addFunctionToObject(vm, agent, "leaving"_s, functionDollarAgentLeaving, 0);

addFunctionToObject(vm, agent, "monotonicNow"_s, functionDollarAgentMonotonicNow, 0);

addFunction(vm, "waiterListSize"_s, functionWaiterListSize, 2);

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

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

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

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

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

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

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

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

addFunction(vm, "dropAllLocks"_s, functionDropAllLocks, 1);

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

putDirect(vm, Identifier::fromString(vm, "performance"_s), performance, DontEnum);

addFunctionToObject(vm, performance, "now"_s, functionPerformanceNow, 0);

addFunctionToObject(vm, performance, "mark"_s, functionPerformanceMark, 1);

addFunctionToObject(vm, performance, "measure"_s, functionPerformanceMeasure, 2);

#if ENABLE(FUZZILLI)

addFunction(vm, "fuzzilli"_s, functionFuzzilli, 2);

#endif

if (Options::exposeCustomSettersOnGlobalObjectForTesting()) {

auto putDirectCustomAccessor = [&] (VM& vm, PropertyName propertyName, JSValue value, unsigned attributes) -> bool {

return putDirectCustomAccessorImpl(filter, vm, propertyName, value, attributes);

};

{

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

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

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

}

{

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

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

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

}

}

if (Options::useDollarVM()) {

// $vm is added in JSGlobalObject but we also want it filtered out. Just add it to the filter here.

Identifier dollarVMIdentifier = Identifier::fromString(vm, "$vm"_s);

rememberDontEnumProperty(filter, dollarVMIdentifier.impl(), 0 | PropertyAttribute::DontEnum);

}

#if PLATFORM(COCOA)

enableAllSDKAlignedBehaviors();

#endif

}

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

{

VM& vm = lexicalGlobalObject->vm();

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

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

return true;

}

bool putDirect(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes = 0)

{

auto& filter = ensurePropertyFilter();

return putDirectImpl(filter, vm, propertyName, value, attributes);

}

PropertyFilter& ensurePropertyFilter()

{

return vm().ensureSideData<PropertyFilter>(&propertyFilterSideDataKey, [] () -> std::unique_ptr<PropertyFilter> {

return makeUnique<PropertyFilter>();