Handle<JSObject> obj,

PropCacheID id) {

CompressedPointer clazzPtr{obj->getClassGCPtr()};

auto *cacheEntry = &fixedPropCache_[static_cast<int>(id)];

if (LLVM_LIKELY(cacheEntry->clazz == clazzPtr)) {

// The slot is cached, so it is safe to use the Internal function.

return createPseudoHandle(

JSObject::getNamedSlotValueUnsafe<PropStorage::Inline::Yes>(

*obj, this, cacheEntry->slot)

.unboxToHV(this));

}

auto sym = Predefined::getSymbolID(fixedPropCacheNames[static_cast<int>(id)]);

NamedPropertyDescriptor desc;

// Check writable and internalSetter flags since the cache slot is shared for

// get/put.

if (LLVM_LIKELY(

JSObject::tryGetOwnNamedDescriptorFast(*obj, this, sym, desc)) &&

!desc.flags.accessor && desc.flags.writable &&

!desc.flags.internalSetter) {

HiddenClass *clazz = vmcast<HiddenClass>(clazzPtr.getNonNull(this));

if (LLVM_LIKELY(!clazz->isDictionary())) {

// Cache the class, id and property slot.

cacheEntry->clazz = clazzPtr;

cacheEntry->slot = desc.slot;

}

return JSObject::getNamedSlotValue(createPseudoHandle(*obj), this, desc);

}

return JSObject::getNamed_RJS(obj, this, sym);

Handle<JSObject> obj,

PropCacheID id,

SmallHermesValue shv) {

CompressedPointer clazzPtr{obj->getClassGCPtr()};

auto *cacheEntry = &fixedPropCache_[static_cast<int>(id)];

if (LLVM_LIKELY(cacheEntry->clazz == clazzPtr)) {

JSObject::setNamedSlotValueUnsafe<PropStorage::Inline::Yes>(

*obj, this, cacheEntry->slot, shv);

return ExecutionStatus::RETURNED;

}

auto sym = Predefined::getSymbolID(fixedPropCacheNames[static_cast<int>(id)]);

NamedPropertyDescriptor desc;

if (LLVM_LIKELY(

JSObject::tryGetOwnNamedDescriptorFast(*obj, this, sym, desc)) &&

!desc.flags.accessor && desc.flags.writable &&

!desc.flags.internalSetter) {

HiddenClass *clazz = vmcast<HiddenClass>(clazzPtr.getNonNull(this));

if (LLVM_LIKELY(!clazz->isDictionary())) {

// Cache the class and property slot.

cacheEntry->clazz = clazzPtr;

cacheEntry->slot = desc.slot;

}

JSObject::setNamedSlotValueUnsafe(*obj, this, desc.slot, shv);

return ExecutionStatus::RETURNED;

}

Handle<> value = makeHandle(shv.unboxToHV(this));

return JSObject::putNamed_RJS(

obj, this, sym, value, PropOpFlags().plusThrowOnError())

.getStatus();

std::shared_ptr<StorageProvider> provider,

const RuntimeConfig &runtimeConfig)

// The initial heap size can't be larger than the max.

: enableEval(runtimeConfig.getEnableEval()),

verifyEvalIR(runtimeConfig.getVerifyEvalIR()),

optimizedEval(runtimeConfig.getOptimizedEval()),

asyncBreakCheckInEval(runtimeConfig.getAsyncBreakCheckInEval()),

heapStorage_(

this,

this,

runtimeConfig.getGCConfig(),

runtimeConfig.getCrashMgr(),

std::move(provider),

runtimeConfig.getVMExperimentFlags()),

hasES6Promise_(runtimeConfig.getES6Promise()),

hasES6Proxy_(runtimeConfig.getES6Proxy()),

hasIntl_(runtimeConfig.getIntl()),

shouldRandomizeMemoryLayout_(runtimeConfig.getRandomizeMemoryLayout()),

