js_hclass.cpp - OpenGrok cross reference for /arkcompiler/ets_runtime/ecmascript/js

Lines Matching refs:JSHClass
123 void JSHClass::InitializeWithDefaultValue(const JSThread *thread, uint32_t size, JSType type, uint32_t inlinedProps)
153 bool JSHClass::IsJSTypeShared(JSType type)
189 // class JSHClass
190 void JSHClass::Initialize(const JSThread *thread, uint32_t size, JSType type, uint32_t inlinedProps)
199 void JSHClass::Initialize(const JSThread *thread, uint32_t size, JSType type,
211 JSHandle<JSHClass> JSHClass::Clone(const JSThread *thread, const JSHandle<JSHClass> &jshclass,
217     JSHandle<JSHClass> newJsHClass;
239 JSHandle<JSHClass> JSHClass::CloneWithElementsKind(const JSThread *thread, const JSHandle<JSHClass> &jshclass,
242     JSHandle<JSHClass> newHClass = Clone(thread, jshclass);
249 JSHandle<JSHClass> JSHClass::CloneWithoutInlinedProperties(const JSThread *thread, const JSHandle<JSHClass> &jshclass)
254 void JSHClass::TransitionElementsToDictionary(const JSThread *thread, const JSHandle<JSObject> &obj)
268 void JSHClass::OptimizeAsFastElements(const JSThread *thread, JSHandle<JSObject> obj)
280 void JSHClass::AddProperty(const JSThread *thread, const JSHandle<JSObject> &obj, const JSHandle<JSTaggedValue> &key,
283     JSHandle<JSHClass> jshclass(thread, obj->GetJSHClass());
285     JSHClass *newClass = jshclass->FindTransitions(key.GetTaggedValue(), metadata, rep);
296         JSHandle<JSHClass> newHClass = JSHandle<JSHClass>(thread, newClass);
298             if (JSHClass::IsNeedNotifyHclassChangedForAotTransition(thread, jshclass, key.GetTaggedValue())) {
299                 JSHClass::EnableProtoChangeMarker(thread, newHClass);
300                 JSHClass::NotifyHclassChanged(thread, jshclass, newHClass, key.GetTaggedValue());
302                 JSHClass::RefreshUsers(thread, jshclass, newHClass);
304             JSHClass::EnablePHCProtoChangeMarker(thread, newHClass);
306             JSHClass::NotifyHclassChanged(thread, jshclass, newHClass, key.GetTaggedValue());
311     JSHandle<JSHClass> newJsHClass = JSHClass::Clone(thread, jshclass);
316     JSHClass::NotifyHclassChanged(thread, jshclass, newJsHClass, key.GetTaggedValue());
322 JSHandle<JSHClass> JSHClass::TransitionExtension(const JSThread *thread, const JSHandle<JSHClass> &jshclass)
329             return JSHandle<JSHClass>(thread, newClass);
334     JSHandle<JSHClass> newJsHClass = JSHClass::Clone(thread, jshclass);
350 JSHandle<JSHClass> JSHClass::TransitionProto(const JSThread *thread, const JSHandle<JSHClass> &jshclass,
358             return JSHandle<JSHClass>(thread, newClass);
362             return JSHandle<JSHClass>(thread, newClass);
368     JSHandle<JSHClass> newJsHClass = JSHClass::Clone(thread, jshclass);
386 JSHClass *JSHClass::FindTransitionProtoForAOT(const JSThread *thread, const JSHandle<JSHClass> &jshclass,
392     JSHandle<JSHClass> baseIhc(thread, proto->GetTaggedObject()->GetClass());
406     return JSHClass::Cast(transIhc->GetTaggedObject());
410 void JSHClass::ReBuildFunctionInheritanceRelationship(const JSThread *thread,
416     JSHandle<JSHClass>::Cast(transIhc)->SetProto(thread, proto.GetTaggedValue());
421     JSHandle<JSHClass> oldPhc(thread, proto->GetTaggedObject()->GetClass());
422     proto->GetTaggedObject()->SynchronizedSetClass(thread, JSHClass::Cast(transPhc->GetTaggedObject()));
423     ASSERT(JSHClass::Cast(transPhc->GetTaggedObject())->IsPrototype());
425     JSHClass::Cast(transPhc->GetTaggedObject())->SetPrototype(thread, oldPhc->GetPrototype());
427     JSTaggedValue phcPrototype = JSHClass::Cast(transPhc->GetTaggedObject())->GetPrototype();
430     JSHClass::EnablePHCProtoChangeMarker(thread,
431         JSHandle<JSHClass>(thread, parentPrototype->GetTaggedObject()->GetClass()));
432     JSHClass::EnableProtoChangeMarker(thread, JSHandle<JSHClass>(transIhc));
435 JSHandle<JSHClass> JSHClass::CloneWithAddProto(const JSThread *thread, const JSHandle<JSHClass> &jshclass,
440     JSHandle<JSHClass> newJsHClass = JSHClass::Clone(thread, jshclass);
449 JSHandle<JSHClass> JSHClass::TransProtoWithoutLayout(const JSThread *thread, const JSHandle<JSHClass> &jshclass,
457             return JSHandle<JSHClass>(thread, newClass);
464 void JSHClass::SetPrototype(const JSThread *thread, JSTaggedValue proto, bool isChangeProto)
471 JSHandle<JSHClass> JSHClass::SetPrototypeWithNotification(const JSThread *thread,
472                                                           const JSHandle<JSHClass> &hclass,
479     JSHandle<JSHClass> newClass = JSHClass::TransitionProto(thread, hclass, proto, isChangeProto);
482         JSHClass::NotifyHclassChanged(thread, hclass, newClass);
487 void JSHClass::SetPrototypeTransition(JSThread *thread, const JSHandle<JSObject> &object,
490     JSHandle<JSHClass> hclass(thread, object->GetJSHClass());
498 void JSHClass::SetPrototype(const JSThread *thread, const JSHandle<JSTaggedValue> &proto, bool isChangeProto)
507 void JSHClass::OptimizePrototypeForIC(const JSThread *thread, const JSHandle<JSTaggedValue> &proto, bool isChangeProto)
509     JSHandle<JSHClass> hclass(thread, proto->GetTaggedObject()->GetClass());
527             JSHandle<JSHClass> newProtoClass;
529                 newProtoClass = JSHandle<JSHClass>(thread, thread->GetArrayInstanceHClass(hclass->GetElementsKind(),
532                 newProtoClass = JSHClass::Clone(thread, hclass);
561 void JSHClass::TransitionToDictionary(const JSThread *thread, const JSHandle<JSObject> &obj)
564     JSHandle<JSHClass> jshclass(thread, obj->GetJSHClass());
565     JSHandle<JSHClass> newJsHClass = CloneWithoutInlinedProperties(thread, jshclass);
576         JSHClass::NotifyHclassChanged(thread, JSHandle<JSHClass>(thread, obj->GetJSHClass()), newJsHClass);
583 void JSHClass::OptimizeAsFastProperties(const JSThread *thread, const JSHandle<JSObject> &obj,
587     JSHandle<JSHClass> jshclass(thread, obj->GetJSHClass());
588     JSHandle<JSHClass> newJsHClass = Clone(thread, jshclass, isDictionary);
622         JSHClass::NotifyHclassChanged(thread, JSHandle<JSHClass>(thread, obj->GetJSHClass()), newJsHClass);
628 void JSHClass::TransitionForRepChange(const JSThread *thread, const JSHandle<JSObject> &receiver,
631     JSHandle<JSHClass> oldHClass(thread, receiver->GetJSHClass());
634     JSHandle<JSHClass> newHClass = JSHClass::Clone(thread, oldHClass);
643     auto hclass = JSHClass::Cast(newHClass.GetTaggedValue().GetTaggedObject());
644     int entry = JSHClass::FindPropertyEntry(thread, hclass, key.GetTaggedValue());
650     JSHClass::NotifyHclassChanged(thread, oldHClass, newHClass, key.GetTaggedValue());
657 bool JSHClass::IsInitialArrayHClassWithElementsKind(const JSThread *thread, const JSHClass *targetHClass,
667         JSHClass *hclass = JSHClass::Cast(hclassVal.GetTaggedObject());
668         JSHClass *hclassWithProto = JSHClass::Cast(hclassWithProtoVal.GetTaggedObject());
674 bool JSHClass::TransitToElementsKindUncheck(const JSThread *thread, const JSHandle<JSObject> &obj,
679     JSHClass *objHclass = obj->GetClass();
689             JSHClass *hclass = JSHClass::Cast(hclassVal.GetTaggedObject());
692             JSHClass::NotifyHclassChanged(thread, JSHandle<JSHClass>(thread, objHclass),
693                                           JSHandle<JSHClass>(thread, hclass));
702 void JSHClass::TransitToElementsKind(const JSThread *thread, const JSHandle<JSArray> &array,
719 bool JSHClass::TransitToElementsKind(const JSThread *thread, const JSHandle<JSObject> &object,
753 void JSHClass::UpdateFieldType(JSHClass *hclass, const PropertyAttributes &attr)
756     JSHClass *ownHClass = FindFieldOwnHClass(hclass, attr);
760 JSHClass *JSHClass::FindFieldOwnHClass(JSHClass *hclass, const PropertyAttributes &attr)
764     JSHClass *curHClass = hclass;
766         auto parentHClass = JSHClass::Cast(parent.GetTaggedObject());
776 void JSHClass::VisitAndUpdateLayout(JSHClass *ownHClass, const PropertyAttributes &attr)
780     std::queue<JSHClass *> backHClass;
783         JSHClass *current = backHClass.front();
797             backHClass.push(JSHClass::Cast(cache));
803         dict->IterateEntryValue([&backHClass] (JSHClass *cache) {
804             backHClass.push(JSHClass::Cast(cache));
809 TransitionResult JSHClass::ConvertOrTransitionWithRep(const JSThread *thread,
829             JSHClass::TransitionForRepChange(thread, receiver, key, attr);
841             JSHClass::TransitionForRepChange(thread, receiver, key, attr);
848 JSHandle<JSTaggedValue> JSHClass::EnableProtoChangeMarker(const JSThread *thread, const JSHandle<JSHClass> &jshclass)
857     JSHandle<JSHClass> protoClass(thread, protoHandle->GetJSHClass());
880 JSHandle<JSTaggedValue> JSHClass::EnablePHCProtoChangeMarker(const JSThread *thread,
881     const JSHandle<JSHClass> &protoClass)
898 void JSHClass::NotifyHclassChanged(const JSThread *thread, JSHandle<JSHClass> oldHclass, JSHandle<JSHClass> newHclass,
935     JSHClass::NoticeThroughChain(thread, oldHclass, addedKey);
936     JSHClass::RefreshUsers(thread, oldHclass, newHclass);
939 void JSHClass::NotifyAccessorChanged(const JSThread *thread, JSHandle<JSHClass> hclass)
960             NotifyAccessorChanged(thread, JSHandle<JSHClass>(thread, listeners->Get(i).GetTaggedObject()));
965 void JSHClass::RegisterOnProtoChain(const JSThread *thread, const JSHandle<JSHClass> &jshclass)
971     JSHandle<JSHClass> user = jshclass;
994             GetProtoChangeDetails(thread, JSHandle<JSHClass>(thread, protoHandle->GetJSHClass()));
1007         user = JSHandle<JSHClass>(thread, protoHandle->GetJSHClass());
1011 bool JSHClass::UnregisterOnProtoChain(const JSThread *thread, const JSHandle<JSHClass> &jshclass)
1042 JSHandle<ProtoChangeDetails> JSHClass::GetProtoChangeDetails(const JSThread *thread, const JSHandle<JSHClass> &jshclass)
1053 JSHandle<ProtoChangeDetails> JSHClass::GetProtoChangeDetails(const JSThread *thread, const JSHandle<JSObject> &obj)
1055     JSHandle<JSHClass> jshclass(thread, obj->GetJSHClass());
1059 void JSHClass::MarkProtoChanged([[maybe_unused]] const JSThread *thread, const JSHandle<JSHClass> &jshclass)
1070 void JSHClass::NoticeThroughChain(const JSThread *thread, const JSHandle<JSHClass> &jshclass,
1087             NoticeThroughChain(thread, JSHandle<JSHClass>(thread, listeners->Get(i).GetTaggedObject()), addedKey);
1092 void JSHClass::RefreshUsers(const JSThread *thread, const JSHandle<JSHClass> &oldHclass,
1093                             const JSHandle<JSHClass> &newHclass)
1113 PropertyLookupResult JSHClass::LookupPropertyInAotHClass(const JSThread *thread, JSHClass *hclass, JSTaggedValue key)
1125     int entry = JSHClass::FindPropertyEntry(thread, hclass, key);
1154 PropertyLookupResult JSHClass::LookupPropertyInPGOHClass(const JSThread *thread, JSHClass *hclass, JSTaggedValue key)
1164     int entry = JSHClass::FindPropertyEntry(thread, hclass, key);
1194 PropertyLookupResult JSHClass::LookupPropertyInBuiltinPrototypeHClass(const JSThread *thread, JSHClass *hclass,
1206     int entry = JSHClass::FindPropertyEntry(thread, hclass, key);
1234 JSHandle<JSTaggedValue> JSHClass::ParseKeyFromPGOCString(ObjectFactory* factory,
1256 JSHandle<JSHClass> JSHClass::CreateRootHClassFromPGO(const JSThread* thread,
1272     JSHandle<JSHClass> hclass = factory->NewEcmaHClass(size, type, maxNum);
1294 JSHandle<JSHClass> JSHClass::CreateRootHClassWithCached(const JSThread* thread,
1303     JSHandle<JSHClass> hclass = factory->GetObjectLiteralRootHClass(maxNum);
1320         JSHandle<JSHClass> child = SetPropertyOfObjHClass(thread, hclass, key, attributes, rep);
1329 JSHandle<JSHClass> JSHClass::CreateChildHClassFromPGO(const JSThread* thread,
1330                                                       const JSHandle<JSHClass>& parent,
1339     JSHandle<JSHClass> newJsHClass = JSHClass::Clone(thread, parent);
1363         JSHClass::NotifyHclassChanged(thread, parent, newJsHClass, key.GetTaggedValue());
1369 bool JSHClass::DumpRootHClassByPGO(const JSHClass* hclass, HClassLayoutDesc* desc)
1384 bool JSHClass::DumpChildHClassByPGO(const JSHClass* hclass, HClassLayoutDesc* desc)
1399 bool JSHClass::UpdateChildLayoutDescByPGO(const JSHClass* hclass, HClassLayoutDesc* childDesc)
1413 bool JSHClass::UpdateRootLayoutDescByPGO(const JSHClass* hclass, HClassLayoutDesc* desc)
1429 CString JSHClass::DumpToString(JSTaggedType hclassVal)
1432     auto hclass = JSHClass::Cast(JSTaggedValue(hclassVal).GetTaggedObject());
1456             LOG_ECMA(FATAL) << "JSHClass::DumpToString UNREACHABLE";
1462 PropertyLookupResult JSHClass::LookupPropertyInBuiltinHClass(const JSThread *thread, JSHClass *hclass,
1473     int entry = JSHClass::FindPropertyEntry(thread, hclass, key);
1503 JSHandle<JSHClass> JSHClass::CreateSHClass(JSThread *thread,
1505                                            const JSHClass *parentHClass,
1523     JSHandle<JSHClass> hclass =
1535 JSHandle<JSHClass> JSHClass::CreateSConstructorHClass(JSThread *thread, const std::vector<PropertyDescriptor> &descs)
1543 JSHandle<JSHClass> JSHClass::CreateSPrototypeHClass(JSThread *thread, const std::vector<PropertyDescriptor> &descs)
1551 void JSHClass::CreateSInlinedLayout(JSThread *thread,
1553                                     const JSHandle<JSHClass> &hclass,
1554                                     const JSHClass *parentHClass)
1606 void JSHClass::CreateSDictLayout(JSThread *thread,
1608                                  const JSHandle<JSHClass> &hclass,
1609                                  const JSHClass *parentHClass)
1663 bool JSHClass::IsNeedNotifyHclassChangedForAotTransition(const JSThread *thread, const JSHandle<JSHClass> &hclass,
1668         JSHClass *protoHclass = protoHandle->GetJSHClass();
1669         if (JSHClass::FindPropertyEntry(thread, protoHclass, key) != -1) {