1 /* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ECMASCRIPT_SERIALIZER_BASE_SERIALIZER_H 17 #define ECMASCRIPT_SERIALIZER_BASE_SERIALIZER_H 18 19 #include "ecmascript/mem/object_xray.h" 20 #include "ecmascript/serializer/serialize_chunk.h" 21 #include "ecmascript/serializer/serialize_data.h" 22 23 namespace panda::ecmascript { 24 25 class Ecmavm; 26 class JSThread; 27 class BaseSerializer { 28 public: BaseSerializer(JSThread * thread)29 explicit BaseSerializer(JSThread *thread) : thread_(thread), vm_(thread->GetEcmaVM()) 30 { 31 data_.reset(new SerializeData(thread)); 32 sharedObjChunk_.reset(new SerializationChunk()); 33 } ~BaseSerializer()34 virtual ~BaseSerializer() 35 { 36 referenceMap_.clear(); 37 } 38 NO_COPY_SEMANTIC(BaseSerializer); 39 NO_MOVE_SEMANTIC(BaseSerializer); 40 41 void SerializeJSTaggedValue(JSTaggedValue value); Release()42 std::unique_ptr<SerializeData> Release() 43 { 44 return std::move(data_); 45 } 46 GetThread()47 JSThread *GetThread() 48 { 49 return thread_; 50 } 51 protected: 52 template <SerializeType serializeType> 53 class SerializeObjectFieldVisitor final : public BaseObjectVisitor<SerializeObjectFieldVisitor<serializeType>> { 54 public: 55 explicit SerializeObjectFieldVisitor(BaseSerializer *serializer); 56 ~SerializeObjectFieldVisitor() override = default; 57 58 void VisitObjectRangeImpl(BaseObject *rootObject, uintptr_t startAddr, uintptr_t endAddr, 59 VisitObjectArea area) override; 60 void VisitObjectHClassImpl(BaseObject *hclass) override; 61 private: 62 BaseSerializer *serializer_ {nullptr}; 63 }; 64 // Different serialize mode can implement this interface to custom processing 65 virtual void SerializeObjectImpl(TaggedObject *object, bool isWeak = false) = 0; 66 void WriteMultiRawData(uintptr_t beginAddr, size_t fieldSize); 67 template<SerializeType serializeType> 68 void SerializeTaggedObject(TaggedObject *object); 69 bool SerializeReference(TaggedObject *object); 70 bool SerializeRootObject(TaggedObject *object); 71 void SerializeSharedObject(TaggedObject *object); 72 template<SerializeType serializeType> 73 void SerializeObjectField(TaggedObject *object); 74 bool SerializeSpecialObjIndividually(JSType objectType, TaggedObject *root, ObjectSlot start, ObjectSlot end); 75 void SerializeHClassFieldIndividually(TaggedObject *root, ObjectSlot start, ObjectSlot end); 76 void SerializeSFunctionFieldIndividually(TaggedObject *root, ObjectSlot start, ObjectSlot end); 77 void SerializeSFunctionModule(JSFunction *func); 78 void SerializeLexicalEnvFieldIndividually(TaggedObject *root, ObjectSlot start, ObjectSlot end); 79 void SerializeSFunctionEnvFieldIndividually(TaggedObject *root, ObjectSlot start, ObjectSlot end); 80 void SerializeSendableEnvFieldIndividually(TaggedObject *root, ObjectSlot start, ObjectSlot end); 81 void SerializeAsyncFunctionFieldIndividually(TaggedObject *root, ObjectSlot start, ObjectSlot end); 82 void SerializeObjectProto(JSHClass *kclass, JSTaggedValue proto); 83 void SerializeTaggedObjField(SerializeType serializeType, TaggedObject *root, ObjectSlot start, ObjectSlot end); 84 void SerializeInObjField(TaggedObject *object, ObjectSlot start, ObjectSlot end); 85 SerializedObjectSpace GetSerializedObjectSpace(TaggedObject *object) const; 86 87 protected: 88 JSThread *thread_; 89 EcmaVM *vm_; 90 std::unique_ptr<SerializeData> data_; 91 std::unique_ptr<SerializationChunk> sharedObjChunk_; 92 CUnorderedMap<TaggedObject *, uint32_t> referenceMap_; 93 size_t objectIndex_ {0}; 94 static constexpr size_t LEXICALENV_GLOBAL_ENV_SLOT = 95 LexicalEnv::DATA_OFFSET + LexicalEnv::GLOBAL_ENV_INDEX * sizeof(JSTaggedValue); 96 static constexpr size_t LEXICALENV_PARENT_ENV_SLOT = 97 LexicalEnv::DATA_OFFSET + LexicalEnv::PARENT_ENV_INDEX * sizeof(JSTaggedValue); 98 static constexpr size_t LEXICALENV_SCOPE_INFO_SLOT = 99 LexicalEnv::DATA_OFFSET + LexicalEnv::SCOPE_INFO_INDEX * sizeof(JSTaggedValue); 100 static constexpr size_t SFUNCTIONENV_GLOBAL_ENV_SLOT = 101 SFunctionEnv::DATA_OFFSET + SFunctionEnv::GLOBAL_ENV_INDEX * sizeof(JSTaggedValue); 102 static constexpr size_t SFUNCTIONENV_CONSTRUCTOR_SLOT = 103 SFunctionEnv::DATA_OFFSET + SFunctionEnv::CONSTRUCTOR_INDEX * sizeof(JSTaggedValue); 104 static constexpr size_t SENDABLEENV_PARENT_ENV_SLOT = 105 SendableEnv::DATA_OFFSET + SendableEnv::SENDABLE_PARENT_ENV_INDEX * sizeof(JSTaggedValue); 106 static constexpr size_t SENDABLEENV_SCOPE_INFO_SLOT = 107 SendableEnv::DATA_OFFSET + SendableEnv::SENDABLE_SCOPE_INFO_INDEX * sizeof(JSTaggedValue); 108 int32_t serializeSharedEvent_ = 0; 109 }; 110 } 111 112 #endif // ECMASCRIPT_SERIALIZER_BASE_SERIALIZER_H 113