bytecodeWarmupPercent_(runtimeConfig.getBytecodeWarmupPercent()),

trackIO_(runtimeConfig.getTrackIO()),

vmExperimentFlags_(runtimeConfig.getVMExperimentFlags()),

runtimeStats_(runtimeConfig.getEnableSampledStats()),

commonStorage_(

createRuntimeCommonStorage(runtimeConfig.getTraceEnabled())),

stackPointer_(),

crashMgr_(runtimeConfig.getCrashMgr()),

crashCallbackKey_(

crashMgr_->registerCallback([this](int fd) { crashCallback(fd); })),

codeCoverageProfiler_(std::make_unique<CodeCoverageProfiler>(this)),

gcEventCallback_(runtimeConfig.getGCConfig().getCallback()) {

assert(

(void *)this == (void *)(HandleRootOwner *)this &&

"cast to HandleRootOwner should be no-op");

#ifdef HERMES_FACEBOOK_BUILD

const bool isSnapshot = std::strstr(__FILE__, "hermes-snapshot");

crashMgr_->setCustomData("HermesIsSnapshot", isSnapshot ? "true" : "false");

#endif

auto maxNumRegisters = runtimeConfig.getMaxNumRegisters();

if (LLVM_UNLIKELY(maxNumRegisters > kMaxSupportedNumRegisters)) {

hermes_fatal("RuntimeConfig maxNumRegisters too big");

}

registerStackStart_ = runtimeConfig.getRegisterStack();

if (!registerStackStart_) {

// registerStackAllocation_ should not be allocated with new, because then

// default constructors would run for the whole stack space.

// Round up to page size as required by vm_allocate.

const uint32_t numBytesForRegisters = llvh::alignTo(

sizeof(PinnedHermesValue) * maxNumRegisters, oscompat::page_size());

auto result = oscompat::vm_allocate(numBytesForRegisters);

if (!result) {

hermes_fatal("Failed to allocate register stack", result.getError());

}

registerStackStart_ = static_cast<PinnedHermesValue *>(result.get());

registerStackAllocation_ = {registerStackStart_, numBytesForRegisters};

crashMgr_->registerMemory(registerStackStart_, numBytesForRegisters);

}

registerStackEnd_ = registerStackStart_ + maxNumRegisters;

if (shouldRandomizeMemoryLayout_) {

const unsigned bytesOff = std::random_device()() % oscompat::page_size();

registerStackEnd_ -= bytesOff / sizeof(PinnedHermesValue);

assert(

registerStackEnd_ >= registerStackStart_ && "register stack too small");

}

stackPointer_ = registerStackEnd_;

// Setup the "root" stack frame.

setCurrentFrameToTopOfStack();

// Allocate the "reserved" registers in the root frame.

allocStack(

StackFrameLayout::CalleeExtraRegistersAtStart,

HermesValue::encodeUndefinedValue());

#ifdef HERMESVM_SERIALIZE

if (runtimeConfig.getDeserializeFile()) {

assert(

runtimeConfig.getExternalPointersVectorCallBack() &&

"missing function pointer to map external pointers.");

// If there is a serialized heap file available, use that to initialize

// Runtime instead of re-creating the Runtime.

Deserializer d(

runtimeConfig.getDeserializeFile(),

this,

runtimeConfig.getExternalPointersVectorCallBack());

deserializeImpl(d, runtimeConfig.getGCConfig().getAllocInYoung());

LLVM_DEBUG(llvh::dbgs() << "Runtime initialized\n");

if (runtimeConfig.getEnableSampleProfiling())

samplingProfiler = std::make_unique<SamplingProfiler>(this);

return;

}

#endif // HERMESVM_SERIALIZE

// Initialize Predefined Strings.

// This function does not do any allocations.

initPredefinedStrings();

// Initialize special code blocks pointing to their own runtime module.

// specialCodeBlockRuntimeModule_ will be owned by runtimeModuleList_.

RuntimeModuleFlags flags;

flags.hidesEpilogue = true;

specialCodeBlockDomain_ = Domain::create(this).getHermesValue();

specialCodeBlockRuntimeModule_ = RuntimeModule::createUninitialized(

this, Handle<Domain>::vmcast(&specialCodeBlockDomain_), flags);

assert(

&runtimeModuleList_.back() == specialCodeBlockRuntimeModule_ &&

"specialCodeBlockRuntimeModule_ not added to runtimeModuleList_");

// At this point, allocations can begin, as all the roots are markable.

// Initialize the pre-allocated character strings.

initCharacterStrings();

GCScope scope(this);

// Explicitly initialize the specialCodeBlockRuntimeModule_ without CJS

// modules.

specialCodeBlockRuntimeModule_->initializeWithoutCJSModulesMayAllocate(

hbc::BCProviderFromBuffer::createBCProviderFromBuffer(

generateSpecialRuntimeBytecode())

.first);

emptyCodeBlock_ = specialCodeBlockRuntimeModule_->getCodeBlockMayAllocate(0);

returnThisCodeBlock_ =

specialCodeBlockRuntimeModule_->getCodeBlockMayAllocate(1);

// Initialize the root hidden class and its variants.

{

MutableHandle<HiddenClass> clazz(

this,

vmcast<HiddenClass>(

ignoreAllocationFailure(HiddenClass::createRoot(this))));

rootClazzes_[0] = clazz.getHermesValue();

for (unsigned i = 1; i <= InternalProperty::NumInternalProperties; ++i) {

auto addResult = HiddenClass::reserveSlot(clazz, this);

assert(

addResult != ExecutionStatus::EXCEPTION &&

"Could not possibly grow larger than the limit");

clazz = *addResult->first;

rootClazzes_[i] = clazz.getHermesValue();

}

}

global_ =

JSObject::create(this, Handle<JSObject>(this, nullptr)).getHermesValue();

JSLibFlags jsLibFlags{};

jsLibFlags.enableHermesInternal = runtimeConfig.getEnableHermesInternal();

jsLibFlags.enableHermesInternalTestMethods =

runtimeConfig.getEnableHermesInternalTestMethods();

initGlobalObject(this, jsLibFlags);

// Once the global object has been initialized, populate native builtins to

// the builtins table.

initNativeBuiltins();

// Set the prototype of the global object to the standard object prototype,

// which has now been defined.

ignoreAllocationFailure(JSObject::setParent(

vmcast<JSObject>(global_),

this,

vmcast<JSObject>(objectPrototype),

PropOpFlags().plusThrowOnError()));

symbolRegistry_.init(this);

#ifdef HERMESVM_SERIALIZE

if (runtimeConfig.getSerializeAfterInitFile()) {

assert(

runtimeConfig.getExternalPointersVectorCallBack() &&

"missing function pointer to map external pointers.");

Serializer s(

*runtimeConfig.getSerializeAfterInitFile(),

this,

runtimeConfig.getExternalPointersVectorCallBack());

serialize(s);

}

#endif // HERMESVM_SERIALIZE

// BB Profiler need to be ready before running internal bytecode.

#ifdef HERMESVM_PROFILER_BB

inlineCacheProfiler_.setHiddenClassArray(

ignoreAllocationFailure(JSArray::create(this, 4, 4)).get());

#endif

codeCoverageProfiler_->disable();

// Execute our internal bytecode.

auto jsBuiltinsObj = runInternalBytecode();

codeCoverageProfiler_->restore();

// Populate JS builtins returned from internal bytecode to the builtins table.

initJSBuiltins(builtins_, jsBuiltinsObj);

if (runtimeConfig.getEnableSampleProfiling())

samplingProfiler = std::make_unique<SamplingProfiler>(this);

LLVM_DEBUG(llvh::dbgs() << "Runtime initialized\n");

: rt_(rt), section_(section), start_(std::chrono::steady_clock::now()) {

if (static_cast<unsigned>(section) == 0) {

// The first phase; record the start as the start of markRoots.

rt_->startOfMarkRoots_ = start_;

}

RootAndSlotAcceptorWithNames &acceptor,

bool markLongLived) {

// The body of markRoots should be sequence of blocks, each of which starts

// with the declaration of an appropriate RootSection instance.

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::Registers);

acceptor.beginRootSection(RootAcceptor::Section::Registers);

for (auto *p = stackPointer_, *e = registerStackEnd_; p != e; ++p)

acceptor.accept(*p);

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::RuntimeInstanceVars);

