/* * Copyright (c) 2021-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ECMASCRIPT_STUBS_RUNTIME_STUBS_INL_H #define ECMASCRIPT_STUBS_RUNTIME_STUBS_INL_H #include "ecmascript/ecma_macros.h" #include "ecmascript/js_tagged_value.h" #include "ecmascript/stubs/runtime_stubs.h" #include "ecmascript/base/array_helper.h" #include "ecmascript/builtins/builtins_regexp.h" #include "ecmascript/compiler/aot_file/aot_file_manager.h" #include "ecmascript/debugger/js_debugger_manager.h" #include "ecmascript/ecma_string_table.h" #include "ecmascript/global_dictionary-inl.h" #include "ecmascript/global_env.h" #include "ecmascript/ic/profile_type_info.h" #include "ecmascript/interpreter/frame_handler.h" #include "ecmascript/interpreter/interpreter.h" #include "ecmascript/jobs/micro_job_queue.h" #include "ecmascript/js_arguments.h" #include "ecmascript/js_async_function.h" #include "ecmascript/js_async_generator_object.h" #include "ecmascript/js_bigint.h" #include "ecmascript/js_for_in_iterator.h" #include "ecmascript/js_generator_object.h" #include "ecmascript/js_iterator.h" #include "ecmascript/js_promise.h" #include "ecmascript/jspandafile/class_info_extractor.h" #include "ecmascript/jspandafile/literal_data_extractor.h" #include "ecmascript/jspandafile/program_object.h" #include "ecmascript/jspandafile/scope_info_extractor.h" #include "ecmascript/message_string.h" #include "ecmascript/module/js_module_manager.h" #include "ecmascript/module/js_module_source_text.h" #include "ecmascript/module/module_value_accessor.h" #include "ecmascript/object_factory-inl.h" #include "ecmascript/patch/quick_fix_helper.h" #include "ecmascript/platform/file.h" #include "ecmascript/runtime.h" #include "ecmascript/stackmap/llvm/llvm_stackmap_parser.h" #include "ecmascript/sendable_env.h" #include "ecmascript/template_string.h" namespace panda::ecmascript { using ArrayHelper = base::ArrayHelper; JSTaggedValue RuntimeStubs::RuntimeInc(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (inputVal->IsBigInt()) { JSHandle bigValue(inputVal); return BigInt::BigintAddOne(thread, bigValue).GetTaggedValue(); } JSTaggedNumber number(inputVal.GetTaggedValue()); return JSTaggedValue(++number); } JSTaggedValue RuntimeStubs::RuntimeDec(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (inputVal->IsBigInt()) { JSHandle bigValue(inputVal); return BigInt::BigintSubOne(thread, bigValue).GetTaggedValue(); } JSTaggedNumber number(inputVal.GetTaggedValue()); return JSTaggedValue(--number); } JSTaggedValue RuntimeStubs::RuntimeExp(JSThread *thread, JSTaggedValue base, JSTaggedValue exponent) { JSHandle baseTag(thread, base); JSHandle exponentTag(thread, exponent); JSHandle valBase = JSTaggedValue::ToNumeric(thread, baseTag); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle valExponent = JSTaggedValue::ToNumeric(thread, exponentTag); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (valBase->IsBigInt() || valExponent->IsBigInt()) { if (valBase->IsBigInt() && valExponent->IsBigInt()) { JSHandle bigBaseVale(valBase); JSHandle bigExponentValue(valExponent); return BigInt::Exponentiate(thread, bigBaseVale, bigExponentValue).GetTaggedValue(); } THROW_TYPE_ERROR_AND_RETURN(thread, "Cannot mix BigInt and other types, use explicit conversions", JSTaggedValue::Exception()); } double doubleBase = valBase->GetNumber(); double doubleExponent = valExponent->GetNumber(); if ((std::abs(doubleBase) == 1 && std::isinf(doubleExponent)) || std::isnan(doubleExponent)) { return JSTaggedValue(base::NAN_VALUE); } if (((doubleBase == 0) && ((base::bit_cast(doubleBase)) & base::DOUBLE_SIGN_MASK) == base::DOUBLE_SIGN_MASK) && std::isfinite(doubleExponent) && base::NumberHelper::TruncateDouble(doubleExponent) == doubleExponent && base::NumberHelper::TruncateDouble(doubleExponent / 2) + base::HALF == (doubleExponent / 2)) { // 2: half if (doubleExponent > 0) { return JSTaggedValue(-0.0); } if (doubleExponent < 0) { return JSTaggedValue(-base::POSITIVE_INFINITY); } } return JSTaggedValue(std::pow(doubleBase, doubleExponent)); } JSTaggedValue RuntimeStubs::RuntimeIsIn(JSThread *thread, const JSHandle &prop, const JSHandle &obj) { if (!obj->IsECMAObject()) { return RuntimeThrowTypeError(thread, "Cannot use 'in' operator in Non-Object"); } JSHandle propKey = JSTaggedValue::ToPropertyKey(thread, prop); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); bool ret = JSTaggedValue::HasProperty(thread, obj, propKey); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(ret); } JSTaggedValue RuntimeStubs::RuntimeInstanceof(JSThread *thread, const JSHandle &obj, const JSHandle &target) { bool ret = JSObject::InstanceOf(thread, obj, target); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(ret); } JSTaggedValue RuntimeStubs::RuntimeInstanceofByHandler(JSThread *thread, JSHandle target, JSHandle object, JSHandle instOfHandler) { // 3. ReturnIfAbrupt(instOfHandler). RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); // 4. If instOfHandler is not undefined, then if (!instOfHandler->IsUndefined()) { // a. Return ! ToBoolean(? Call(instOfHandler, target, «object»)). JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSTaggedValue function = env->GetTaggedHasInstanceFunction(); JSTaggedValue instOf = instOfHandler.GetTaggedValue(); // slowpath if (function != instOf) { JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, instOfHandler, target, undefined, 1); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(object.GetTaggedValue()); JSTaggedValue tagged = JSFunction::Call(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return tagged; } } // 5. If IsCallable(target) is false, throw a TypeError exception. if (!target->IsCallable()) { THROW_TYPE_ERROR_AND_RETURN(thread, "InstanceOf error when target is not Callable", JSTaggedValue::Exception()); } // fastpath // 6. Return ? OrdinaryHasInstance(target, object). bool res = JSFunction::OrdinaryHasInstance(thread, target, object); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(res); } JSTaggedValue RuntimeStubs::RuntimeCreateGeneratorObj(JSThread *thread, const JSHandle &genFunc) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle obj = factory->NewJSGeneratorObject(genFunc); JSHandle context = factory->NewGeneratorContext(); context->SetGeneratorObject(thread, obj.GetTaggedValue()); // change state to SUSPENDED_START obj->SetGeneratorState(JSGeneratorState::SUSPENDED_START); obj->SetGeneratorContext(thread, context); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return obj.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeCreateAsyncGeneratorObj(JSThread *thread, const JSHandle &genFunc) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle obj = factory->NewJSAsyncGeneratorObject(genFunc); JSHandle context = factory->NewGeneratorContext(); context->SetGeneratorObject(thread, obj.GetTaggedValue()); // change state to SUSPENDED_START obj->SetAsyncGeneratorState(JSAsyncGeneratorState::SUSPENDED_START); obj->SetGeneratorContext(thread, context); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return obj.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeGetTemplateObject(JSThread *thread, const JSHandle &literal) { JSHandle templateObj = TemplateString::GetTemplateObject(thread, literal); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return templateObj.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeGetNextPropName(JSThread *thread, const JSHandle &iter) { ASSERT(iter->IsForinIterator()); JSTaggedValue res = JSForInIterator::NextInternal(thread, JSHandle::Cast(iter)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res; } JSTaggedValue RuntimeStubs::RuntimeIterNext(JSThread *thread, const JSHandle &iter) { JSHandle resultObj = JSIterator::IteratorNext(thread, iter); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return resultObj.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeCloseIterator(JSThread *thread, const JSHandle &iter) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); const GlobalEnvConstants *globalConst = thread->GlobalConstants(); JSHandle record; if (thread->HasPendingException()) { record = JSHandle(factory->NewCompletionRecord( CompletionRecordType::THROW, JSHandle(thread, thread->GetException()))); } else { JSHandle undefinedVal = globalConst->GetHandledUndefined(); record = JSHandle(factory->NewCompletionRecord(CompletionRecordType::NORMAL, undefinedVal)); } JSHandle result = JSIterator::IteratorClose(thread, iter, record); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (result->IsCompletionRecord()) { return CompletionRecord::Cast(result->GetTaggedObject())->GetValue(thread); } return result.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeSuperCallSpread(JSThread *thread, const JSHandle &func, const JSHandle &newTarget, const JSHandle &array) { JSHandle superFunc(thread, JSTaggedValue::GetPrototype(thread, func)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!superFunc->IsJSFunction()) { THROW_TYPE_ERROR_AND_RETURN(thread, "Super constructor is not JSFunction", JSTaggedValue::Exception()); } JSHandle argv(thread, RuntimeGetCallSpreadArgs(thread, array)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); const uint32_t argsLength = argv->GetLength(); JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, superFunc, undefined, newTarget, argsLength); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(argsLength, argv); JSTaggedValue result = JSFunction::Construct(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return result; } JSTaggedValue RuntimeStubs::RuntimeOptSuperCallSpread(JSThread *thread, const JSHandle &func, const JSHandle &newTarget, const JSHandle &taggedArray) { JSHandle superFunc(thread, JSTaggedValue::GetPrototype(thread, func)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!superFunc->IsJSFunction()) { THROW_TYPE_ERROR_AND_RETURN(thread, "Super constructor is not JSFunction", JSTaggedValue::Exception()); } JSHandle argv(thread, taggedArray.GetTaggedValue()); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); const uint32_t argsLength = argv->GetLength(); JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, superFunc, undefined, newTarget, argsLength); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(argsLength, argv); JSTaggedValue result = JSFunction::Construct(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return result; } JSTaggedValue RuntimeStubs::RuntimeSuperCallForwardAllArgs(JSThread *thread, JSTaggedType *sp, const JSHandle &superFunc, const JSHandle &newTarget, uint32_t restNumArgs, uint32_t startIdx) { if (!superFunc->IsConstructor()) { THROW_TYPE_ERROR_AND_RETURN(thread, "Super constructor is not a constructor", JSTaggedValue::Exception()); } // prepare callinfo JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, superFunc, undefined, newTarget, restNumArgs); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); // set args for callinfo for (uint32_t i = 0; i < restNumArgs; ++i) { // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) info->SetCallArg(i, JSTaggedValue(sp[startIdx + i])); } // execute super ctor with call info JSTaggedValue res = JSFunction::Construct(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res; } JSTaggedValue RuntimeStubs::RuntimeDelObjProp(JSThread *thread, const JSHandle &obj, const JSHandle &prop) { JSHandle jsObj(JSTaggedValue::ToObject(thread, obj)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle propKey = JSTaggedValue::ToPropertyKey(thread, prop); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); bool ret = JSTaggedValue::DeletePropertyOrThrow(thread, jsObj, propKey); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(ret); } JSTaggedValue RuntimeStubs::RuntimeNewObjApply(JSThread *thread, const JSHandle &func, const JSHandle &array) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); if (!array->IsJSArray()) { return RuntimeThrowTypeError(thread, "Cannot Newobjspread"); } uint32_t length = JSHandle::Cast(array)->GetArrayLength(); JSHandle argsArray = factory->NewTaggedArray(length); for (uint32_t i = 0; i < length; ++i) { auto prop = JSTaggedValue::GetProperty(thread, array, i).GetValue(); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); argsArray->Set(thread, i, prop); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, func, undefined, func, length); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(length, argsArray); return NewObject(info); } JSTaggedValue RuntimeStubs::RuntimeCreateIterResultObj(JSThread *thread, const JSHandle &value, JSTaggedValue flag) { ASSERT(flag.IsBoolean()); bool done = flag.IsTrue(); JSHandle iter = JSIterator::CreateIterResultObject(thread, value, done); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return iter.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeAsyncFunctionAwaitUncaught(JSThread *thread, const JSHandle &asyncFuncObj, const JSHandle &value) { JSAsyncFunction::AsyncFunctionAwait(thread, asyncFuncObj, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (asyncFuncObj->IsAsyncGeneratorObject()) { JSHandle obj = JSTaggedValue::ToObject(thread, asyncFuncObj); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle generator = JSHandle::Cast(obj); JSHandle queue(thread, generator->GetAsyncGeneratorQueue(thread)); if (queue->Empty(thread)) { return JSTaggedValue::Undefined(); } JSHandle next(thread, queue->Front(thread)); JSHandle completion(thread, next->GetCapability(thread)); JSHandle promise(thread, completion->GetPromise(thread)); return promise.GetTaggedValue(); } JSHandle asyncFuncObjHandle(asyncFuncObj); JSHandle promise(thread, asyncFuncObjHandle->GetPromise(thread)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return promise.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeAsyncFunctionResolveOrReject(JSThread *thread, const JSHandle &asyncFuncObj, const JSHandle &value, bool is_resolve) { JSHandle asyncFuncObjHandle(asyncFuncObj); JSHandle promise(thread, asyncFuncObjHandle->GetPromise(thread)); if (thread->GetEcmaVM()->GetJSOptions().EnablePendingCheak()) { thread->GetEcmaVM()->RemoveAsyncStackTrace(promise); } // ActivePromise JSHandle reactions = JSPromise::CreateResolvingFunctions(thread, promise); const GlobalEnvConstants *globalConst = thread->GlobalConstants(); JSHandle thisArg = globalConst->GetHandledUndefined(); JSHandle activeFunc; if (is_resolve) { activeFunc = JSHandle(thread, reactions->GetResolveFunction(thread)); } else { activeFunc = JSHandle(thread, reactions->GetRejectFunction(thread)); } JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, activeFunc, thisArg, undefined, 1); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(value.GetTaggedValue()); [[maybe_unused]] JSTaggedValue res = JSFunction::Call(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return promise.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeAsyncGeneratorResolve(JSThread *thread, JSHandle asyncFuncObj, JSHandle value, JSTaggedValue flag) { [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle asyncGeneratorObjHandle(asyncFuncObj); JSHandle valueHandle(value); JSHandle genContextHandle(thread, asyncGeneratorObjHandle->GetGeneratorContext(thread)); // save stack, should copy cur_frame, function execute over will free cur_frame SaveFrameToContext(thread, genContextHandle); ASSERT(flag.IsBoolean()); bool done = flag.IsTrue(); return JSAsyncGeneratorObject::AsyncGeneratorResolve(thread, asyncGeneratorObjHandle, valueHandle, done); } JSTaggedValue RuntimeStubs::RuntimeAsyncGeneratorReject(JSThread *thread, JSHandle asyncFuncObj, JSHandle value) { [[maybe_unused]] EcmaHandleScope handleScope(thread); JSHandle asyncGeneratorObjHandle(asyncFuncObj); JSHandle valueHandle(value); return JSAsyncGeneratorObject::AsyncGeneratorReject(thread, asyncGeneratorObjHandle, valueHandle); } JSTaggedValue RuntimeStubs::RuntimeCopyDataProperties(JSThread *thread, const JSHandle &dst, const JSHandle &src) { if (!src->IsNull() && !src->IsUndefined()) { // 2. Let from be ! ToObject(source). JSHandle from(JSTaggedValue::ToObject(thread, src)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle keys = JSTaggedValue::GetOwnPropertyKeys(thread, from); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSMutableHandle key(thread, JSTaggedValue::Undefined()); uint32_t keysLen = keys->GetLength(); for (uint32_t i = 0; i < keysLen; i++) { PropertyDescriptor desc(thread); key.Update(keys->Get(thread, i)); bool success = JSTaggedValue::GetOwnProperty(thread, from, key, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (success && desc.IsEnumerable()) { desc.SetWritable(true); desc.SetConfigurable(true); JSTaggedValue::DefineOwnProperty(thread, dst, key, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } } } return dst.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeStArraySpread(JSThread *thread, const JSHandle &dst, JSTaggedValue index, const JSHandle &src) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle undefinedHandle(thread, JSTaggedValue::Undefined()); ASSERT(dst->IsJSArray()); if (dst->IsJSArray()) { if (src->IsNull() || src->IsUndefined()) { THROW_TYPE_ERROR_AND_RETURN(thread, "src is not iterable", JSTaggedValue::Exception()); } } else { THROW_TYPE_ERROR_AND_RETURN(thread, "dst is not iterable", JSTaggedValue::Exception()); } if (src->IsString()) { JSHandle srcString = JSTaggedValue::ToString(thread, src); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle srcFlat = JSHandle(thread, EcmaStringAccessor::Flatten(thread->GetEcmaVM(), srcString)); uint32_t dstLen = static_cast(index.GetInt()); uint32_t strLen = EcmaStringAccessor(srcFlat).GetLength(); for (uint32_t i = 0; i < strLen; i++) { uint16_t res = EcmaStringAccessor(srcFlat).Get(thread, i); JSHandle strValue(factory->NewFromUtf16Literal(&res, 1)); JSTaggedValue::SetProperty(thread, dst, dstLen + i, strValue, true); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } JSHandle length(thread, JSTaggedValue(dstLen + strLen)); if (strLen == 0U) { JSHandle lengthKey = thread->GlobalConstants()->GetHandledLengthString(); JSTaggedValue::SetProperty(thread, dst, lengthKey, length); } return length.GetTaggedValue(); } if (index.GetInt() == 0 && src->IsStableJSArray(thread)) { JSHandle srcElements(thread, JSHandle::Cast(src)->GetElements(thread)); uint32_t length = JSHandle::Cast(src)->GetArrayLength(); JSHandle dstElements = factory->NewTaggedArray(length); JSHandle dstArray = JSHandle::Cast(dst); dstArray->SetElements(thread, dstElements); dstArray->SetArrayLength(thread, length); JSHandle srcObj(src); JSHandle dstObj(dst); ElementAccessor::CopyJSArrayObject(thread, srcObj, dstObj, length); for (uint32_t i = 0; i < length; i++) { JSHandle reg(thread, ElementAccessor::Get(thread, srcObj, i)); if (reg->IsHole()) { JSHandle reg2(thread, JSArray::FastGetPropertyByValue(thread, src, i).GetTaggedValue()); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (reg2->IsHole()) { ElementAccessor::Set(thread, dstObj, i, undefinedHandle, true); } else { ElementAccessor::Set(thread, dstObj, i, reg2, true); } } else { ElementAccessor::Set(thread, dstObj, i, reg, true); } } return JSTaggedValue(length); } JSHandle iter; auto globalConst = thread->GlobalConstants(); if (src->IsJSArrayIterator() || src->IsJSMapIterator() || src->IsJSSetIterator() || src->IsIterator()) { iter = src; } else if (src->IsJSArray()) { JSHandle valuesStr = globalConst->GetHandledValuesString(); JSHandle valuesMethod = JSObject::GetMethod(thread, src, valuesStr); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); iter = JSIterator::GetIterator(thread, src, valuesMethod); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } else { iter = JSIterator::GetIterator(thread, src); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } JSMutableHandle indexHandle(thread, index); JSHandle valueStr = globalConst->GetHandledValueString(); PropertyDescriptor desc(thread); JSHandle iterResult; uint32_t srcLen = 0U; do { iterResult = JSIterator::IteratorStep(thread, iter); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (iterResult->IsFalse()) { break; } bool success = JSTaggedValue::GetOwnProperty(thread, iterResult, valueStr, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (success && desc.IsEnumerable()) { JSTaggedValue::DefineOwnProperty(thread, dst, indexHandle, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); int tmp = indexHandle->GetInt(); indexHandle.Update(JSTaggedValue(tmp + 1)); ++srcLen; } } while (true); if (srcLen == 0U) { JSHandle lengthKey = thread->GlobalConstants()->GetHandledLengthString(); JSTaggedValue::SetProperty(thread, dst, lengthKey, indexHandle); } return indexHandle.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeGetIteratorNext(JSThread *thread, const JSHandle &obj, const JSHandle &method) { ASSERT(method->IsCallable()); JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, method, obj, undefined, 0); JSTaggedValue ret = JSFunction::Call(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!ret.IsECMAObject()) { return RuntimeThrowTypeError(thread, "the Iterator is not an ecmaobject."); } return ret; } JSTaggedValue RuntimeStubs::RuntimeSetObjectWithProto(JSThread *thread, const JSHandle &proto, const JSHandle &obj) { if (!proto->IsECMAObject() && !proto->IsNull()) { return JSTaggedValue::False(); } if (UNLIKELY(proto->IsJSShared())) { THROW_TYPE_ERROR_AND_RETURN(thread, GET_MESSAGE_STRING(SetProtoWithSendable), JSTaggedValue::Exception()); } JSObject::SetPrototype(thread, obj, proto, true); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeLdObjByValue(JSThread *thread, const JSHandle &obj, const JSHandle &prop, bool callGetter, JSTaggedValue receiver) { // Ecma Spec 2015 12.3.2.1 // 7. Let bv be RequireObjectCoercible(baseValue). // 8. ReturnIfAbrupt(bv). JSHandle object = JSTaggedValue::RequireObjectCoercible(thread, obj, "Cannot load property of null or undefined"); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSTaggedValue res; if (callGetter) { res = JSObject::CallGetter(thread, AccessorData::Cast(receiver.GetTaggedObject()), object); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } else { JSHandle propKey = JSTaggedValue::ToPropertyKey(thread, prop); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); res = JSTaggedValue::GetProperty(thread, object, propKey).GetValue().GetTaggedValue(); } RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res; } JSTaggedValue RuntimeStubs::RuntimeStObjByValue(JSThread *thread, const JSHandle &obj, const JSHandle &prop, const JSHandle &value) { // Ecma Spec 2015 12.3.2.1 // 7. Let bv be RequireObjectCoercible(baseValue). // 8. ReturnIfAbrupt(bv). JSHandle object = JSTaggedValue::RequireObjectCoercible(thread, obj, "Cannot store property of null or undefined"); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle propKey(JSTaggedValue::ToPropertyKey(thread, prop)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); // strict mode is true JSTaggedValue::SetProperty(thread, object, propKey, value, true); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeStOwnByValue(JSThread *thread, const JSHandle &obj, const JSHandle &key, const JSHandle &value) { const GlobalEnvConstants *globalConst = thread->GlobalConstants(); if (obj->IsClassConstructor() && JSTaggedValue::SameValue(thread, key, globalConst->GetHandledPrototypeString())) { return RuntimeThrowTypeError(thread, "In a class, static property named 'prototype' throw a TypeError"); } // property in class is non-enumerable bool enumerable = !(obj->IsClassPrototype() || obj->IsClassConstructor()); PropertyDescriptor desc(thread, value, true, enumerable, true); JSHandle propKey = JSTaggedValue::ToPropertyKey(thread, key); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); bool ret = JSTaggedValue::DefineOwnProperty(thread, obj, propKey, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!ret) { return RuntimeThrowTypeError(thread, "StOwnByValue failed"); } return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeLdSuperByValue(JSThread *thread, const JSHandle &obj, const JSHandle &key, JSTaggedValue thisFunc) { ASSERT(thisFunc.IsJSFunction()); // get Homeobject form function JSHandle homeObject(thread, JSFunction::Cast(thisFunc.GetTaggedObject())->GetHomeObject(thread)); JSHandle superBase(thread, JSTaggedValue::GetSuperBase(thread, homeObject)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSTaggedValue::RequireObjectCoercible(thread, superBase); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle propKey(JSTaggedValue::ToPropertyKey(thread, key)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSTaggedValue res = JSTaggedValue::GetProperty(thread, superBase, propKey, obj).GetValue().GetTaggedValue(); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res; } JSTaggedValue RuntimeStubs::RuntimeStSuperByValue(JSThread *thread, const JSHandle &obj, const JSHandle &key, const JSHandle &value, JSTaggedValue thisFunc) { ASSERT(thisFunc.IsJSFunction()); // get Homeobject form function JSHandle homeObject(thread, JSFunction::Cast(thisFunc.GetTaggedObject())->GetHomeObject(thread)); JSHandle superBase(thread, JSTaggedValue::GetSuperBase(thread, homeObject)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSTaggedValue::RequireObjectCoercible(thread, superBase); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle propKey(JSTaggedValue::ToPropertyKey(thread, key)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); // check may_throw is false? JSTaggedValue::SetProperty(thread, superBase, propKey, value, obj, true); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeLdObjByIndex(JSThread *thread, const JSHandle &obj, uint32_t idx, bool callGetter, JSTaggedValue receiver) { JSTaggedValue res; if (callGetter) { res = JSObject::CallGetter(thread, AccessorData::Cast(receiver.GetTaggedObject()), obj); } else { res = JSTaggedValue::GetProperty(thread, obj, idx).GetValue().GetTaggedValue(); } RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res; } JSTaggedValue RuntimeStubs::RuntimeLdObjByName(JSThread *thread, JSTaggedValue obj, JSTaggedValue prop, bool callGetter, JSTaggedValue receiver) { JSHandle objHandle(thread, obj); JSTaggedValue res; if (callGetter) { res = JSObject::CallGetter(thread, AccessorData::Cast(receiver.GetTaggedObject()), objHandle); } else { JSHandle propHandle(thread, prop); res = JSTaggedValue::GetProperty(thread, objHandle, propHandle).GetValue().GetTaggedValue(); } RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res; } JSTaggedValue RuntimeStubs::RuntimeStObjByName(JSThread *thread, const JSHandle &obj, const JSHandle &prop, const JSHandle &value) { JSTaggedValue::SetProperty(thread, obj, prop, value, true); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeStObjByIndex(JSThread *thread, const JSHandle &obj, uint32_t idx, const JSHandle &value) { JSTaggedValue::SetProperty(thread, obj, idx, value, true); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeStOwnByIndex(JSThread *thread, const JSHandle &obj, const JSHandle &idx, const JSHandle &value) { // property in class is non-enumerable bool enumerable = !(obj->IsClassPrototype() || obj->IsClassConstructor()); PropertyDescriptor desc(thread, value, true, enumerable, true); bool ret = JSTaggedValue::DefineOwnProperty(thread, obj, idx, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!ret) { return RuntimeThrowTypeError(thread, "SetOwnByIndex failed"); } return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeStGlobalRecord(JSThread *thread, const JSHandle &prop, const JSHandle &value, bool isConst) { ObjectFactory* factory = thread->GetEcmaVM()->GetFactory(); if (thread->GetEcmaVM()->GetJSOptions().IsEnableLoweringBuiltin()) { BuiltinIndex& builtinIndex = BuiltinIndex::GetInstance(); auto index = builtinIndex.GetBuiltinIndex(thread, prop.GetTaggedValue()); if (index != BuiltinIndex::NOT_FOUND) { auto box = factory->NewPropertyBox(JSHandle(thread, JSTaggedValue::Hole())); thread->GetBuiltinEntriesPointer()->ClearByIndex(index, box.GetTaggedValue()); } } EcmaVM *vm = thread->GetEcmaVM(); JSHandle env = vm->GetGlobalEnv(); GlobalDictionary *dict = GlobalDictionary::Cast(env->GetGlobalRecord()->GetTaggedObject()); // cross files global record name binding judgment int entry = dict->FindEntry(thread, prop.GetTaggedValue()); if (entry != -1) { std::string message = "Duplicate identifier \""; message.append(EcmaStringAccessor(JSTaggedValue::ToString(thread, prop)).ToStdString(thread)); message.append("\""); LOG_ECMA(ERROR) << message; return RuntimeThrowSyntaxError(thread, "Duplicate identifier"); } PropertyAttributes attributes; if (isConst) { attributes.SetIsConstProps(true); } JSHandle dictHandle(thread, dict); JSHandle box = factory->NewPropertyBox(value); PropertyBoxType boxType = value->IsUndefined() ? PropertyBoxType::UNDEFINED : PropertyBoxType::CONSTANT; attributes.SetBoxType(boxType); dict = *GlobalDictionary::PutIfAbsent(thread, dictHandle, prop, JSHandle(box), attributes); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); env->SetGlobalRecord(thread, JSTaggedValue(dict)); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeNeg(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (inputVal->IsBigInt()) { JSHandle bigValue(inputVal); return BigInt::UnaryMinus(thread, bigValue).GetTaggedValue(); } JSTaggedNumber number(inputVal.GetTaggedValue()); if (number.IsInt()) { int32_t intValue = number.GetInt(); if (intValue == 0) { return JSTaggedValue(-0.0); } if (intValue == INT32_MIN) { return JSTaggedValue(-static_cast(INT32_MIN)); } return JSTaggedValue(-intValue); } if (number.IsDouble()) { return JSTaggedValue(-number.GetDouble()); } LOG_ECMA(FATAL) << "this branch is unreachable"; UNREACHABLE(); } JSTaggedValue RuntimeStubs::RuntimeNot(JSThread *thread, const JSHandle &value) { JSHandle inputVal = JSTaggedValue::ToNumeric(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (inputVal->IsBigInt()) { JSHandle bigValue(inputVal); return BigInt::BitwiseNOT(thread, bigValue).GetTaggedValue(); } int32_t number = JSTaggedValue::ToInt32(thread, inputVal); return JSTaggedValue(~number); // NOLINT(hicpp-signed-bitwise) } JSTaggedValue RuntimeStubs::RuntimeResolveClass(JSThread *thread, const JSHandle &ctor, const JSHandle &literal, const JSHandle &base, const JSHandle &lexenv) { ASSERT(ctor.GetTaggedValue().IsClassConstructor()); FrameHandler frameHandler(thread); JSTaggedValue currentFunc = frameHandler.GetFunction(); JSHandle ecmaModule(thread, JSFunction::Cast(currentFunc.GetTaggedObject())->GetModule(thread)); RuntimeSetClassInheritanceRelationship(thread, JSHandle(ctor), base); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); uint32_t literalBufferLength = literal->GetLength(); ASSERT(literalBufferLength > 0); // only traverse the value of key-value pair for (uint32_t index = 1; index < literalBufferLength - 1; index += 2) { // 2: key-value pair JSTaggedValue value = literal->Get(thread, index); if (LIKELY(value.IsJSFunction())) { JSFunction *func = JSFunction::Cast(value.GetTaggedObject()); func->SetLexicalEnv(thread, lexenv.GetTaggedValue()); func->SetModule(thread, ecmaModule); } } return ctor.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeCloneClassFromTemplate(JSThread *thread, const JSHandle &ctor, const JSHandle &base, const JSHandle &lexenv) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); const GlobalEnvConstants *globalConst = thread->GlobalConstants(); ASSERT(ctor.GetTaggedValue().IsClassConstructor()); JSHandle clsPrototype(thread, ctor->GetFunctionPrototype(thread)); bool canShareHClass = false; JSHandle cloneClass = factory->CloneClassCtor(ctor, lexenv, canShareHClass); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle cloneClassPrototype = factory->CloneObjectLiteral(JSHandle(clsPrototype), lexenv, canShareHClass); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); // After clone both, reset "constructor" and "prototype" properties. JSFunction::SetFunctionPrototypeOrInstanceHClass(thread, cloneClass, cloneClassPrototype.GetTaggedValue()); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); PropertyDescriptor ctorDesc(thread, JSHandle(cloneClass), true, false, true); JSTaggedValue::DefinePropertyOrThrow(thread, JSHandle(cloneClassPrototype), globalConst->GetHandledConstructorString(), ctorDesc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); cloneClass->SetHomeObject(thread, cloneClassPrototype); if (!canShareHClass) { RuntimeSetClassInheritanceRelationship(thread, JSHandle(cloneClass), base); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); } return cloneClass.GetTaggedValue(); } bool RuntimeStubs::ShouldUseAOTHClass(const JSHandle &ihc, const JSHandle &chc, const JSHandle &classLiteral) { // In the case of incomplete data collection in PGO, AOT may not create ihc and chc at the same time. // Therefore, there is no need to check for the existence of both at this point. return (!ihc->IsUndefined() || !chc->IsUndefined()) && !classLiteral->GetIsAOTUsed(); } bool RuntimeStubs::MaybeHasInterfacesType(JSThread *thread, const JSHandle &arrayHandle) { // this interface is one of the conditions for determining whether it is an interop scenario. return arrayHandle->GetLength() != 0 && arrayHandle->Get(thread, arrayHandle->GetLength() - 1).IsString(); } void RuntimeStubs::DefineInterfaceTypeOwnProperty(JSThread *thread, JSHandle &cls, const JSHandle &base, const JSHandle &lexenv, JSHandle &extractor, const JSHandle &ihc, const JSHandle &chc, const JSHandle &arrayHandle, const JSHandle &classLiteral) { // set 1.2runtie interfaceType no property. ClassInfoExtractor::BuildClassInfoExtractorFromLiteral( thread, extractor, arrayHandle, arrayHandle->GetLength(), ClassKind::NON_SENDABLE, 1); cls = EntranceForDefineClass(thread, base, lexenv, extractor, ihc, chc, classLiteral); JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle interfaceTypeSymbol = env->GetInterfaceTypeSymbol(); JSHandle interfaceTypeValue(thread, arrayHandle->Get(thread, arrayHandle->GetLength() - 1)); PropertyDescriptor desc(thread, interfaceTypeValue, false, false, false); JSObject::DefineOwnProperty( thread, JSHandle::Cast(cls), interfaceTypeSymbol, desc); } JSHandle RuntimeStubs::EntranceForDefineClass(JSThread *thread, const JSHandle &base, const JSHandle &lexenv, JSHandle &extractor, const JSHandle &ihc, const JSHandle &chc, const JSHandle &classLiteral) { if (ShouldUseAOTHClass(ihc, chc, classLiteral)) { classLiteral->SetIsAOTUsed(true); return ClassHelper::DefineClassWithIHClass(thread, base, extractor, lexenv, ihc, chc); } else { return ClassHelper::DefineClassFromExtractor(thread, base, extractor, lexenv); } } // clone class may need re-set inheritance relationship due to extends may be a variable. JSTaggedValue RuntimeStubs::RuntimeCreateClassWithBuffer(JSThread *thread, const JSHandle &base, const JSHandle &lexenv, const JSHandle &constpool, uint16_t methodId, uint16_t literalId, const JSHandle &module, const JSHandle &length) { if (base->IsJSShared()) { THROW_TYPE_ERROR_AND_RETURN(thread, GET_MESSAGE_STRING(NotSendableSubClass), JSTaggedValue::Exception()); } [[maybe_unused]] EcmaHandleScope handleScope(thread); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); CString entry = ModuleManager::GetRecordName(thread, module.GetTaggedValue()); // For class constructor. auto methodObj = ConstantPool::GetMethodFromCache(thread, constpool.GetTaggedValue(), methodId); JSHandle method(thread, methodObj); JSHandle constpoolHandle = JSHandle::Cast(constpool); JSHandle cls; JSMutableHandle ihc(thread, JSTaggedValue::Undefined()); JSMutableHandle chc(thread, JSTaggedValue::Undefined()); JSHandle cp(thread, thread->GetEcmaVM()->FindOrCreateUnsharedConstpool(constpoolHandle.GetTaggedValue())); JSTaggedValue val = cp->GetObjectFromCache(thread, literalId); if (val.IsAOTLiteralInfo()) { JSHandle aotLiteralInfo(thread, val); ihc.Update(aotLiteralInfo->GetIhc(thread)); chc.Update(aotLiteralInfo->GetChc(thread)); } JSTaggedValue literalObj = ConstantPool::GetClassLiteralFromCache(thread, cp, literalId, entry); JSHandle classLiteral(thread, literalObj); JSHandle arrayHandle(thread, classLiteral->GetArray(thread)); JSHandle extractor = factory->NewClassInfoExtractor(method); auto instance = ecmascript::Runtime::GetInstance(); ASSERT(instance != nullptr); if (instance->IsHybridVm() && MaybeHasInterfacesType(thread, arrayHandle)) { DefineInterfaceTypeOwnProperty(thread, cls, base, lexenv, extractor, ihc, chc, arrayHandle, classLiteral); } else { auto literalLength = arrayHandle->GetLength(); ClassInfoExtractor::BuildClassInfoExtractorFromLiteral(thread, extractor, arrayHandle, literalLength); if (ShouldUseAOTHClass(ihc, chc, classLiteral)) { classLiteral->SetIsAOTUsed(true); cls = ClassHelper::DefineClassWithIHClass(thread, base, extractor, lexenv, ihc, chc); } else { cls = ClassHelper::DefineClassFromExtractor(thread, base, extractor, lexenv); } } RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); RuntimeSetClassInheritanceRelationship(thread, JSHandle(cls), base); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); cls->SetLexicalEnv(thread, lexenv.GetTaggedValue()); cls->SetModule(thread, module.GetTaggedValue()); RuntimeSetClassConstructorLength(thread, cls.GetTaggedValue(), length.GetTaggedValue()); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return cls.GetTaggedValue(); } void RuntimeStubs::SetProfileTypeInfoCellToFunction(JSThread *thread, const JSHandle &jsFunc, const JSHandle &definedFunc, uint16_t slotId) { if (slotId == ProfileTypeInfo::INVALID_SLOT_INDEX) { // do nothing for invalid slotId return; } ASSERT(definedFunc->IsJSFunction()); ASSERT(!definedFunc->IsSharedFunction()); ASSERT(jsFunc->IsJSFunction()); ASSERT(!jsFunc->IsSharedFunction()); auto profileTypeInfo = jsFunc->GetProfileTypeInfo(thread); if (profileTypeInfo.IsUndefined()) { JSHandle method(thread, jsFunc->GetMethod(thread)); uint32_t slotSize = method->GetSlotSize(); profileTypeInfo = RuntimeNotifyInlineCache(thread, jsFunc, slotSize); } ASSERT(!profileTypeInfo.IsUndefined()); JSHandle profileTypeArray(thread, profileTypeInfo); JSTaggedValue slotValue = profileTypeArray->Get(thread, slotId); if (slotValue.IsUndefined()) { JSHandle handleUndefined(thread, JSTaggedValue::Undefined()); JSHandle newProfileTypeInfoCell = thread->GetEcmaVM()->GetFactory()->NewProfileTypeInfoCell(handleUndefined); profileTypeArray->Set(thread, slotId, newProfileTypeInfoCell); definedFunc->SetRawProfileTypeInfo(thread, newProfileTypeInfoCell); } else { auto cellPtr = ProfileTypeInfoCell::Cast(slotValue.GetTaggedObject()); cellPtr->UpdateProfileTypeInfoCellType(thread); definedFunc->SetRawProfileTypeInfo(thread, slotValue); } } JSTaggedValue RuntimeStubs::RuntimeCreateSharedClass(JSThread *thread, const JSHandle &base, const JSHandle &constpool, uint16_t methodId, uint16_t literalId, uint16_t length, const JSHandle &module) { if (!base->IsJSShared() && !base->IsHole()) { THROW_TYPE_ERROR_AND_RETURN(thread, GET_MESSAGE_STRING(ClassNotDerivedFromShared), JSTaggedValue::Exception()); } [[maybe_unused]] EcmaHandleScope handleScope(thread); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); CString entry = ModuleManager::GetRecordName(thread, module.GetTaggedValue()); auto methodObj = ConstantPool::GetMethodFromCache(thread, constpool.GetTaggedValue(), methodId); JSHandle method(thread, methodObj); JSHandle(method)->SetIsSendable(true); JSHandle constpoolHandle = JSHandle::Cast(constpool); JSHandle sendableEnv(thread, JSTaggedValue::Undefined()); if (module->IsSourceTextModule()) { JSHandle moduleRecord = JSHandle::Cast(module); sendableEnv = JSHandle(thread, moduleRecord->GetSendableEnv(thread)); } auto literalObj = ConstantPool::GetClassLiteralFromCache( thread, constpoolHandle, literalId, entry, sendableEnv, ClassKind::SENDABLE); JSHandle classLiteral(thread, literalObj); JSHandle arrayHandle(thread, classLiteral->GetArray(thread)); auto literalLength = arrayHandle->GetLength(); ASSERT(literalLength > 0); // fieldTypeId is the last element in literal buffer auto fieldTypeId = static_cast(arrayHandle->Get(thread, literalLength - 1).GetInt()); // Don't trim array, because define class maybe called on muilt-time in the same vm or diferrent vm JSHandle extractor = factory->NewClassInfoExtractor(method); ClassInfoExtractor::BuildClassInfoExtractorFromLiteral(thread, extractor, arrayHandle, literalLength - 1, ClassKind::SENDABLE); JSHandle fieldTypeArray = ConstantPool::GetFieldLiteral(thread, constpoolHandle, fieldTypeId, entry); JSHandle staticFieldArray = SendableClassDefiner::ExtractStaticFieldTypeArray(thread, fieldTypeArray); JSHandle cls = SendableClassDefiner::DefineSendableClassFromExtractor(thread, extractor, staticFieldArray); ModuleManager *moduleManager = thread->GetModuleManager(); JSHandle sendableClsModule = moduleManager->GenerateSendableFuncModule(module); if (sendableClsModule->IsSourceTextModule()) { JSHandle sendableClsModuleRecord(sendableClsModule); sendableClsModuleRecord->SetSendableEnv(thread, sendableEnv); } cls->SetModule(thread, sendableClsModule.GetTaggedValue()); RuntimeSetClassConstructorLength(thread, cls.GetTaggedValue(), JSTaggedValue(length)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); RuntimeSetClassInheritanceRelationship(thread, JSHandle(cls), base, ClassKind::SENDABLE); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); uint32_t arrayLength = fieldTypeArray->GetLength(); ASSERT(arrayLength > 0); auto instanceFieldNums = static_cast(fieldTypeArray->Get(thread, arrayLength - 1).GetInt()); // Don't trim array, because define class maybe called on muilt-time in the same vm or diferrent vm uint32_t instanceLength = instanceFieldNums * 2; // 2: key and value ASSERT(instanceLength < arrayLength); SendableClassDefiner::DefineSendableInstanceHClass(thread, fieldTypeArray, instanceLength, cls, base); return cls.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeSetClassInheritanceRelationship(JSThread *thread, const JSHandle &ctor, const JSHandle &base, ClassKind kind) { JSHandle env = thread->GetEcmaVM()->GetGlobalEnv(); const GlobalEnvConstants *globalConst = thread->GlobalConstants(); ASSERT(ctor->IsJSFunction()); JSHandle parent = base; /* * class A / class A extends null class A extends B * a a * | | * | __proto__ | __proto__ * | | * A ----> A.prototype A ----> A.prototype * | | | | * | __proto__ | __proto__ | __proto__ | __proto__ * | | | | * Function.prototype Object.prototype / null B ----> B.prototype */ JSHandle parentPrototype; // hole means parent is not present Method *method = Method::Cast(JSHandle::Cast(ctor)->GetMethod(thread).GetTaggedObject()); if (parent->IsHole()) { method->SetFunctionKind(FunctionKind::CLASS_CONSTRUCTOR); parentPrototype = (kind == ClassKind::SENDABLE) ? env->GetSObjectFunctionPrototype() : env->GetObjectFunctionPrototype(); parent = (kind == ClassKind::SENDABLE) ? env->GetSFunctionPrototype() : env->GetFunctionPrototype(); } else if (parent->IsNull()) { method->SetFunctionKind(FunctionKind::DERIVED_CONSTRUCTOR); parentPrototype = JSHandle(thread, JSTaggedValue::Null()); parent = (kind == ClassKind::SENDABLE) ? env->GetSFunctionPrototype() : env->GetFunctionPrototype(); } else if (!parent->IsConstructor()) { return RuntimeThrowTypeError(thread, "parent class is not constructor"); } else { method->SetFunctionKind(FunctionKind::DERIVED_CONSTRUCTOR); parentPrototype = JSTaggedValue::GetProperty(thread, parent, globalConst->GetHandledPrototypeString()).GetValue(); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!parentPrototype->IsECMAObject() && !parentPrototype->IsNull()) { return RuntimeThrowTypeError(thread, "parent class have no valid prototype"); } } ctor->GetTaggedObject()->GetClass()->SetPrototype(thread, parent); // __proto__ JSHandle clsPrototype(thread, JSHandle(ctor)->GetFunctionPrototype(thread)); clsPrototype->GetClass()->SetPrototype(thread, parentPrototype); // ctor -> hclass -> EnableProtoChangeMarker auto constructor = JSFunction::Cast(ctor.GetTaggedValue().GetTaggedObject()); if (constructor->GetClass()->IsAOT()) { JSHClass::EnableProtoChangeMarker(thread, JSHandle(thread, constructor->GetClass())); // prototype -> hclass -> EnableProtoChangeMarker JSHClass::EnableProtoChangeMarker( thread, JSHandle(thread, constructor->GetFunctionPrototype(thread).GetTaggedObject()->GetClass())); } // by enableing the ProtoChangeMarker, the IHC generated in the Aot stage // is registered into the listener of its prototype. In this way, it is ensured // that when the prototype changes, the affected IHC can be notified. JSTaggedValue protoOrHClass = JSHandle(ctor)->GetProtoOrHClass(thread); if (protoOrHClass.IsJSHClass()) { JSHClass *ihc = JSHClass::Cast(protoOrHClass.GetTaggedObject()); if (ihc->IsAOT()) { JSHandle ihcHandle(thread, ihc); JSHClass::EnableProtoChangeMarker(thread, ihcHandle); } } else { JSHandle protoHandle(thread, protoOrHClass); if (protoHandle->GetJSHClass()->IsAOT()) { JSHClass::EnablePHCProtoChangeMarker(thread, JSHandle(thread, protoHandle->GetJSHClass())); } } return JSTaggedValue::Undefined(); } JSTaggedValue RuntimeStubs::RuntimeSetClassConstructorLength(JSThread *thread, JSTaggedValue ctor, JSTaggedValue length) { ASSERT(ctor.IsClassConstructor()); JSFunction* cls = JSFunction::Cast(ctor.GetTaggedObject()); if (LIKELY(!cls->GetClass()->IsDictionaryMode())) { cls->SetPropertyInlinedProps(thread, JSFunction::LENGTH_INLINE_PROPERTY_INDEX, length); } else { const GlobalEnvConstants *globalConst = thread->GlobalConstants(); cls->UpdatePropertyInDictionary(thread, globalConst->GetLengthString(), length); } return JSTaggedValue::Undefined(); } JSTaggedValue RuntimeStubs::RuntimeNotifyInlineCache(JSThread *thread, const JSHandle &function, uint32_t icSlotSize) { // max ic slot index is 0xffff, the size of ic slot could extend more ASSERT(icSlotSize <= ProfileTypeInfo::MAX_SLOT_INDEX + MethodLiteral::EXTEND_SLOT_SIZE); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle profileTypeInfo; if (function->IsSharedFunction()) { return JSTaggedValue::Undefined(); } else { profileTypeInfo = factory->NewProfileTypeInfo(icSlotSize); } Method *method = Method::Cast(function->GetMethod(thread)); auto codeSize = method->GetCodeSize(thread); if (pgo::PGOProfilerManager::GetInstance()->IsBigMethod(codeSize)) { LOG_ECMA(DEBUG) << "method size is too large, skip pgo. code size: " << codeSize << ", max code size: " << pgo::PGOProfilerManager::GetInstance()->GetMaxAotMethodSize(); profileTypeInfo->SetBigMethodPeriodIndex(); } JSFunction::SetProfileTypeInfo(thread, function, JSHandle::Cast(profileTypeInfo)); return profileTypeInfo.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeStOwnByValueWithNameSet(JSThread *thread, const JSHandle &obj, const JSHandle &key, const JSHandle &value) { const GlobalEnvConstants *globalConst = thread->GlobalConstants(); if (obj->IsClassConstructor() && JSTaggedValue::SameValue(thread, key, globalConst->GetHandledPrototypeString())) { return RuntimeThrowTypeError(thread, "In a class, static property named 'prototype' throw a TypeError"); } // property in class is non-enumerable bool enumerable = !(obj->IsClassPrototype() || obj->IsClassConstructor()); PropertyDescriptor desc(thread, value, true, enumerable, true); JSHandle propKey = JSTaggedValue::ToPropertyKey(thread, key); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); bool ret = JSTaggedValue::DefineOwnProperty(thread, obj, propKey, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!ret) { return RuntimeThrowTypeError(thread, "StOwnByValueWithNameSet failed"); } if (value->IsJSFunction()) { if (propKey->IsNumber()) { propKey = JSHandle(base::NumberHelper::NumberToString(thread, propKey.GetTaggedValue())); } JSFunctionBase::SetFunctionName(thread, JSHandle::Cast(value), propKey, JSHandle(thread, JSTaggedValue::Undefined())); } return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeStOwnByName(JSThread *thread, const JSHandle &obj, const JSHandle &prop, const JSHandle &value) { ASSERT(prop->IsStringOrSymbol()); // property in class is non-enumerable bool enumerable = !(obj->IsClassPrototype() || obj->IsClassConstructor()); PropertyDescriptor desc(thread, value, true, enumerable, true); bool ret = JSTaggedValue::DefineOwnProperty(thread, obj, prop, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!ret) { return RuntimeThrowTypeError(thread, "SetOwnByName failed"); } return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeStOwnByNameWithNameSet(JSThread *thread, const JSHandle &objHandle, const JSHandle &propHandle, const JSHandle &valueHandle) { ASSERT(propHandle->IsStringOrSymbol()); JSHandle propKey = JSTaggedValue::ToPropertyKey(thread, propHandle); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); // property in class is non-enumerable bool enumerable = !(objHandle->IsClassPrototype() || objHandle->IsClassConstructor()); PropertyDescriptor desc(thread, valueHandle, true, enumerable, true); bool ret = JSTaggedValue::DefineOwnProperty(thread, objHandle, propHandle, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!ret) { return RuntimeThrowTypeError(thread, "SetOwnByNameWithNameSet failed"); } JSFunctionBase::SetFunctionName(thread, JSHandle::Cast(valueHandle), propKey, JSHandle(thread, JSTaggedValue::Undefined())); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeSuspendGenerator(JSThread *thread, const JSHandle &genObj, const JSHandle &value) { if (genObj->IsAsyncGeneratorObject()) { JSHandle generatorObjectHandle(genObj); JSHandle genContextHandle(thread, generatorObjectHandle->GetGeneratorContext(thread)); // save stack, should copy cur_frame, function execute over will free cur_frame SaveFrameToContext(thread, genContextHandle); // change state to SuspendedYield if (generatorObjectHandle->IsExecuting()) { return value.GetTaggedValue(); } RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return generatorObjectHandle.GetTaggedValue(); } if (genObj->IsGeneratorObject()) { JSHandle generatorObjectHandle(genObj); JSHandle genContextHandle(thread, generatorObjectHandle->GetGeneratorContext(thread)); // set TaskInfo for TaskPool generatorObjectHandle->SetTaskInfo(thread->GetTaskInfo()); // save stack, should copy cur_frame, function execute over will free cur_frame SaveFrameToContext(thread, genContextHandle); // change state to SuspendedYield if (generatorObjectHandle->IsExecuting()) { generatorObjectHandle->SetGeneratorState(JSGeneratorState::SUSPENDED_YIELD); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return value.GetTaggedValue(); } RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return generatorObjectHandle.GetTaggedValue(); } return RuntimeThrowTypeError(thread, "RuntimeSuspendGenerator failed"); } void RuntimeStubs::RuntimeSetGeneratorState(JSThread *thread, const JSHandle &genObj, const int32_t index) { JSHandle generatorObjectHandle(genObj); JSHandle genContextHandle(thread, generatorObjectHandle->GetGeneratorContext(thread)); // change state switch (index) { case static_cast(JSAsyncGeneratorState::SUSPENDED_START): generatorObjectHandle->SetAsyncGeneratorState(JSAsyncGeneratorState::SUSPENDED_START); break; case static_cast(JSAsyncGeneratorState::SUSPENDED_YIELD): generatorObjectHandle->SetAsyncGeneratorState(JSAsyncGeneratorState::SUSPENDED_YIELD); break; case static_cast(JSAsyncGeneratorState::EXECUTING): generatorObjectHandle->SetAsyncGeneratorState(JSAsyncGeneratorState::EXECUTING); break; case static_cast(JSAsyncGeneratorState::COMPLETED): generatorObjectHandle->SetAsyncGeneratorState(JSAsyncGeneratorState::COMPLETED); break; case static_cast(JSAsyncGeneratorState::AWAITING_RETURN): generatorObjectHandle->SetAsyncGeneratorState(JSAsyncGeneratorState::AWAITING_RETURN); break; default: LOG_ECMA(FATAL) << "this branch is unreachable"; UNREACHABLE(); } } JSTaggedValue RuntimeStubs::RuntimeGetModuleNamespace(JSThread *thread, int32_t index) { return ModuleValueAccessor::GetModuleNamespace(thread, index); } JSTaggedValue RuntimeStubs::RuntimeGetModuleNamespace(JSThread *thread, int32_t index, JSTaggedValue jsFunc) { return ModuleValueAccessor::GetModuleNamespace(thread, index, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeGetModuleNamespace(JSThread *thread, JSTaggedValue localName) { return DeprecatedModuleValueAccessor::GetModuleNamespace(thread, localName); } JSTaggedValue RuntimeStubs::RuntimeGetModuleNamespace(JSThread *thread, JSTaggedValue localName, JSTaggedValue jsFunc) { return DeprecatedModuleValueAccessor::GetModuleNamespace(thread, localName, jsFunc); } void RuntimeStubs::RuntimeStModuleVar(JSThread *thread, int32_t index, JSTaggedValue value) { ModuleValueAccessor::StoreModuleValue(thread, index, value); } void RuntimeStubs::RuntimeStModuleVar(JSThread *thread, int32_t index, JSTaggedValue value, JSTaggedValue jsFunc) { ModuleValueAccessor::StoreModuleValue(thread, index, value, jsFunc); } void RuntimeStubs::RuntimeStModuleVar(JSThread *thread, JSTaggedValue key, JSTaggedValue value) { DeprecatedModuleValueAccessor::StoreModuleValue(thread, key, value); } void RuntimeStubs::RuntimeStModuleVar(JSThread *thread, JSTaggedValue key, JSTaggedValue value, JSTaggedValue jsFunc) { DeprecatedModuleValueAccessor::StoreModuleValue(thread, key, value, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeLdLocalModuleVar(JSThread *thread, int32_t index) { return ModuleValueAccessor::GetModuleValueInner(thread, index); } inline JSTaggedValue RuntimeStubs::RuntimeLdLocalModuleVarWithModule(JSThread* thread, int32_t index, JSHandle moduleHdl) { JSTaggedValue module = moduleHdl.GetTaggedValue(); ModuleManager* mmgr = thread->GetModuleManager(); if (SourceTextModule::IsSendableFunctionModule(module)) { const CString recordNameStr = SourceTextModule::GetModuleName(module); module = mmgr->HostGetImportedModule(recordNameStr).GetTaggedValue(); } return SourceTextModule::Cast(module)->GetModuleValue(thread, index, false); } JSTaggedValue RuntimeStubs::RuntimeLdLocalModuleVar(JSThread *thread, int32_t index, JSTaggedValue jsFunc) { return ModuleValueAccessor::GetModuleValueInner(thread, index, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeLdExternalModuleVar(JSThread *thread, int32_t index) { return ModuleValueAccessor::GetModuleValueOuter(thread, index); } inline JSTaggedValue RuntimeStubs::RuntimeLdExternalModuleVarWithModule(JSThread* thread, int32_t index, JSHandle moduleHdl) { JSTaggedValue module = moduleHdl.GetTaggedValue(); ModuleManager* mmgr = thread->GetModuleManager(); if (SourceTextModule::IsSendableFunctionModule(module)) { const CString recordNameStr = SourceTextModule::GetModuleName(module); module = mmgr->HostGetImportedModule(recordNameStr).GetTaggedValue(); moduleHdl = JSHandle(thread, module); } return ModuleValueAccessor::GetModuleValueOuter(thread, index, moduleHdl); } JSTaggedValue RuntimeStubs::RuntimeLdSendableExternalModuleVar(JSThread *thread, int32_t index, JSTaggedValue jsFunc) { return ModuleValueAccessor::GetSendableModuleValueOuter(thread, index, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeLdSendableLocalModuleVar(JSThread* thread, int32_t index, JSTaggedValue jsFunc) { return ModuleValueAccessor::GetSendableModuleValueInner(thread, index, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeLdExternalModuleVar(JSThread *thread, int32_t index, JSTaggedValue jsFunc) { return ModuleValueAccessor::GetModuleValueOuter(thread, index, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeLdLazyExternalModuleVar(JSThread *thread, int32_t index, JSTaggedValue jsFunc) { return ModuleValueAccessor::GetLazyModuleValueOuter(thread, index, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeLdLazySendableExternalModuleVar( JSThread *thread, int32_t index, JSTaggedValue jsFunc) { return ModuleValueAccessor::GetLazySendableModuleValueOuter(thread, index, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeLdModuleVar(JSThread *thread, JSTaggedValue key, bool inner) { if (inner) { JSTaggedValue moduleValue = DeprecatedModuleValueAccessor::GetModuleValueInner(thread, key); return moduleValue; } return DeprecatedModuleValueAccessor::GetModuleValueOuter(thread, key); } JSTaggedValue RuntimeStubs::RuntimeLdModuleVar(JSThread *thread, JSTaggedValue key, bool inner, JSTaggedValue jsFunc) { if (inner) { JSTaggedValue moduleValue = DeprecatedModuleValueAccessor::GetModuleValueInner(thread, key, jsFunc); return moduleValue; } return DeprecatedModuleValueAccessor::GetModuleValueOuter(thread, key, jsFunc); } JSTaggedValue RuntimeStubs::RuntimeGetPropIterator(JSThread *thread, const JSHandle &value) { JSHandle iteratorHandle = JSObject::EnumerateObjectProperties(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return iteratorHandle.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeAsyncFunctionEnter(JSThread *thread) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); // 1. create promise JSHandle globalEnv = thread->GetEcmaVM()->GetGlobalEnv(); JSHandle promiseFunc(globalEnv->GetPromiseFunction()); JSHandle promiseObject(factory->NewJSObjectByConstructor(promiseFunc)); if (thread->GetEcmaVM()->GetJSOptions().EnablePendingCheak()) { thread->GetEcmaVM()->InsertAsyncStackTrace(promiseObject); } promiseObject->SetPromiseState(PromiseState::PENDING); // 2. create asyncfuncobj JSHandle asyncFuncObj = factory->NewJSAsyncFuncObject(); asyncFuncObj->SetPromise(thread, promiseObject); JSHandle context = factory->NewGeneratorContext(); context->SetGeneratorObject(thread, asyncFuncObj); // change state to EXECUTING asyncFuncObj->SetGeneratorState(JSGeneratorState::EXECUTING); asyncFuncObj->SetGeneratorContext(thread, context); // 3. return asyncfuncobj RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return asyncFuncObj.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeGetIterator(JSThread *thread, const JSHandle &obj) { EcmaVM *vm = thread->GetEcmaVM(); JSHandle env = vm->GetGlobalEnv(); JSHandle valuesFunc = JSTaggedValue::GetProperty(thread, obj, env->GetIteratorSymbol()).GetValue(); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!valuesFunc->IsCallable()) { return valuesFunc.GetTaggedValue(); } JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, valuesFunc, obj, undefined, 0); return EcmaInterpreter::Execute(info); } JSTaggedValue RuntimeStubs::RuntimeGetAsyncIterator(JSThread *thread, const JSHandle &obj) { JSHandle asyncit = JSIterator::GetAsyncIterator(thread, obj); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return asyncit.GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeLdPrivateProperty(JSThread *thread, JSTaggedValue lexicalEnv, uint32_t levelIndex, uint32_t slotIndex, JSTaggedValue obj) { JSTaggedValue currentLexicalEnv = lexicalEnv; for (uint32_t i = 0; i < levelIndex; i++) { currentLexicalEnv = LexicalEnv::Cast(currentLexicalEnv.GetTaggedObject())->GetParentEnv(thread); ASSERT(!currentLexicalEnv.IsUndefined()); } JSTaggedValue key = LexicalEnv::Cast(currentLexicalEnv.GetTaggedObject())->GetProperties(thread, slotIndex); // private property is invisible for proxy JSHandle handleObj(thread, obj.IsJSProxy() ? JSProxy::Cast(obj)->GetPrivateField(thread) : obj); JSHandle handleKey(thread, key); if (handleKey->IsJSFunction()) { // getter JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); // 0: getter has 0 arg EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, handleKey, handleObj, undefined, 0); JSTaggedValue resGetter = JSFunction::Call(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return resGetter; } PropertyDescriptor desc(thread); if (!JSTaggedValue::IsPropertyKey(handleKey) || !JSTaggedValue::GetOwnProperty(thread, handleObj, handleKey, desc)) { THROW_TYPE_ERROR_AND_RETURN(thread, "invalid or cannot find private key", JSTaggedValue::Exception()); } JSTaggedValue res = desc.GetValue().GetTaggedValue(); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res; } JSTaggedValue RuntimeStubs::RuntimeStPrivateProperty(JSThread *thread, JSTaggedValue lexicalEnv, uint32_t levelIndex, uint32_t slotIndex, JSTaggedValue obj, JSTaggedValue value) { JSTaggedValue currentLexicalEnv = lexicalEnv; for (uint32_t i = 0; i < levelIndex; i++) { currentLexicalEnv = LexicalEnv::Cast(currentLexicalEnv.GetTaggedObject())->GetParentEnv(thread); ASSERT(!currentLexicalEnv.IsUndefined()); } JSTaggedValue key = LexicalEnv::Cast(currentLexicalEnv.GetTaggedObject())->GetProperties(thread, slotIndex); // private property is invisible for proxy JSHandle handleObj(thread, obj.IsJSProxy() ? JSProxy::Cast(obj)->GetPrivateField(thread) : obj); JSHandle handleKey(thread, key); JSHandle handleValue(thread, value); if (handleKey->IsJSFunction()) { // setter JSHandle undefined = thread->GlobalConstants()->GetHandledUndefined(); // 1: setter has 1 arg EcmaRuntimeCallInfo *info = EcmaInterpreter::NewRuntimeCallInfo(thread, handleKey, handleObj, undefined, 1); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); info->SetCallArg(handleValue.GetTaggedValue()); JSTaggedValue resSetter = JSFunction::Call(info); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return resSetter; } PropertyDescriptor desc(thread); if (!JSTaggedValue::IsPropertyKey(handleKey) || !JSTaggedValue::GetOwnProperty(thread, handleObj, handleKey, desc)) { THROW_TYPE_ERROR_AND_RETURN(thread, "invalid or cannot find private key", JSTaggedValue::Exception()); } desc.SetValue(handleValue); bool res = JSTaggedValue::DefineOwnProperty(thread, handleObj, handleKey, desc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(res); } JSTaggedValue RuntimeStubs::RuntimeTestIn(JSThread *thread, JSTaggedValue lexicalEnv, uint32_t levelIndex, uint32_t slotIndex, JSTaggedValue obj) { if (!obj.IsECMAObject()) { THROW_TYPE_ERROR_AND_RETURN(thread, "Cannot use 'in' operator in Non-Object", JSTaggedValue::Exception()); } JSTaggedValue currentLexicalEnv = lexicalEnv; for (uint32_t i = 0; i < levelIndex; i++) { currentLexicalEnv = LexicalEnv::Cast(currentLexicalEnv.GetTaggedObject())->GetParentEnv(thread); ASSERT(!currentLexicalEnv.IsUndefined()); } JSTaggedValue key = LexicalEnv::Cast(currentLexicalEnv.GetTaggedObject())->GetProperties(thread, slotIndex); JSHandle handleObj(thread, obj.IsJSProxy() ? JSProxy::Cast(obj)->GetPrivateField(thread) : obj); JSHandle handleKey(thread, key); bool res = JSTaggedValue::IsPropertyKey(handleKey) && JSTaggedValue::HasProperty(thread, handleObj, handleKey); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(res); } void RuntimeStubs::RuntimeThrow(JSThread *thread, JSTaggedValue value) { thread->SetException(value); } void RuntimeStubs::RuntimeThrowThrowNotExists(JSThread *thread) { THROW_TYPE_ERROR(thread, "Throw method is not defined"); } void RuntimeStubs::RuntimeThrowPatternNonCoercible(JSThread *thread) { JSHandle msg(thread->GlobalConstants()->GetHandledObjNotCoercibleString()); ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); THROW_NEW_ERROR_AND_RETURN(thread, factory->NewJSError(base::ErrorType::TYPE_ERROR, msg, StackCheck::NO).GetTaggedValue()); } void RuntimeStubs::RuntimeThrowDeleteSuperProperty(JSThread *thread) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle info = factory->NewFromASCII("Can not delete super property"); JSHandle errorObj = factory->NewJSError(base::ErrorType::REFERENCE_ERROR, info, StackCheck::NO); THROW_NEW_ERROR_AND_RETURN(thread, errorObj.GetTaggedValue()); } void RuntimeStubs::RuntimeThrowUndefinedIfHole(JSThread *thread, const JSHandle &obj) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle info(thread->GlobalConstants()->GetHandledNotInitializedString()); JSHandle msg = factory->ConcatFromString(obj, info); THROW_NEW_ERROR_AND_RETURN(thread, factory->NewJSError(base::ErrorType::REFERENCE_ERROR, msg, StackCheck::NO).GetTaggedValue()); } void RuntimeStubs::RuntimeThrowIfNotObject(JSThread *thread) { THROW_TYPE_ERROR(thread, "Inner return result is not object"); } void RuntimeStubs::RuntimeThrowConstAssignment(JSThread *thread, const JSHandle &value) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle info = factory->NewFromASCII("Assignment to const variable "); JSHandle msg = factory->ConcatFromString(info, value); THROW_NEW_ERROR_AND_RETURN(thread, factory->NewJSError(base::ErrorType::TYPE_ERROR, msg, StackCheck::NO).GetTaggedValue()); } JSTaggedValue RuntimeStubs::RuntimeLdGlobalRecord(JSThread *thread, JSTaggedValue key) { EcmaVM *vm = thread->GetEcmaVM(); JSHandle env = vm->GetGlobalEnv(); GlobalDictionary *dict = GlobalDictionary::Cast(env->GetGlobalRecord()->GetTaggedObject()); int entry = dict->FindEntry(thread, key); if (entry != -1) { return JSTaggedValue(dict->GetBox(thread, entry)); } return JSTaggedValue::Undefined(); } JSTaggedValue RuntimeStubs::RuntimeTryLdGlobalByName(JSThread *thread, const JSHandle &obj, const JSHandle &prop) { OperationResult res = JSTaggedValue::GetProperty(thread, obj, prop); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (!res.GetPropertyMetaData().IsFound()) { return RuntimeThrowReferenceError(thread, prop, " is not defined"); } return res.GetValue().GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeTryUpdateGlobalRecord(JSThread *thread, JSTaggedValue prop, JSTaggedValue value) { EcmaVM *vm = thread->GetEcmaVM(); JSHandle env = vm->GetGlobalEnv(); GlobalDictionary *dict = GlobalDictionary::Cast(env->GetGlobalRecord()->GetTaggedObject()); int entry = dict->FindEntry(thread, prop); ASSERT(entry != -1); if (dict->GetAttributes(thread, entry).IsConstProps()) { return RuntimeThrowTypeError(thread, "const variable can not be modified"); } PropertyBox *box = dict->GetBox(thread, entry); box->SetValue(thread, value); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeThrowReferenceError(JSThread *thread, const JSHandle &prop, const char *desc) { ObjectFactory *factory = thread->GetEcmaVM()->GetFactory(); JSHandle propName = JSTaggedValue::ToString(thread, prop); ASSERT_NO_ABRUPT_COMPLETION(thread); JSHandle info = factory->NewFromUtf8(desc); JSHandle msg = factory->ConcatFromString(propName, info); THROW_NEW_ERROR_AND_RETURN_VALUE(thread, factory->NewJSError(base::ErrorType::REFERENCE_ERROR, msg, StackCheck::NO).GetTaggedValue(), JSTaggedValue::Exception()); } JSTaggedValue RuntimeStubs::RuntimeLdGlobalVarFromProto(JSThread *thread, const JSHandle &globalObj, const JSHandle &prop) { ASSERT(globalObj->IsJSGlobalObject()); JSHandle global(globalObj); JSHandle obj(thread, JSObject::GetPrototype(thread, global)); OperationResult res = JSTaggedValue::GetProperty(thread, obj, prop); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return res.GetValue().GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeStGlobalVar(JSThread *thread, const JSHandle &prop, const JSHandle &value) { JSHandle global(thread, thread->GetEcmaVM()->GetGlobalEnv()->GetGlobalObject()); JSObject::GlobalSetProperty(thread, prop, value, true); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue::True(); } JSTaggedValue RuntimeStubs::RuntimeToNumber(JSThread *thread, const JSHandle &value) { return JSTaggedValue::ToNumber(thread, value); } JSTaggedValue RuntimeStubs::RuntimeToNumeric(JSThread *thread, const JSHandle &value) { return JSTaggedValue::ToNumeric(thread, value).GetTaggedValue(); } JSTaggedValue RuntimeStubs::RuntimeDynamicImport(JSThread *thread, const JSHandle &specifier, const JSHandle &func) { EcmaVM *ecmaVm = thread->GetEcmaVM(); JSHandle env = ecmaVm->GetGlobalEnv(); ObjectFactory *factory = ecmaVm->GetFactory(); // get current filename JSFunction *function = JSFunction::Cast(func->GetTaggedObject()); const JSPandaFile *jsPandaFile = function->GetCallTarget(thread)->GetJSPandaFile(thread); ASSERT(jsPandaFile != nullptr); CString currentfilename = jsPandaFile->GetJSPandaFileDesc(); JSMutableHandle dirPath(thread, thread->GlobalConstants()->GetUndefined()); JSMutableHandle recordName(thread, thread->GlobalConstants()->GetUndefined()); if (jsPandaFile->IsBundlePack()) { dirPath.Update(factory->NewFromUtf8(currentfilename).GetTaggedValue()); } else { recordName.Update(factory->NewFromUtf8(function->GetRecordName(thread))); dirPath.Update(factory->NewFromUtf8(currentfilename).GetTaggedValue()); } // 4. Let promiseCapability be !NewPromiseCapability(%Promise%). JSHandle promiseFunc = env->GetPromiseFunction(); JSHandle promiseCapability = JSPromise::NewPromiseCapability(thread, promiseFunc); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle job = ecmaVm->GetMicroJobQueue(); JSHandle argv = factory->NewTaggedArray(5); // 5: 5 means parameters stored in array argv->Set(thread, 0, promiseCapability->GetResolve(thread)); argv->Set(thread, 1, promiseCapability->GetReject(thread)); // 1 : reject method argv->Set(thread, 2, dirPath); // 2 : current file path(containing file name) argv->Set(thread, 3, specifier); // 3 : request module's path argv->Set(thread, 4, recordName); // 4 : js recordName or undefined JSHandle dynamicImportJob(env->GetDynamicImportJob()); job::MicroJobQueue::EnqueueJob(thread, job, job::QueueType::QUEUE_PROMISE, dynamicImportJob, argv); return promiseCapability->GetPromise(thread); } JSTaggedValue RuntimeStubs::RuntimeEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Equal(thread, left, right); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } JSTaggedValue RuntimeStubs::RuntimeNotEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Equal(thread, left, right); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::False() : JSTaggedValue::True()); } JSTaggedValue RuntimeStubs::RuntimeLess(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Compare(thread, left, right) == ComparisonResult::LESS; RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } JSTaggedValue RuntimeStubs::RuntimeLessEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Compare(thread, left, right) <= ComparisonResult::EQUAL; RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } JSTaggedValue RuntimeStubs::RuntimeGreater(JSThread *thread, const JSHandle &left, const JSHandle &right) { bool ret = JSTaggedValue::Compare(thread, left, right) == ComparisonResult::GREAT; RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } JSTaggedValue RuntimeStubs::RuntimeGreaterEq(JSThread *thread, const JSHandle &left, const JSHandle &right) { ComparisonResult comparison = JSTaggedValue::Compare(thread, left, right); bool ret = (comparison == ComparisonResult::GREAT) || (comparison == ComparisonResult::EQUAL); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return (ret ? JSTaggedValue::True() : JSTaggedValue::False()); } JSTaggedValue RuntimeStubs::RuntimeAdd2(JSThread *thread, const JSHandle &left, const JSHandle &right) { if (left->IsString() && right->IsString()) { EcmaString *resultStr = EcmaStringAccessor::Concat( thread->GetEcmaVM(), JSHandle(left), JSHandle(right)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(resultStr); } JSHandle primitiveA0(thread, JSTaggedValue::ToPrimitive(thread, left)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle primitiveA1(thread, JSTaggedValue::ToPrimitive(thread, right)); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); // contain string if (primitiveA0->IsString() || primitiveA1->IsString()) { JSHandle stringA0 = JSTaggedValue::ToString(thread, primitiveA0); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle stringA1 = JSTaggedValue::ToString(thread, primitiveA1); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); EcmaString *resultStr = EcmaStringAccessor::Concat(thread->GetEcmaVM(), stringA0, stringA1); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); return JSTaggedValue(resultStr); } JSHandle valLeft = JSTaggedValue::ToNumeric(thread, primitiveA0); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); JSHandle valRight = JSTaggedValue::ToNumeric(thread, primitiveA1); RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread); if (valLeft->IsBigInt() || valRight->IsBigInt()) { if (valLeft->IsBigInt() && valRight->IsBigInt()) { JSHandle