mirrors/escargot
2
0
Fork 0
mirror of https://github.com/Samsung/escargot.git synced 2026-06-22 10:01:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
escargot/src/runtime/VMInstance.cpp
HyukWoo Park 023b7ea014 Implement general tail call optimization 
Signed-off-by: HyukWoo Park <hyukwoo.park@samsung.com>
2024-02-20 17:16:10 +09:00

997 lines
41 KiB
C++
Raw Blame History

/*
* Copyright (c) 2016-present Samsung Electronics Co., Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
* USA
*/
#include "Escargot.h"
#include "VMInstance.h"
#include "runtime/Global.h"
#include "runtime/ThreadLocal.h"
#include "runtime/Platform.h"
#include "runtime/ArrayObject.h"
#include "runtime/ArrayBufferObject.h"
#include "runtime/StringObject.h"
#include "runtime/DateObject.h"
#include "runtime/JobQueue.h"
#include "runtime/CompressibleString.h"
#include "runtime/ReloadableString.h"
#include "intl/Intl.h"
#include "interpreter/ByteCode.h"
#if defined(ENABLE_TCO)
#include "interpreter/ByteCodeInterpreter.h"
#endif
#if defined(ENABLE_CODE_CACHE)
#include "codecache/CodeCache.h"
#endif
#include <time.h> // for tzname
#if defined(OS_WINDOWS)
#include <Windows.h>
#endif
namespace Escargot {
Value VMInstance::functionPrototypeNativeGetter(ExecutionState& state, Object* self, const Value& receiver, const EncodedValue& privateDataFromObjectPrivateArea)
{
ASSERT(self->isFunctionObject());
if (privateDataFromObjectPrivateArea.isEmpty()) {
return self->asFunctionObject()->getFunctionPrototype(state);
} else {
return privateDataFromObjectPrivateArea;
}
}
bool VMInstance::functionPrototypeNativeSetter(ExecutionState& state, Object* self, const Value& receiver, EncodedValue& privateDataFromObjectPrivateArea, const Value& setterInputData)
{
ASSERT(self->isFunctionObject());
privateDataFromObjectPrivateArea = setterInputData;
return true;
}
static ObjectPropertyNativeGetterSetterData functionPrototypeNativeGetterSetterData(
true, false, false, &VMInstance::functionPrototypeNativeGetter, &VMInstance::functionPrototypeNativeSetter);
static ObjectPropertyNativeGetterSetterData builtinFunctionPrototypeNativeGetterSetterData(
false, false, false, &VMInstance::functionPrototypeNativeGetter, &VMInstance::functionPrototypeNativeSetter);
Value VMInstance::stringLengthNativeGetter(ExecutionState& state, Object* self, const Value& receiver, const EncodedValue& privateDataFromObjectPrivateArea)
{
ASSERT(self->isStringObject());
return Value(self->asStringObject()->primitiveValue()->length());
}
bool VMInstance::stringLengthNativeSetter(ExecutionState& state, Object* self, const Value& receiver, EncodedValue& privateDataFromObjectPrivateArea, const Value& setterInputData)
{
return false;
}
static ObjectPropertyNativeGetterSetterData stringLengthGetterSetterData(
false, false, false, &VMInstance::stringLengthNativeGetter, &VMInstance::stringLengthNativeSetter);
Value VMInstance::regexpLastIndexNativeGetter(ExecutionState& state, Object* self, const Value& receiver, const EncodedValue& privateDataFromObjectPrivateArea)
{
if (!self->isRegExpObject()) {
ErrorObject::throwBuiltinError(state, ErrorCode::TypeError, "getter called on non-RegExp object");
}
return self->asRegExpObject()->lastIndex();
}
bool VMInstance::regexpLastIndexNativeSetter(ExecutionState& state, Object* self, const Value& receiver, EncodedValue& privateDataFromObjectPrivateArea, const Value& setterInputData)
{
ASSERT(self->isRegExpObject());
self->asRegExpObject()->setLastIndex(state, setterInputData);
return true;
}
static ObjectPropertyNativeGetterSetterData regexpLastIndexGetterSetterData(
true, false, false, &VMInstance::regexpLastIndexNativeGetter, &VMInstance::regexpLastIndexNativeSetter);
#if defined(ENABLE_COMPRESSIBLE_STRING)
#ifndef ESCARGOT_COMPRESSIBLE_COMPRESS_GC_CHECK_INTERVAL
#define ESCARGOT_COMPRESSIBLE_COMPRESS_GC_CHECK_INTERVAL 1000
#endif
#ifndef ESCARGOT_COMPRESSIBLE_COMPRESS_USED_BEFORE_INTERVAL
#define ESCARGOT_COMPRESSIBLE_COMPRESS_USED_BEFORE_INTERVAL 1000
#endif
#ifndef ESCARGOT_COMPRESSIBLE_COMPRESS_MIN_SIZE
#define ESCARGOT_COMPRESSIBLE_COMPRESS_MIN_SIZE 1024 * 128
#endif
void VMInstance::compressStringsIfNeeds(uint64_t currentTickCount)
{
auto& currentAllocatedCompressibleStrings = compressibleStrings();
const size_t& currentAllocatedCompressibleStringsCount = currentAllocatedCompressibleStrings.size();
size_t mostBigIndex = SIZE_MAX;
for (size_t i = 0; i < currentAllocatedCompressibleStringsCount; i++) {
if (!currentAllocatedCompressibleStrings[i]->isCompressed()
&& currentTickCount - currentAllocatedCompressibleStrings[i]->m_lastUsedTickcount > ESCARGOT_COMPRESSIBLE_COMPRESS_USED_BEFORE_INTERVAL
&& currentAllocatedCompressibleStrings[i]->decomressedBufferSize() > ESCARGOT_COMPRESSIBLE_COMPRESS_MIN_SIZE) {
if (mostBigIndex == SIZE_MAX) {
mostBigIndex = i;
} else if (currentAllocatedCompressibleStrings[i]->decomressedBufferSize() > currentAllocatedCompressibleStrings[mostBigIndex]->decomressedBufferSize()) {
mostBigIndex = i;
}
}
}
if (mostBigIndex != SIZE_MAX) {
currentAllocatedCompressibleStrings[mostBigIndex]->compress();
}
}
#endif
static void markHashSet(GC_word* desc, size_t base)
{
#if defined(COMPILER_MSVC) || defined(COMPILER_CLANG_CL)
GC_set_bit(desc, base + 2); // m_ht.m_buckets_data
GC_set_bit(desc, base + 5); // m_ht.m_buckets
#else
GC_set_bit(desc, base + 1); // m_ht.m_buckets_data
GC_set_bit(desc, base + 4); // m_ht.m_buckets
#endif
}
void* VMInstance::operator new(size_t size)
{
static MAY_THREAD_LOCAL bool typeInited = false;
static MAY_THREAD_LOCAL GC_descr descr;
if (!typeInited) {
GC_word desc[GC_BITMAP_SIZE(VMInstance)] = { 0 };
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_staticStrings.dtoaCache));
markHashSet(desc, GC_WORD_OFFSET(VMInstance, m_atomicStringMap));
#define DECLARE_GLOBAL_SYMBOLS(name) GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_globalSymbols.name));
DEFINE_GLOBAL_SYMBOLS(DECLARE_GLOBAL_SYMBOLS);
#undef DECLARE_GLOBAL_SYMBOLS
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_globalSymbolRegistry));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_currentSandBox));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForFunctionObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForNotConstructorFunctionObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForBuiltinFunctionObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForFunctionPrototypeObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForBoundFunctionObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForClassConstructorFunctionObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForClassConstructorFunctionObjectWithName));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForStringObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForRegExpObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForMappedArgumentsObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultStructureForUnmappedArgumentsObject));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_defaultPrivateMemberStructure));
markHashSet(desc, GC_WORD_OFFSET(VMInstance, m_rootedObjectStructure));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_onVMInstanceDestroyData));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_toStringRecursionPreventer.m_registeredItems));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_regexpCache));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_regexpOptionStringCache));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_cachedUTC));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_jobQueue));
#if defined(ENABLE_INTL)
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_intlAvailableLocales));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_intlCollatorAvailableLocales));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_intlPluralRulesAvailableLocales));
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_caseMappingAvailableLocales));
#endif
#if defined(ENABLE_THREADING)
GC_set_bit(desc, GC_WORD_OFFSET(VMInstance, m_asyncWaiterData));
#endif
descr = GC_make_descriptor(desc, GC_WORD_LEN(VMInstance));
typeInited = true;
}
return GC_MALLOC_EXPLICITLY_TYPED(size, descr);
}
void vmMarkStartCallback(void* data)
{
#if !defined(ESCARGOT_DEBUGGER)
// in debugger mode, do not remove ByteCodeBlock
VMInstance* self = (VMInstance*)data;
if (self->m_regexpCache->size() > REGEXP_CACHE_SIZE_MAX || UNLIKELY(self->inIdleMode())) {
self->m_regexpCache->clear();
}
auto& currentCodeSizeTotal = self->compiledByteCodeSize();
if (currentCodeSizeTotal > self->maxCompiledByteCodeSize() || UNLIKELY(self->inIdleMode())) {
currentCodeSizeTotal = std::numeric_limits<size_t>::max();
auto& v = self->compiledByteCodeBlocks();
for (size_t i = 0; i < v.size(); i++) {
auto cb = v[i]->m_codeBlock;
if (LIKELY(!cb->isAsync() && !cb->isGenerator())) {
v[i]->m_codeBlock->setByteCodeBlock(nullptr);
}
}
}
#endif
}
void vmReclaimEndCallback(void* data)
{
VMInstance* self = (VMInstance*)data;
#if defined(ENABLE_COMPRESSIBLE_STRING) || defined(ENABLE_WASM)
auto currentTick = fastTickCount();
#if defined(ENABLE_COMPRESSIBLE_STRING)
if (currentTick - self->m_lastCompressibleStringsTestTime > ESCARGOT_COMPRESSIBLE_COMPRESS_GC_CHECK_INTERVAL) {
self->compressStringsIfNeeds(currentTick);
self->m_lastCompressibleStringsTestTime = currentTick;
}
#endif
#endif
auto& currentCodeSizeTotal = self->compiledByteCodeSize();
if (currentCodeSizeTotal == std::numeric_limits<size_t>::max()) {
GC_invoke_finalizers();
// we need to check this because ~VMInstance can be called by GC_invoke_finalizers
if (!self->m_isFinalized) {
currentCodeSizeTotal = 0;
auto& v = self->compiledByteCodeBlocks();
for (size_t i = 0; i < v.size(); i++) {
auto cb = v[i]->m_codeBlock;
if (UNLIKELY(!cb->isAsync() && !cb->isGenerator())) {
v[i]->m_codeBlock->setByteCodeBlock(v[i]);
}
ASSERT(v[i]->m_codeBlock->byteCodeBlock() == v[i]);
currentCodeSizeTotal += v[i]->memoryAllocatedSize();
}
}
}
/*
if (t == GC_EventType::GC_EVENT_RECLAIM_END) {
printf("Done GC: HeapSize: [%f MB , %f MB]\n", GC_get_memory_use() / 1024.f / 1024.f, GC_get_heap_size() / 1024.f / 1024.f);
printf("bytecode Size %f KiB codeblock count %zu\n", self->compiledByteCodeSize() / 1024.f, self->m_compiledByteCodeBlocks.size());
printf("regexp cache size %zu\n", self->regexpCache()->size());
}
*/
}
VMInstance::~VMInstance()
{
{
auto& v = compiledByteCodeBlocks();
for (size_t i = 0; i < v.size(); i++) {
v[i]->m_isOwnerMayFreed = true;
}
}
#if defined(ENABLE_COMPRESSIBLE_STRING)
{
auto& v = compressibleStrings();
for (size_t i = 0; i < v.size(); i++) {
v[i]->m_isOwnerMayFreed = true;
}
}
#endif
#if defined(ENABLE_RELOADABLE_STRING)
{
auto& v = reloadableStrings();
for (size_t i = 0; i < v.size(); i++) {
v[i]->m_isOwnerMayFreed = true;
}
}
#endif
m_isFinalized = true;
// remove gc event callback
if (ThreadLocal::isInited()) {
GCEventListenerSet& list = ThreadLocal::gcEventListenerSet();
Optional<GCEventListenerSet::EventListenerVector*> msListeners = list.markStartListeners();
if (msListeners) {
auto iter = std::find(msListeners->begin(), msListeners->end(), std::make_pair(vmMarkStartCallback, static_cast<void*>(this)));
// the pointer could pointer end
// because ThreadLocal can be differ regard to multiple init-deinit
if (iter != msListeners->end()) {
msListeners->erase(iter);
}
}
Optional<GCEventListenerSet::EventListenerVector*> reListeners = list.reclaimEndListeners();
if (reListeners) {
auto iter = std::find(reListeners->begin(), reListeners->end(), std::make_pair(vmReclaimEndCallback, static_cast<void*>(this)));
// the pointer could pointer end
// because ThreadLocal can be differ regard to multiple init-deinit
if (iter != reListeners->end()) {
reListeners->erase(iter);
}
}
}
if (m_onVMInstanceDestroy) {
m_onVMInstanceDestroy(this, m_onVMInstanceDestroyData);
}
clearCachesRelatedWithContext();
#if defined(ENABLE_ICU)
ucal_close(m_calendar);
#endif
#if defined(ENABLE_CODE_CACHE)
delete m_codeCache;
#endif
}
VMInstance::VMInstance(const char* locale, const char* timezone, const char* baseCacheDir)
: m_staticStrings(&m_atomicStringMap)
, m_currentSandBox(nullptr)
, m_isFinalized(false)
, m_inIdleMode(false)
, m_didSomePrototypeObjectDefineIndexedProperty(false)
, m_compiledByteCodeSize(0)
, m_maxCompiledByteCodeSize(SCRIPT_FUNCTION_OBJECT_BYTECODE_SIZE_MAX)
#if defined(ENABLE_COMPRESSIBLE_STRING)
, m_lastCompressibleStringsTestTime(0)
, m_compressibleStringsUncomressedBufferSize(0)
#endif
, m_onVMInstanceDestroy(nullptr)
, m_onVMInstanceDestroyData(nullptr)
, m_errorCreationCallback(nullptr)
, m_errorCreationCallbackPublic(nullptr)
, m_errorThrowCallback(nullptr)
, m_errorThrowCallbackPublic(nullptr)
, m_promiseHook(nullptr)
, m_promiseHookPublic(nullptr)
, m_promiseRejectCallback(nullptr)
, m_promiseRejectCallbackPublic(nullptr)
, m_cachedUTC(nullptr)
{
GC_REGISTER_FINALIZER_NO_ORDER(this, [](void* obj, void*) {
VMInstance* self = (VMInstance*)obj;
self->~VMInstance();
},
nullptr, nullptr, nullptr);
if (!String::emptyString) {
String::initEmptyString();
ASSERT(!!String::emptyString && String::emptyString->isAtomicStringSource());
}
m_staticStrings.initStaticStrings();
m_regexpCache = new (GC) RegExpCacheMap();
m_regexpOptionStringCache = (ASCIIString**)GC_MALLOC(64 * sizeof(ASCIIString*));
memset(m_regexpOptionStringCache, 0, 64 * sizeof(ASCIIString*));
#if defined(ENABLE_ICU)
m_calendar = nullptr;
if (timezone) {
m_timezoneID = timezone;
} else if (getenv("TZ")) {
m_timezoneID = getenv("TZ");
} else {
m_timezoneID = "";
}
if (locale) {
m_locale = locale;
} else if (getenv("LOCALE") && strlen(getenv("LOCALE"))) {
m_locale = getenv("LOCALE");
} else {
#if defined(ENABLE_RUNTIME_ICU_BINDER)
m_locale = RuntimeICUBinder::ICU::findSystemLocale();
#else
m_locale = uloc_getDefault();
#endif
}
// remove posix postfix(A_POSIX -> A)
if (m_locale.find("_POSIX") == m_locale.length() - 6) {
m_locale = m_locale.substr(0, m_locale.length() - 6);
}
#endif
// add gc event callback
GCEventListenerSet& list = ThreadLocal::gcEventListenerSet();
list.ensureMarkStartListeners()->push_back(std::make_pair(vmMarkStartCallback, this));
list.ensureReclaimEndListeners()->push_back(std::make_pair(vmReclaimEndCallback, this));
#define DECLARE_GLOBAL_SYMBOLS(name) m_globalSymbols.name = new Symbol(new ASCIIStringFromExternalMemory("Symbol." #name, sizeof("Symbol." #name) - 1));
DEFINE_GLOBAL_SYMBOLS(DECLARE_GLOBAL_SYMBOLS);
#undef DECLARE_GLOBAL_SYMBOLS
ExecutionState stateForInit;
m_defaultStructureForObject = new ObjectStructureWithTransition(ObjectStructureItemTightVector(), false, false, false, false);
m_defaultStructureForFunctionObject = m_defaultStructureForObject->addProperty(m_staticStrings.prototype,
ObjectStructurePropertyDescriptor::createDataButHasNativeGetterSetterDescriptor(&functionPrototypeNativeGetterSetterData));
m_defaultStructureForFunctionObject = m_defaultStructureForFunctionObject->addProperty(m_staticStrings.length,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForFunctionObject = m_defaultStructureForFunctionObject->addProperty(m_staticStrings.name,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForBuiltinFunctionObject = m_defaultStructureForObject->addProperty(m_staticStrings.prototype,
ObjectStructurePropertyDescriptor::createDataButHasNativeGetterSetterDescriptor(&builtinFunctionPrototypeNativeGetterSetterData));
m_defaultStructureForBuiltinFunctionObject = m_defaultStructureForBuiltinFunctionObject->addProperty(m_staticStrings.length,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForBuiltinFunctionObject = m_defaultStructureForBuiltinFunctionObject->addProperty(m_staticStrings.name,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForNotConstructorFunctionObject = m_defaultStructureForObject->addProperty(m_staticStrings.length,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForNotConstructorFunctionObject = m_defaultStructureForNotConstructorFunctionObject->addProperty(m_staticStrings.name,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForBoundFunctionObject = m_defaultStructureForObject->addProperty(m_staticStrings.length,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForBoundFunctionObject = m_defaultStructureForBoundFunctionObject->addProperty(m_staticStrings.name,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForFunctionPrototypeObject = m_defaultStructureForObject->addProperty(m_staticStrings.constructor,
ObjectStructurePropertyDescriptor::createDataDescriptor((ObjectStructurePropertyDescriptor::PresentAttribute)(ObjectStructurePropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
m_defaultStructureForClassConstructorFunctionObject = m_defaultStructureForObject->addProperty(m_staticStrings.length,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForClassConstructorFunctionObject = m_defaultStructureForClassConstructorFunctionObject->addProperty(m_staticStrings.prototype,
ObjectStructurePropertyDescriptor::createDataButHasNativeGetterSetterDescriptor(&builtinFunctionPrototypeNativeGetterSetterData));
m_defaultStructureForClassConstructorFunctionObjectWithName = m_defaultStructureForObject->addProperty(m_staticStrings.length,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForClassConstructorFunctionObjectWithName = m_defaultStructureForClassConstructorFunctionObjectWithName->addProperty(m_staticStrings.name,
ObjectStructurePropertyDescriptor::createDataDescriptor(ObjectStructurePropertyDescriptor::ConfigurablePresent));
m_defaultStructureForClassConstructorFunctionObjectWithName = m_defaultStructureForClassConstructorFunctionObjectWithName->addProperty(m_staticStrings.prototype,
ObjectStructurePropertyDescriptor::createDataButHasNativeGetterSetterDescriptor(&builtinFunctionPrototypeNativeGetterSetterData));
m_defaultStructureForStringObject = m_defaultStructureForObject->addProperty(m_staticStrings.length, ObjectStructurePropertyDescriptor::createDataButHasNativeGetterSetterDescriptor(&stringLengthGetterSetterData));
m_defaultStructureForRegExpObject = m_defaultStructureForObject->addProperty(m_staticStrings.lastIndex,
ObjectStructurePropertyDescriptor::createDataButHasNativeGetterSetterDescriptor(&regexpLastIndexGetterSetterData));
m_defaultStructureForMappedArgumentsObject = m_defaultStructureForObject->addProperty(m_staticStrings.length, ObjectStructurePropertyDescriptor::createDataDescriptor((ObjectStructurePropertyDescriptor::PresentAttribute)(ObjectStructurePropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
m_defaultStructureForMappedArgumentsObject = m_defaultStructureForMappedArgumentsObject->addProperty(ObjectStructurePropertyName(stateForInit, globalSymbols().iterator), ObjectStructurePropertyDescriptor::createDataDescriptor((ObjectStructurePropertyDescriptor::PresentAttribute)(ObjectStructurePropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
m_defaultStructureForMappedArgumentsObject = m_defaultStructureForMappedArgumentsObject->addProperty(m_staticStrings.callee, ObjectStructurePropertyDescriptor::createDataDescriptor((ObjectStructurePropertyDescriptor::PresentAttribute)(ObjectStructurePropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
m_defaultStructureForUnmappedArgumentsObject = m_defaultStructureForObject->addProperty(m_staticStrings.length, ObjectStructurePropertyDescriptor::createDataDescriptor((ObjectStructurePropertyDescriptor::PresentAttribute)(ObjectStructurePropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
m_defaultStructureForUnmappedArgumentsObject = m_defaultStructureForUnmappedArgumentsObject->addProperty(ObjectStructurePropertyName(stateForInit, globalSymbols().iterator), ObjectStructurePropertyDescriptor::createDataDescriptor((ObjectStructurePropertyDescriptor::PresentAttribute)(ObjectStructurePropertyDescriptor::WritablePresent | ObjectStructurePropertyDescriptor::ConfigurablePresent)));
m_defaultStructureForUnmappedArgumentsObject = m_defaultStructureForUnmappedArgumentsObject->addProperty(m_staticStrings.callee, ObjectStructurePropertyDescriptor::createAccessorDescriptor((ObjectStructurePropertyDescriptor::PresentAttribute)(ObjectStructurePropertyDescriptor::NotPresent)));
m_defaultPrivateMemberStructure = new ObjectPrivateMemberStructure();
m_jobQueue = new JobQueue();
#if defined(ENABLE_TCO)
if (!Interpreter::tcoBuffer) {
Interpreter::initTCOBuffer();
}
#endif
#if defined(ENABLE_CODE_CACHE)
if (UNLIKELY(!baseCacheDir || strlen(baseCacheDir) == 0)) {
const char* homeDir = getenv("HOME");
baseCacheDir = (!homeDir || strlen(homeDir) == 0) ? "/tmp" : homeDir;
}
m_codeCache = new CodeCache(baseCacheDir);
#endif
}
#if defined(ENABLE_ICU)
#if defined(ENABLE_RUNTIME_ICU_BINDER)
static std::string findTimezone()
{
return RuntimeICUBinder::ICU::findSystemTimezoneName();
}
#elif defined(OS_WINDOWS)
static std::string findTimezone()
{
DYNAMIC_TIME_ZONE_INFORMATION tz;
DWORD ret = GetDynamicTimeZoneInformation(&tz);
UErrorCode status = U_ZERO_ERROR;
UChar result[256];
int32_t len = ucal_getTimeZoneIDForWindowsID(
(const UChar*)tz.TimeZoneKeyName, -1,
"en_US",
result,
sizeof(result) / sizeof(UChar),
&status);
RELEASE_ASSERT(status == U_ZERO_ERROR);
return (new UTF16String(result, len))->toNonGCUTF8StringData();
}
#else
static std::string findTimezone()
{
auto tz = icu::TimeZone::detectHostTimeZone();
icu::UnicodeString id;
tz->getID(id);
delete tz;
std::string r;
id.toUTF8String(r);
return r;
}
#endif
void VMInstance::ensureCalendar()
{
ensureTimezoneID();
auto u16 = utf8StringToUTF16String(timezoneID().data(), timezoneID().size());
UErrorCode status = U_ZERO_ERROR;
m_calendar = ucal_open(u16.data(), u16.length(), "en", UCAL_DEFAULT, &status);
RELEASE_ASSERT(m_calendar);
}
void VMInstance::ensureTimezoneID()
{
if (m_timezoneID == "") {
m_timezoneID = findTimezone();
}
}
void VMInstance::ensureTzname()
{
if (m_tzname[0].size()) {
return;
}
auto u16timezoneID = String::fromUTF8(timezoneID().data(), timezoneID().size())->toUTF16StringData();
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal = ucal_open(u16timezoneID.data(), u16timezoneID.length(), "en", UCAL_DEFAULT, &status);
if (U_SUCCESS(status)) {
UChar name[128];
int32_t nameLength = ucal_getTimeZoneDisplayName(cal, UCalendarDisplayNameType::UCAL_STANDARD, locale().data(), name, sizeof(name) / sizeof(UChar), &status);
if (U_SUCCESS(status)) {
m_tzname[0] = (new UTF16String(name, nameLength))->toNonGCUTF8StringData();
nameLength = ucal_getTimeZoneDisplayName(cal, UCalendarDisplayNameType::UCAL_DST, locale().data(), name, sizeof(name) / sizeof(UChar), &status);
if (U_SUCCESS(status)) {
m_tzname[1] = (new UTF16String(name, nameLength))->toNonGCUTF8StringData();
}
}
ucal_close(cal);
if (m_tzname[0].size() && m_tzname[1].size()) {
return;
}
}
// Fallback route
#if defined(OS_WINDOWS)
size_t s;
char tznameResult[100];
_get_tzname(&s, tznameResult, sizeof(tznameResult), 0);
m_tzname[0] = tznameResult;
_get_tzname(&s, tznameResult, sizeof(tznameResult), 1);
m_tzname[1] = tznameResult;
#else
// FIXME tzset function is MT-safe but changing TZ value and read tzname is not MT-safe
#if defined(ENABLE_THREADING)
static std::mutex s_mutex;
std::lock_guard<std::mutex> guard(s_mutex);
#endif
char* oldTZ = getenv("TZ");
setenv("TZ", timezoneID().data(), 1);
tzset();
m_tzname[0] = ::tzname[0];
m_tzname[1] = ::tzname[1];
if (oldTZ) {
setenv("TZ", oldTZ, 1);
} else {
unsetenv("TZ");
}
tzset();
#endif
}
#else
void VMInstance::ensureTzname()
{
if (m_tzname[0].size()) {
return;
}
tzset();
#if defined(OS_WINDOWS)
m_tzname[0] = ::_tzname[0];
m_tzname[1] = ::_tzname[1];
#else
m_tzname[0] = ::tzname[0];
m_tzname[1] = ::tzname[1];
#endif
}
#endif
DateObject* VMInstance::cachedUTC(ExecutionState& state)
{
if (m_cachedUTC == nullptr) {
DateObject* obj = new DateObject(state);
obj->setPrototype(state, Value(Value::Null));
m_cachedUTC = obj;
}
return m_cachedUTC;
}
void VMInstance::addObjectStructureToRootSet(ObjectStructure* structure)
{
ASSERT(m_rootedObjectStructure.find(structure) == m_rootedObjectStructure.end());
m_rootedObjectStructure.insert(structure);
// if non-tranition structure not marked by inlinecache,
// properties can be disappear if modifying property function is called
structure->markReferencedByInlineCache();
}
class TempObjectStructure : public ObjectStructure {
public:
TempObjectStructure(ObjectStructureItem* properties, size_t propertyCount)
: ObjectStructure(false, false, false)
, m_properties(properties)
, m_propertyCount(propertyCount)
{
}
virtual std::pair<size_t, Optional<const ObjectStructureItem*>> findProperty(const ObjectStructurePropertyName& s) override
{
return std::make_pair(0, nullptr);
}
virtual const ObjectStructureItem& readProperty(size_t idx) override
{
return m_properties[idx];
}
virtual const ObjectStructureItem* properties() const override
{
return m_properties;
}
virtual size_t propertyCount() const override
{
return m_propertyCount;
}
virtual ObjectStructure* addProperty(const ObjectStructurePropertyName& name, const ObjectStructurePropertyDescriptor& desc) override
{
return nullptr;
}
virtual ObjectStructure* removeProperty(size_t pIndex) override
{
return nullptr;
}
virtual ObjectStructure* replacePropertyDescriptor(size_t idx, const ObjectStructurePropertyDescriptor& newDesc) override
{
return nullptr;
}
virtual ObjectStructure* convertToNonTransitionStructure() override
{
return nullptr;
}
virtual bool inTransitionMode() override
{
return false;
}
private:
ObjectStructureItem* m_properties;
size_t m_propertyCount;
};
Optional<ObjectStructure*> VMInstance::findRootedObjectStructure(ObjectStructureItem* properties, size_t propertyCount)
{
TempObjectStructure temp(properties, propertyCount);
auto iter = m_rootedObjectStructure.find(&temp);
if (iter != m_rootedObjectStructure.end()) {
return *iter;
}
return nullptr;
}
void VMInstance::clearCachesRelatedWithContext()
{
m_regexpCache->clear();
globalSymbolRegistry().clear();
#if defined(ENABLE_CODE_CACHE)
// CodeCache should be cleared here because CodeCache holds a lock of cache directory
// this lock should be released immediately (destructor may be called later)
m_codeCache->clear();
#endif
if (ThreadLocal::isInited()) {
bf_clear_cache(ThreadLocal::bfContext());
}
}
void VMInstance::enterIdleMode()
{
m_inIdleMode = true;
// user can call this function many times without many performance concern
if (GC_get_bytes_since_gc() > 4096) {
GC_gcollect_and_unmap();
GC_gcollect_and_unmap();
GC_gcollect_and_unmap();
}
#if defined(ENABLE_COMPRESSIBLE_STRING)
// ESCARGOT_LOG_INFO("compressibleStringsUncomressedBufferSize before %lfKB\n", m_compressibleStringsUncomressedBufferSize/1024.f);
auto& currentAllocatedCompressibleStrings = compressibleStrings();
const size_t& currentAllocatedCompressibleStringsCount = currentAllocatedCompressibleStrings.size();
for (size_t i = 0; i < currentAllocatedCompressibleStringsCount; i++) {
if (!currentAllocatedCompressibleStrings[i]->isCompressed()) {
currentAllocatedCompressibleStrings[i]->compress();
}
}
// ESCARGOT_LOG_INFO("compressibleStringsUncomressedBufferSize after %lfKB\n", m_compressibleStringsUncomressedBufferSize/1024.f);
#endif
#if defined(ENABLE_RELOADABLE_STRING)
auto& currentAllocatedReloadableStrings = reloadableStrings();
const size_t& currentAllocatedReloadableStringsCount = currentAllocatedReloadableStrings.size();
for (size_t i = 0; i < currentAllocatedReloadableStringsCount; i++) {
if (!currentAllocatedReloadableStrings[i]->isUnloaded()) {
currentAllocatedReloadableStrings[i]->unload();
}
}
#endif
m_inIdleMode = false;
}
void VMInstance::somePrototypeObjectDefineIndexedProperty(ExecutionState& state)
{
m_didSomePrototypeObjectDefineIndexedProperty = true;
std::vector<ArrayObject*> allOfArray;
Escargot::HeapObjectIteratorCallback callback =
[&allOfArray](Escargot::ExecutionState& state, void* obj) {
Escargot::ArrayObject* arr = (Escargot::ArrayObject*)obj;
allOfArray.push_back(arr);
};
Escargot::ArrayObject::iterateArrays(state, callback);
GC_disable();
Vector<ArrayObject*, GCUtil::gc_malloc_allocator<ArrayObject*>> allOfArrayRooted;
allOfArrayRooted.assign(allOfArray.data(), allOfArray.data() + allOfArray.size());
GC_enable();
for (size_t i = 0; i < allOfArrayRooted.size(); i++) {
allOfArrayRooted[i]->convertIntoNonFastMode(state);
}
}
void VMInstance::enqueueJob(Job* job)
{
m_jobQueue->enqueueJob(job);
Global::platform()->markJSJobEnqueued(job->relatedContext());
}
bool VMInstance::hasPendingJob()
{
return m_jobQueue->hasNextJob();
}
SandBox::SandBoxResult VMInstance::executePendingJob()
{
return m_jobQueue->nextJob()->run();
}
bool VMInstance::hasPendingJobFromAnotherThread()
{
#if defined(ENABLE_THREADING)
return m_asyncWaiterData.size();
#else
return false;
#endif
}
bool VMInstance::waitEventFromAnotherThread(unsigned timeoutInMillisecond)
{
#if defined(ENABLE_THREADING)
std::unique_lock<std::mutex> ul(m_asyncWaiterDataMutex);
if (m_pendingAsyncWaiterCount) {
return true;
}
bool notified = true;
if (timeoutInMillisecond) {
notified = m_waitEventFromAnotherThreadConditionVariable.wait_for(ul, std::chrono::milliseconds((int64_t)timeoutInMillisecond)) == std::cv_status::no_timeout;
} else {
m_waitEventFromAnotherThreadConditionVariable.wait(ul);
}
return notified;
#else
return false;
#endif
}
void VMInstance::executePendingJobFromAnotherThread()
{
#if defined(ENABLE_THREADING)
std::unique_lock<std::mutex> ul(m_asyncWaiterDataMutex);
for (size_t i = 0; i < m_asyncWaiterData.size(); i++) {
if (std::get<2>(m_asyncWaiterData[i]) == nullptr) {
Context* context = std::get<0>(m_asyncWaiterData[i]);
SandBox sb(context);
sb.run([](ExecutionState& state, void* d) -> Value {
AsyncWaiterDataItem* data = reinterpret_cast<AsyncWaiterDataItem*>(d);
PromiseObject* promise = std::get<1>(*data)->asPromiseObject();
if (std::get<3>(*data)) {
promise->fulfill(state, state.context()->staticStrings().lazyOk().string());
} else {
promise->fulfill(state, state.context()->staticStrings().lazyTimedOut().string());
}
return promise;
},
&m_asyncWaiterData[i]);
std::get<4>(m_asyncWaiterData[i])->join();
m_asyncWaiterData.erase(i);
i--;
}
}
m_pendingAsyncWaiterCount = 0;
#endif
}
#if defined(ENABLE_ICU) && defined(ENABLE_INTL)
// some locale have script value on it eg) zh_Hant_HK. so we need to remove it
static std::string icuLocaleToBCP47LanguageRegionPair(const char* l)
{
std::string v = l;
for (size_t i = 0; i < v.length(); i++) {
if (v[i] == '_') {
v[i] = '-';
}
}
auto c = Intl::canonicalizeLanguageTag(v);
if (c.region.length()) {
return c.language + "-" + c.region;
}
return c.language;
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::intlCollatorAvailableLocales()
{
if (m_intlCollatorAvailableLocales.size() == 0) {
auto count = ucol_countAvailable();
// after removing script value from locale
// we should consider duplication
// eg) zh, zh_Hans
std::set<std::string> duplicateRemover;
for (int32_t i = 0; i < count; ++i) {
auto s = icuLocaleToBCP47LanguageRegionPair(ucol_getAvailable(i));
if (duplicateRemover.find(s) == duplicateRemover.end()) {
duplicateRemover.insert(s);
String* locale = String::fromASCII(s.data(), s.length());
m_intlCollatorAvailableLocales.pushBack(locale);
}
}
}
return m_intlCollatorAvailableLocales;
}
void VMInstance::ensureIntlSupportedLocales()
{
if (m_intlAvailableLocales.size() == 0) {
#if !defined(NDEBUG)
ASSERT(uloc_countAvailable() == udat_countAvailable());
ASSERT(uloc_countAvailable() == unum_countAvailable());
for (int32_t i = 0; i < uloc_countAvailable(); ++i) {
ASSERT(std::string(uloc_getAvailable(i)) == std::string(udat_getAvailable(i)));
ASSERT(std::string(uloc_getAvailable(i)) == std::string(unum_getAvailable(i)));
}
#endif
// after removing script value from locale
// we should consider duplication
// eg) zh, zh_Hans
std::set<std::string> duplicateRemover;
auto count = uloc_countAvailable();
for (int32_t i = 0; i < count; ++i) {
auto s = icuLocaleToBCP47LanguageRegionPair(uloc_getAvailable(i));
if (duplicateRemover.find(s) == duplicateRemover.end()) {
duplicateRemover.insert(s);
String* locale = String::fromASCII(s.data(), s.length());
m_intlAvailableLocales.pushBack(locale);
}
}
}
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::intlDateTimeFormatAvailableLocales()
{
ensureIntlSupportedLocales();
return m_intlAvailableLocales;
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::intlNumberFormatAvailableLocales()
{
ensureIntlSupportedLocales();
return m_intlAvailableLocales;
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::intlRelativeTimeFormatAvailableLocales()
{
ensureIntlSupportedLocales();
return m_intlAvailableLocales;
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::intlDisplayNamesAvailableLocales()
{
ensureIntlSupportedLocales();
return m_intlAvailableLocales;
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::intlListFormatAvailableLocales()
{
ensureIntlSupportedLocales();
return m_intlAvailableLocales;
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::caseMappingAvailableLocales()
{
if (m_caseMappingAvailableLocales.size() == 0) {
m_caseMappingAvailableLocales.pushBack(String::fromASCII("tr"));
m_caseMappingAvailableLocales.pushBack(String::fromASCII("el"));
m_caseMappingAvailableLocales.pushBack(String::fromASCII("lt"));
m_caseMappingAvailableLocales.pushBack(String::fromASCII("az"));
}
return m_caseMappingAvailableLocales;
}
const Vector<String*, GCUtil::gc_malloc_allocator<String*>>& VMInstance::intlPluralRulesAvailableLocales()
{
if (m_intlPluralRulesAvailableLocales.size() == 0) {
UErrorCode status = U_ZERO_ERROR;
UResourceBundle* rb = ures_openDirect(nullptr, "plurals", &status);
ASSERT(U_SUCCESS(status));
UResourceBundle* locales = ures_getByKey(rb, "locales", nullptr, &status);
ASSERT(U_SUCCESS(status));
UResourceBundle* res = nullptr;
std::set<std::string> duplicateRemover;
while (true) {
res = ures_getNextResource(locales, res, &status);
if (res == nullptr || U_FAILURE(status)) {
break;
}
auto s = icuLocaleToBCP47LanguageRegionPair(ures_getKey(res));
if (duplicateRemover.find(s) == duplicateRemover.end()) {
duplicateRemover.insert(s);
String* locale = String::fromASCII(s.data(), s.length());
m_intlPluralRulesAvailableLocales.pushBack(locale);
}
}
ures_close(res);
ures_close(locales);
ures_close(rb);
}
return m_intlPluralRulesAvailableLocales;
}
#endif
} // namespace Escargot
Reference in a new issue View git blame Copy permalink