acceptor.beginRootSection(RootAcceptor::Section::RuntimeInstanceVars);

for (auto &clazz : rootClazzes_)

acceptor.accept(clazz, "rootClass");

#define RUNTIME_HV_FIELD_INSTANCE(name) acceptor.accept((name), #name);

#include "hermes/VM/RuntimeHermesValueFields.def"

#undef RUNTIME_HV_FIELD_INSTANCE

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::RuntimeModules);

acceptor.beginRootSection(RootAcceptor::Section::RuntimeModules);

#define RUNTIME_HV_FIELD_RUNTIMEMODULE(name) acceptor.accept(name);

#include "hermes/VM/RuntimeHermesValueFields.def"

#undef RUNTIME_HV_FIELD_RUNTIMEMODULE

for (auto &rm : runtimeModuleList_)

rm.markRoots(acceptor, markLongLived);

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::CharStrings);

acceptor.beginRootSection(RootAcceptor::Section::CharStrings);

if (markLongLived) {

for (auto &hv : charStrings_)

acceptor.accept(hv);

}

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(

this, RootAcceptor::Section::StringCycleCheckVisited);

acceptor.beginRootSection(RootAcceptor::Section::StringCycleCheckVisited);

for (auto *&ptr : stringCycleCheckVisited_)

acceptor.acceptPtr(ptr);

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::Builtins);

acceptor.beginRootSection(RootAcceptor::Section::Builtins);

for (Callable *&f : builtins_)

acceptor.acceptPtr(f);

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::Jobs);

acceptor.beginRootSection(RootAcceptor::Section::Jobs);

for (Callable *&f : jobQueue_)

acceptor.acceptPtr(f);

acceptor.endRootSection();

}

#ifdef MARK

#error "Shouldn't have defined mark already"

#endif

#define MARK(field) acceptor.accept((field), #field)

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::Prototypes);

acceptor.beginRootSection(RootAcceptor::Section::Prototypes);

// Prototypes.

#define RUNTIME_HV_FIELD_PROTOTYPE(name) MARK(name);

#include "hermes/VM/RuntimeHermesValueFields.def"

#undef RUNTIME_HV_FIELD_PROTOTYPE

acceptor.acceptPtr(objectPrototypeRawPtr, "objectPrototype");

acceptor.acceptPtr(functionPrototypeRawPtr, "functionPrototype");

#undef MARK

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::IdentifierTable);

if (markLongLived) {

// Need to add nodes before the root section, and edges during the root

// section.

acceptor.provideSnapshot([this](HeapSnapshot &snap) {

identifierTable_.snapshotAddNodes(snap);

});

acceptor.beginRootSection(RootAcceptor::Section::IdentifierTable);

identifierTable_.markIdentifiers(acceptor, &getHeap());

acceptor.provideSnapshot([this](HeapSnapshot &snap) {

identifierTable_.snapshotAddEdges(snap);

});

acceptor.endRootSection();

}

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::GCScopes);

acceptor.beginRootSection(RootAcceptor::Section::GCScopes);

markGCScopes(acceptor);

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::SymbolRegistry);

acceptor.beginRootSection(RootAcceptor::Section::SymbolRegistry);

symbolRegistry_.markRoots(acceptor);

acceptor.endRootSection();

}

// Mark the alternative roots during the normal mark roots call.

markRootsForCompleteMarking(acceptor);

{

MarkRootsPhaseTimer timer(

this, RootAcceptor::Section::CodeCoverageProfiler);

acceptor.beginRootSection(RootAcceptor::Section::CodeCoverageProfiler);

if (codeCoverageProfiler_) {

codeCoverageProfiler_->markRoots(acceptor);

}

#ifdef HERMESVM_PROFILER_BB

auto *&hiddenClassArray = inlineCacheProfiler_.getHiddenClassArray();

if (hiddenClassArray) {

acceptor.acceptPtr(hiddenClassArray);

}

#endif

acceptor.endRootSection();

}

{

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::Custom);

// Define nodes before the root section starts.

for (auto &fn : customSnapshotNodeFuncs_) {

acceptor.provideSnapshot(fn);

}

acceptor.beginRootSection(RootAcceptor::Section::Custom);

for (auto &fn : customMarkRootFuncs_)

fn(&getHeap(), acceptor);

// Define edges while inside the root section.

for (auto &fn : customSnapshotEdgeFuncs_) {

acceptor.provideSnapshot(fn);

}

acceptor.endRootSection();

}

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::WeakRefs);

acceptor.beginRootSection(RootAcceptor::Section::WeakRefs);

if (markLongLived) {

for (auto &entry : fixedPropCache_) {

acceptor.acceptWeak(entry.clazz);

}

for (auto &rm : runtimeModuleList_)

rm.markWeakRoots(acceptor);

}

for (auto &fn : customMarkWeakRootFuncs_)

fn(&getHeap(), acceptor);

acceptor.endRootSection();

RootAndSlotAcceptorWithNames &acceptor) {

MarkRootsPhaseTimer timer(this, RootAcceptor::Section::SamplingProfiler);

acceptor.beginRootSection(RootAcceptor::Section::SamplingProfiler);

if (samplingProfiler) {

samplingProfiler->markRoots(acceptor);

}

acceptor.endRootSection();

const unsigned kNumPhases =

static_cast<unsigned>(RootAcceptor::Section::NumSections);

#define ROOT_SECTION(phase) "MarkRoots_" #phase,

static const char *markRootsPhaseNames[kNumPhases] = {

#include "hermes/VM/RootSections.def"

};

#undef ROOT_SECTION

json.emitKey("runtime");

json.openDict();

json.emitKeyValue("totalMarkRootsTime", formatSecs(totalMarkRootsTime_).secs);

for (unsigned phaseNum = 0; phaseNum < kNumPhases; phaseNum++) {

json.emitKeyValue(

std::string(markRootsPhaseNames[phaseNum]) + "Time",

formatSecs(markRootsPhaseTimes_[phaseNum]).secs);

}

json.closeDict();

// Printing the timings is unstable.

if (shouldStabilizeInstructionCount())

return;

getHeap().printAllCollectedStats(os);

#ifndef NDEBUG

printArrayCensus(llvh::outs());

#endif

if (trackIO_) {

getIOTrackingInfoJSON(os);

}

JSONEmitter json(os);

json.openArray();

for (auto &module : getRuntimeModules()) {

auto tracker = module.getBytecode()->getPageAccessTracker();

if (tracker) {

json.openDict();

json.emitKeyValue("url", module.getSourceURL());

json.emitKey("tracking_info");

tracker->getJSONStats(json);

json.closeDict();

}

}

json.closeArray();

#ifdef HERMES_ENABLE_DEBUGGER

debugger_.willUnloadModule(rm);

#endif

runtimeModuleList_.remove(*rm);

// Do array capacity histogram.

// Map from array size to number of arrays that are that size.

// Arrays includes ArrayStorage and SegmentedArray.

std::map<std::pair<size_t, size_t>, std::pair<size_t, size_t>>

arraySizeToCountAndWastedSlots;

auto printTable = [&os](const std::map<

std::pair<size_t, size_t>,

std::pair<size_t, size_t>>

&arraySizeToCountAndWastedSlots) {

os << llvh::format(

"%8s %8s %8s %10s %15s %15s %15s %20s %25s\n",

(const char *)"Capacity",

(const char *)"Sizeof",

(const char *)"Count",

(const char *)"Count %",

(const char *)"Cum Count %",

(const char *)"Bytes %",

(const char *)"Cum Bytes %",

(const char *)"Wasted Slots %",

(const char *)"Cum Wasted Slots %");

size_t totalBytes = 0;

size_t totalCount = 0;

size_t totalWastedSlots = 0;

for (const auto &p : arraySizeToCountAndWastedSlots) {

totalBytes += p.first.second * p.second.first;

totalCount += p.second.first;

totalWastedSlots += p.second.second;

}

size_t cumulativeBytes = 0;

size_t cumulativeCount = 0;

size_t cumulativeWastedSlots = 0;

for (const auto &p : arraySizeToCountAndWastedSlots) {

cumulativeBytes += p.first.second * p.second.first;

cumulativeCount += p.second.first;

cumulativeWastedSlots += p.second.second;

os << llvh::format(

"%8d %8d %8d %9.2f%% %14.2f%% %14.2f%% %14.2f%% %19.2f%% %24.2f%%\n",

p.first.first,

p.first.second,

p.second.first,

p.second.first * 100.0 / totalCount,

cumulativeCount * 100.0 / totalCount,

p.first.second * p.second.first * 100.0 / totalBytes,

cumulativeBytes * 100.0 / totalBytes,

totalWastedSlots ? p.second.second * 100.0 / totalWastedSlots : 100.0,

totalWastedSlots ? cumulativeWastedSlots * 100.0 / totalWastedSlots

: 100.0);

}

os << "\n";

};

os << "Array Census for ArrayStorage:\n";

getHeap().forAllObjs([&arraySizeToCountAndWastedSlots](GCCell *cell) {

if (cell->getKind() == CellKind::ArrayStorageKind) {

ArrayStorage *arr = vmcast<ArrayStorage>(cell);

const auto key = std::make_pair(arr->capacity(), arr->getAllocatedSize());

arraySizeToCountAndWastedSlots[key].first++;

arraySizeToCountAndWastedSlots[key].second +=

arr->capacity() - arr->size();

}

});

if (arraySizeToCountAndWastedSlots.empty()) {

os << "\tNo ArrayStorages\n\n";

} else {

printTable(arraySizeToCountAndWastedSlots);

}

os << "Array Census for SegmentedArray:\n";

arraySizeToCountAndWastedSlots.clear();

getHeap().forAllObjs([&arraySizeToCountAndWastedSlots](GCCell *cell) {

if (cell->getKind() == CellKind::SegmentedArrayKind) {

SegmentedArray *arr = vmcast<SegmentedArray>(cell);

const auto key =

std::make_pair(arr->totalCapacityOfSpine(), arr->getAllocatedSize());

arraySizeToCountAndWastedSlots[key].first++;

arraySizeToCountAndWastedSlots[key].second +=

arr->totalCapacityOfSpine() - arr->size();

}

});

if (arraySizeToCountAndWastedSlots.empty()) {

os << "\tNo SegmentedArrays\n\n";

} else {

printTable(arraySizeToCountAndWastedSlots);

}

os << "Array Census for Segment:\n";

arraySizeToCountAndWastedSlots.clear();

getHeap().forAllObjs([&arraySizeToCountAndWastedSlots](GCCell *cell) {

if (cell->getKind() == CellKind::SegmentKind) {

SegmentedArray::Segment *seg = vmcast<SegmentedArray::Segment>(cell);

const auto key = std::make_pair(seg->length(), seg->getAllocatedSize());

arraySizeToCountAndWastedSlots[key].first++;

arraySizeToCountAndWastedSlots[key].second +=

SegmentedArray::Segment::kMaxLength - seg->length();

}

});

if (arraySizeToCountAndWastedSlots.empty()) {

os << "\tNo Segments\n\n";

} else {

printTable(arraySizeToCountAndWastedSlots);

}

os << "Array Census for JSArray:\n";

arraySizeToCountAndWastedSlots.clear();

getHeap().forAllObjs([&arraySizeToCountAndWastedSlots, this](GCCell *cell) {

if (cell->getKind() == CellKind::ArrayKind) {

JSArray *arr = vmcast<JSArray>(cell);

JSArray::StorageType *storage = arr->getIndexedStorage(this);

const auto capacity = storage ? storage->totalCapacityOfSpine() : 0;

const auto sz = storage ? storage->size() : 0;

const auto key = std::make_pair(capacity, arr->getAllocatedSize());

arraySizeToCountAndWastedSlots[key].first++;

arraySizeToCountAndWastedSlots[key].second += capacity - sz;

}

});

if (arraySizeToCountAndWastedSlots.empty()) {

os << "\tNo JSArrays\n\n";

} else {

printTable(arraySizeToCountAndWastedSlots);

}

os << "\n";

// Register stack uses mmap and RuntimeModules are tracked by their owning

// Domains. So this only considers IdentifierTable size.

return sizeof(IdentifierTable) + identifierTable_.additionalMemorySize();

// Do a dummy allocation which could force a heap move if handle sanitization

// is on.

FillerCell::create(

this,

std::max<size_t>(

heapAlignSize(sizeof(FillerCell)), GC::minAllocationSize()));

llvh::StringRef code,

llvh::StringRef sourceURL,

const hbc::CompileFlags &compileFlags) {

#ifdef HERMESVM_LEAN

return raiseEvalUnsupported(code);

#else

std::unique_ptr<hermes::Buffer> buffer;

if (compileFlags.lazy) {

buffer.reset(new hermes::OwnedMemoryBuffer(

llvh::MemoryBuffer::getMemBufferCopy(code)));

} else {

buffer.reset(

new hermes::OwnedMemoryBuffer(llvh::MemoryBuffer::getMemBuffer(code)));

}

return run(std::move(buffer), sourceURL, compileFlags);

#endif

std::unique_ptr<hermes::Buffer> code,

llvh::StringRef sourceURL,

const hbc::CompileFlags &compileFlags) {

#ifdef HERMESVM_LEAN

auto buffer = code.get();

return raiseEvalUnsupported(llvh::StringRef(

reinterpret_cast<const char *>(buffer->data()), buffer->size()));

#else

std::unique_ptr<hbc::BCProviderFromSrc> bytecode;

{

PerfSection loading("Loading new JavaScript code");

loading.addArg("url", sourceURL);

auto bytecode_err = hbc::BCProviderFromSrc::createBCProviderFromSrc(

std::move(code), sourceURL, compileFlags);

if (!bytecode_err.first) {

return raiseSyntaxError(TwineChar16(bytecode_err.second));

}

bytecode = std::move(bytecode_err.first);

}

PerfSection loading("Executing global function");

RuntimeModuleFlags rmflags;

rmflags.persistent = true;

return runBytecode(

std::move(bytecode), rmflags, sourceURL, makeNullHandle<Environment>());

#endif

std::shared_ptr<hbc::BCProvider> &&bytecode,

RuntimeModuleFlags flags,

llvh::StringRef sourceURL,

Handle<Environment> environment,

Handle<> thisArg) {

clearThrownValue();

#ifdef HERMESVM_SERIALIZE

// If we are constructed from serialize data with a ClosureFunction, execute

// the function.

if (!serializeClosure.isUndefined()) {

ScopedNativeCallFrame newFrame{

this,

0,

serializeClosure,

HermesValue::encodeUndefinedValue(),

*thisArg};

if (LLVM_UNLIKELY(newFrame.overflowed()))

return raiseStackOverflow(StackOverflowKind::NativeStack);

return shouldRandomizeMemoryLayout_

? interpretFunctionWithRandomStack(

this, vmcast<JSFunction>(serializeClosure)->getCodeBlock())

: interpretFunction(

vmcast<JSFunction>(serializeClosure)->getCodeBlock());

}

#endif

auto globalFunctionIndex = bytecode->getGlobalFunctionIndex();

if (bytecode->getBytecodeOptions().staticBuiltins && !builtinsFrozen_) {

if (assertBuiltinsUnmodified() == ExecutionStatus::EXCEPTION) {

return ExecutionStatus::EXCEPTION;

}

freezeBuiltins();

assert(builtinsFrozen_ && "Builtins must be frozen by now.");

}

if (bytecode->getBytecodeOptions().hasAsync && !hasES6Promise_) {

return raiseTypeError(

"Cannot execute a bytecode having async functions when Promise is disabled.");

}

if (flags.persistent) {

persistentBCProviders_.push_back(bytecode);

if (bytecodeWarmupPercent_ > 0) {

// Start the warmup thread for this bytecode if it's a buffer.

bytecode->startWarmup(bytecodeWarmupPercent_);

}

if (getVMExperimentFlags() & experiments::MAdviseRandom) {

bytecode->madvise(oscompat::MAdvice::Random);

} else if (getVMExperimentFlags() & experiments::MAdviseSequential) {

bytecode->madvise(oscompat::MAdvice::Sequential);

}

if (getVMExperimentFlags() & experiments::VerifyBytecodeChecksum) {

llvh::ArrayRef<uint8_t> buf = bytecode->getRawBuffer();

// buf is empty for non-buffer providers

if (!buf.empty()) {

if (!hbc::BCProviderFromBuffer::bytecodeHashIsValid(buf)) {

const char *msg = "Bytecode checksum verification failed";

hermesLog("Hermes", "%s", msg);

hermes_fatal(msg);

}

}

}

}

// Only track I/O for buffers > 64 kB (which excludes things like

// Runtime::generateSpecialRuntimeBytecode).

if (flags.persistent && trackIO_ &&

bytecode->getRawBuffer().size() > MIN_IO_TRACKING_SIZE) {

bytecode->startPageAccessTracker();

if (!bytecode->getPageAccessTracker()) {

hermesLog(

"Hermes",

"Failed to start bytecode I/O instrumentation, "

"maybe not supported on this platform.");

}

}

GCScope scope(this);

Handle<Domain> domain = makeHandle(Domain::create(this));

auto runtimeModuleRes = RuntimeModule::create(

this, domain, nextScriptId_++, std::move(bytecode), flags, sourceURL);

if (LLVM_UNLIKELY(runtimeModuleRes == ExecutionStatus::EXCEPTION)) {

return ExecutionStatus::EXCEPTION;

}

auto runtimeModule = *runtimeModuleRes;

auto globalCode = runtimeModule->getCodeBlockMayAllocate(globalFunctionIndex);

#ifdef HERMES_ENABLE_DEBUGGER

// If the debugger is configured to pause on load, give it a chance to pause.

getDebugger().willExecuteModule(runtimeModule, globalCode);

#endif

if (runtimeModule->hasCJSModules()) {

auto requireContext = RequireContext::create(

this, domain, getPredefinedStringHandle(Predefined::dotSlash));

return runRequireCall(

this,

requireContext,

domain,

*domain->getCJSModuleOffset(this, domain->getCJSEntryModuleID()));

} else if (runtimeModule->hasCJSModulesStatic()) {

return runRequireCall(

this,

makeNullHandle<RequireContext>(),

domain,

*domain->getCJSModuleOffset(this, domain->getCJSEntryModuleID()));

} else {

// Create a JSFunction which will reference count the runtime module.

// Note that its handle gets registered in the scope, so we don't need to

// save it. Also note that environment will often be null here, except if