| // Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| #ifndef RUNTIME_VM_COMPILER_RUNTIME_API_H_ |
| #define RUNTIME_VM_COMPILER_RUNTIME_API_H_ |
| |
| // This header defines the API that compiler can use to interact with the |
| // underlying Dart runtime that it is embedded into. |
| // |
| // Compiler is not allowed to directly interact with any objects - it can only |
| // use classes like dart::Object, dart::Code, dart::Function and similar as |
| // opaque handles. All interactions should be done through helper methods |
| // provided by this header. |
| // |
| // This header also provides ways to get word sizes, frame layout, field |
| // offsets for the target runtime. Note that these can be different from |
| // those on the host. Helpers providing access to these values live |
| // in compiler::target namespace. |
| |
| #include "platform/globals.h" |
| #include "platform/thread_sanitizer.h" |
| #include "platform/utils.h" |
| |
| #include "vm/allocation.h" |
| #include "vm/bitfield.h" |
| #include "vm/bss_relocs.h" |
| #include "vm/class_id.h" |
| #include "vm/code_entry_kind.h" |
| #include "vm/constants.h" |
| #include "vm/frame_layout.h" |
| #include "vm/pointer_tagging.h" |
| #include "vm/runtime_entry_list.h" |
| #include "vm/token.h" |
| |
| namespace dart { |
| |
| // Forward declarations. |
| class LocalVariable; |
| class Object; |
| class RuntimeEntry; |
| class Zone; |
| |
| #define DO(clazz) \ |
| class Untagged##clazz; \ |
| class clazz; |
| CLASS_LIST_FOR_HANDLES(DO) |
| #undef DO |
| |
| namespace compiler { |
| class Assembler; |
| } |
| |
| namespace compiler { |
| |
| // Host word sizes. |
| // |
| // Code in the compiler namespace should not use kWordSize and derived |
| // constants directly because the word size on host and target might |
| // be different. |
| // |
| // To prevent this we introduce variables that would shadow these |
| // constants and introduce compilation errors when used. |
| // |
| // target::kWordSize and target::ObjectAlignment give access to |
| // word size and object aligment offsets for the target. |
| // |
| // Similarly kHostWordSize gives access to the host word size. |
| class InvalidClass {}; |
| extern InvalidClass kWordSize; |
| extern InvalidClass kWordSizeLog2; |
| extern InvalidClass kBitsPerWord; |
| extern InvalidClass kBitsPerWordLog2; |
| extern InvalidClass kWordMin; |
| extern InvalidClass kWordMax; |
| extern InvalidClass kUWordMax; |
| extern InvalidClass kNewObjectAlignmentOffset; |
| extern InvalidClass kOldObjectAlignmentOffset; |
| extern InvalidClass kNewObjectBitPosition; |
| extern InvalidClass kOldPageSize; |
| extern InvalidClass kOldPageSizeInWords; |
| extern InvalidClass kOldPageMask; |
| extern InvalidClass kObjectAlignment; |
| extern InvalidClass kObjectAlignmentLog2; |
| extern InvalidClass kObjectAlignmentMask; |
| extern InvalidClass kSmiBits; |
| extern InvalidClass kSmiMin; |
| extern InvalidClass kSmiMax; |
| |
| static constexpr intptr_t kHostWordSize = dart::kWordSize; |
| static constexpr intptr_t kHostWordSizeLog2 = dart::kWordSizeLog2; |
| |
| // |
| // Object handles. |
| // |
| |
| // Create an empty handle. |
| Object& NewZoneHandle(Zone* zone); |
| |
| // Clone the given handle. |
| Object& NewZoneHandle(Zone* zone, const Object&); |
| |
| // |
| // Constant objects. |
| // |
| |
| const Object& NullObject(); |
| const Object& SentinelObject(); |
| const Bool& TrueObject(); |
| const Bool& FalseObject(); |
| const Object& EmptyTypeArguments(); |
| const Type& DynamicType(); |
| const Type& ObjectType(); |
| const Type& VoidType(); |
| const Type& IntType(); |
| const Class& GrowableObjectArrayClass(); |
| const Class& MintClass(); |
| const Class& DoubleClass(); |
| const Class& Float32x4Class(); |
| const Class& Float64x2Class(); |
| const Class& Int32x4Class(); |
| const Class& ClosureClass(); |
| const Array& OneArgArgumentsDescriptor(); |
| |
| template <typename To, typename From> |
| const To& CastHandle(const From& from) { |
| return reinterpret_cast<const To&>(from); |
| } |
| |
| // Returns true if [a] and [b] are the same object. |
| bool IsSameObject(const Object& a, const Object& b); |
| |
| // Returns true if [a] and [b] represent the same type (are equal). |
| bool IsEqualType(const AbstractType& a, const AbstractType& b); |
| |
| // Returns true if [type] is a subtype of the "int" type (_Smi, _Mint, int or |
| // _IntegerImplementation). |
| bool IsSubtypeOfInt(const AbstractType& type); |
| |
| // Returns true if [type] is the "double" type. |
| bool IsDoubleType(const AbstractType& type); |
| |
| // Returns true if [type] is the "double" type. |
| bool IsBoolType(const AbstractType& type); |
| |
| // Returns true if [type] is the "_Smi" type. |
| bool IsSmiType(const AbstractType& type); |
| |
| // Returns true if the given handle is a zone handle or one of the global |
| // cached handles. |
| bool IsNotTemporaryScopedHandle(const Object& obj); |
| |
| // Returns true if [obj] resides in old space. |
| bool IsInOldSpace(const Object& obj); |
| |
| // Returns true if [obj] is not a Field/ICData clone. |
| // |
| // Used to assert that we are not embedding pointers to cloned objects that are |
| // used by background compiler into object pools / code. |
| bool IsOriginalObject(const Object& object); |
| |
| // Clear the given handle. |
| void SetToNull(Object* obj); |
| |
| // Helper functions to upcast handles. |
| // |
| // Note: compiler code cannot include object.h so it cannot see that Object is |
| // a superclass of Code or Function - thus we have to cast these pointers using |
| // reinterpret_cast. |
| inline const Object& ToObject(const Code& handle) { |
| return *reinterpret_cast<const Object*>(&handle); |
| } |
| |
| inline const Object& ToObject(const Function& handle) { |
| return *reinterpret_cast<const Object*>(&handle); |
| } |
| |
| // Returns some hash value for the given object. |
| // |
| // Note: the given hash value does not necessarily match Object.get:hashCode, |
| // or canonical hash. |
| intptr_t ObjectHash(const Object& obj); |
| |
| // Prints the given object into a C string. |
| const char* ObjectToCString(const Object& obj); |
| |
| // If the given object represents a Dart integer returns true and sets [value] |
| // to the value of the integer. |
| bool HasIntegerValue(const dart::Object& obj, int64_t* value); |
| |
| // Creates a random cookie to be used for masking constants embedded in the |
| // generated code. |
| int32_t CreateJitCookie(); |
| |
| // Returns the size in bytes for the given class id. |
| word TypedDataElementSizeInBytes(classid_t cid); |
| |
| // Returns the size in bytes for the given class id. |
| word TypedDataMaxNewSpaceElements(classid_t cid); |
| |
| // Looks up the dart:math's _Random._A field. |
| const Field& LookupMathRandomStateFieldOffset(); |
| |
| // Looks up the dart:convert's _Utf8Decoder._scanFlags field. |
| const Field& LookupConvertUtf8DecoderScanFlagsField(); |
| |
| // Returns the offset in bytes of [field]. |
| word LookupFieldOffsetInBytes(const Field& field); |
| |
| #if defined(TARGET_ARCH_IA32) |
| uword SymbolsPredefinedAddress(); |
| #endif |
| |
| typedef void (*RuntimeEntryCallInternal)(const dart::RuntimeEntry*, |
| Assembler*, |
| intptr_t); |
| |
| const Code& StubCodeAllocateArray(); |
| const Code& StubCodeSubtype3TestCache(); |
| const Code& StubCodeSubtype7TestCache(); |
| |
| class RuntimeEntry : public ValueObject { |
| public: |
| virtual ~RuntimeEntry() {} |
| |
| void Call(Assembler* assembler, intptr_t argument_count) const { |
| ASSERT(call_ != NULL); |
| ASSERT(runtime_entry_ != NULL); |
| |
| // We call a manually set function pointer which points to the |
| // implementation of call for the subclass. We do this instead of just |
| // defining Call in this class as a pure virtual method and providing an |
| // implementation in the subclass as RuntimeEntry objects are declared as |
| // globals which causes problems on Windows. |
| // |
| // When exit() is called on Windows, global objects start to be destroyed. |
| // As part of an object's destruction, the vtable is reset to that of the |
| // base class. Since some threads may still be running and accessing these |
| // now destroyed globals, an invocation to dart::RuntimeEntry::Call would |
| // instead invoke dart::compiler::RuntimeEntry::Call. If |
| // dart::compiler::RuntimeEntry::Call were a pure virtual method, _purecall |
| // would be invoked to handle the invalid call and attempt to call exit(), |
| // causing the process to hang on a lock. |
| // |
| // By removing the need to rely on a potentially invalid vtable at exit, |
| // we should be able to avoid hanging or crashing the process at shutdown, |
| // even as global objects start to be destroyed. See issue #35855. |
| call_(runtime_entry_, assembler, argument_count); |
| } |
| |
| word OffsetFromThread() const; |
| |
| bool is_leaf() const; |
| |
| protected: |
| RuntimeEntry(const dart::RuntimeEntry* runtime_entry, |
| RuntimeEntryCallInternal call) |
| : runtime_entry_(runtime_entry), call_(call) {} |
| |
| private: |
| const dart::RuntimeEntry* runtime_entry_; |
| RuntimeEntryCallInternal call_; |
| }; |
| |
| #define DECLARE_RUNTIME_ENTRY(name) \ |
| extern const RuntimeEntry& k##name##RuntimeEntry; |
| RUNTIME_ENTRY_LIST(DECLARE_RUNTIME_ENTRY) |
| #undef DECLARE_RUNTIME_ENTRY |
| |
| #define DECLARE_RUNTIME_ENTRY(type, name, ...) \ |
| extern const RuntimeEntry& k##name##RuntimeEntry; |
| LEAF_RUNTIME_ENTRY_LIST(DECLARE_RUNTIME_ENTRY) |
| #undef DECLARE_RUNTIME_ENTRY |
| |
| // Allocate a string object with the given content in the runtime heap. |
| const String& AllocateString(const char* buffer); |
| |
| DART_NORETURN void BailoutWithBranchOffsetError(); |
| |
| // compiler::target namespace contains information about the target platform: |
| // |
| // - word sizes and derived constants |
| // - offsets of fields |
| // - sizes of structures |
| namespace target { |
| |
| #if defined(TARGET_ARCH_IS_32_BIT) |
| typedef int32_t word; |
| typedef uint32_t uword; |
| static constexpr int kWordSizeLog2 = 2; |
| #elif defined(TARGET_ARCH_IS_64_BIT) |
| typedef int64_t word; |
| typedef uint64_t uword; |
| static constexpr int kWordSizeLog2 = 3; |
| #else |
| #error "Unsupported architecture" |
| #endif |
| static constexpr int kWordSize = 1 << kWordSizeLog2; |
| static_assert(kWordSize == sizeof(word), "kWordSize should match sizeof(word)"); |
| // Our compiler code currently assumes this, so formally check it. |
| #if !defined(FFI_UNIT_TESTS) |
| static_assert(dart::kWordSize >= kWordSize, |
| "Host word size smaller than target word size"); |
| #endif |
| |
| #if defined(DART_COMPRESSED_POINTERS) |
| static constexpr int kCompressedWordSize = kInt32Size; |
| static constexpr int kCompressedWordSizeLog2 = kInt32SizeLog2; |
| #else |
| static constexpr int kCompressedWordSize = kWordSize; |
| static constexpr int kCompressedWordSizeLog2 = kWordSizeLog2; |
| #endif |
| |
| static constexpr word kBitsPerWordLog2 = kWordSizeLog2 + kBitsPerByteLog2; |
| static constexpr word kBitsPerWord = 1 << kBitsPerWordLog2; |
| |
| using ObjectAlignment = dart::ObjectAlignment<kWordSize, kWordSizeLog2>; |
| |
| constexpr word kWordMax = (static_cast<uword>(1) << (kBitsPerWord - 1)) - 1; |
| constexpr word kWordMin = -(static_cast<uword>(1) << (kBitsPerWord - 1)); |
| constexpr uword kUwordMax = static_cast<word>(-1); |
| |
| // The number of bits in the _magnitude_ of a Smi, not counting the sign bit. |
| #if !defined(DART_COMPRESSED_POINTERS) |
| constexpr int kSmiBits = kBitsPerWord - 2; |
| #else |
| constexpr int kSmiBits = 30; |
| #endif |
| constexpr word kSmiMax = (static_cast<uword>(1) << kSmiBits) - 1; |
| constexpr word kSmiMin = -(static_cast<uword>(1) << kSmiBits); |
| |
| // Information about heap pages. |
| extern const word kOldPageSize; |
| extern const word kOldPageSizeInWords; |
| extern const word kOldPageMask; |
| |
| static constexpr intptr_t kObjectAlignment = ObjectAlignment::kObjectAlignment; |
| |
| // Note: if other flags are added, then change the check for required parameters |
| // when no named arguments are provided in |
| // FlowGraphBuilder::BuildClosureCallHasRequiredNamedArgumentsCheck, since it |
| // assumes there are no flag slots when no named parameters are required. |
| enum ParameterFlags { |
| kRequiredNamedParameterFlag, |
| kNumParameterFlags, |
| }; |
| // Parameter flags are stored in Smis. To ensure shifts and masks can be used to |
| // calculate both the parameter flag index in the parameter names array and |
| // which bit to check, kNumParameterFlagsPerElement should be a power of two. |
| static constexpr intptr_t kNumParameterFlagsPerElementLog2 = |
| kBitsPerWordLog2 - 1 - kNumParameterFlags; |
| static constexpr intptr_t kNumParameterFlagsPerElement = |
| 1 << kNumParameterFlagsPerElementLog2; |
| static_assert(kNumParameterFlagsPerElement <= kSmiBits, |
| "kNumParameterFlagsPerElement should fit in a Smi"); |
| |
| inline intptr_t RoundedAllocationSize(intptr_t size) { |
| return Utils::RoundUp(size, kObjectAlignment); |
| } |
| // Information about frame_layout that compiler should be targeting. |
| extern UntaggedFrame frame_layout; |
| |
| constexpr intptr_t kIntSpillFactor = sizeof(int64_t) / kWordSize; |
| constexpr intptr_t kDoubleSpillFactor = sizeof(double) / kWordSize; |
| |
| // Returns the FP-relative index where [variable] can be found (assumes |
| // [variable] is not captured), in bytes. |
| inline int FrameOffsetInBytesForVariable(const LocalVariable* variable) { |
| return frame_layout.FrameSlotForVariable(variable) * kWordSize; |
| } |
| |
| // Check whether instance_size is small enough to be encoded in the size tag. |
| bool SizeFitsInSizeTag(uword instance_size); |
| |
| // Encode tag word for a heap allocated object with the given class id and |
| // size. |
| // |
| // Note: even on 64-bit platforms we only use lower 32-bits of the tag word. |
| uword MakeTagWordForNewSpaceObject(classid_t cid, uword instance_size); |
| |
| // |
| // Target specific information about objects. |
| // |
| |
| // Returns true if the given object can be represented as a Smi on the target |
| // platform. |
| bool IsSmi(const dart::Object& a); |
| |
| // Returns true if the given value can be represented as a Smi on the target |
| // platform. |
| bool IsSmi(int64_t value); |
| |
| // Return raw Smi representation of the given object for the target platform. |
| word ToRawSmi(const dart::Object& a); |
| |
| // Return raw Smi representation of the given integer value for the target |
| // platform. |
| // |
| // Note: method assumes that caller has validated that value is representable |
| // as a Smi. |
| word ToRawSmi(intptr_t value); |
| |
| word SmiValue(const dart::Object& a); |
| |
| // If the given object can be loaded from the thread on the target then |
| // return true and set offset (if provided) to the offset from the |
| // thread pointer to a field that contains the object. |
| bool CanLoadFromThread(const dart::Object& object, intptr_t* offset = nullptr); |
| |
| // On IA32 we can embed raw pointers into generated code. |
| #if defined(TARGET_ARCH_IA32) |
| // Returns true if the pointer to the given object can be directly embedded |
| // into the generated code (because the object is immortal and immovable). |
| bool CanEmbedAsRawPointerInGeneratedCode(const dart::Object& obj); |
| |
| // Returns raw pointer value for the given object. Should only be invoked |
| // if CanEmbedAsRawPointerInGeneratedCode returns true. |
| word ToRawPointer(const dart::Object& a); |
| #endif // defined(TARGET_ARCH_IA32) |
| |
| bool WillAllocateNewOrRememberedObject(intptr_t instance_size); |
| |
| bool WillAllocateNewOrRememberedContext(intptr_t num_context_variables); |
| |
| bool WillAllocateNewOrRememberedArray(intptr_t length); |
| |
| #define FINAL_CLASS() \ |
| static word NextFieldOffset() { return -kWordSize; } |
| |
| // |
| // Target specific offsets and constants. |
| // |
| // Currently we use the same names for classes, constants and getters to make |
| // migration easier. |
| |
| class UntaggedObject : public AllStatic { |
| public: |
| static const word kCardRememberedBit; |
| static const word kOldAndNotRememberedBit; |
| static const word kOldAndNotMarkedBit; |
| static const word kSizeTagPos; |
| static const word kSizeTagSize; |
| static const word kClassIdTagPos; |
| static const word kClassIdTagSize; |
| static const word kHashTagPos; |
| static const word kHashTagSize; |
| static const word kSizeTagMaxSizeTag; |
| static const word kTagBitsSizeTagPos; |
| static const word kBarrierOverlapShift; |
| static const word kGenerationalBarrierMask; |
| |
| static bool IsTypedDataClassId(intptr_t cid); |
| }; |
| |
| class UntaggedAbstractType : public AllStatic { |
| public: |
| static const word kTypeStateFinalizedInstantiated; |
| }; |
| |
| class UntaggedType : public AllStatic { |
| public: |
| static const bool kTypeClassIdIsSigned; |
| static const word kTypeClassIdBitSize; |
| }; |
| |
| class Object : public AllStatic { |
| public: |
| // Offset of the tags word. |
| static word tags_offset(); |
| static word InstanceSize(); |
| }; |
| |
| class ObjectPool : public AllStatic { |
| public: |
| // Return offset to the element with the given [index] in the object pool. |
| static word element_offset(intptr_t index); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Class : public AllStatic { |
| public: |
| static word host_type_arguments_field_offset_in_words_offset(); |
| |
| static word declaration_type_offset(); |
| |
| static word super_type_offset(); |
| |
| // The offset of the UntaggedObject::num_type_arguments_ field in bytes. |
| static word num_type_arguments_offset(); |
| |
| // The value used if no type arguments vector is present. |
| static const word kNoTypeArguments; |
| |
| static word InstanceSize(); |
| |
| FINAL_CLASS(); |
| |
| // Return class id of the given class on the target. |
| static classid_t GetId(const dart::Class& handle); |
| |
| // Return instance size for the given class on the target. |
| static uword GetInstanceSize(const dart::Class& handle); |
| |
| // Return whether objects of the class on the target contain compressed |
| // pointers. |
| static bool HasCompressedPointers(const dart::Class& handle); |
| |
| // Returns the number of type arguments. |
| static intptr_t NumTypeArguments(const dart::Class& klass); |
| |
| // Whether [klass] has a type arguments vector field. |
| static bool HasTypeArgumentsField(const dart::Class& klass); |
| |
| // Returns the offset (in bytes) of the type arguments vector. |
| static intptr_t TypeArgumentsFieldOffset(const dart::Class& klass); |
| |
| // Whether to trace allocation for this klass. |
| static bool TraceAllocation(const dart::Class& klass); |
| }; |
| |
| class Instance : public AllStatic { |
| public: |
| // Returns the offset to the first field of [UntaggedInstance]. |
| static word first_field_offset(); |
| static word native_fields_array_offset(); |
| static word DataOffsetFor(intptr_t cid); |
| static word ElementSizeFor(intptr_t cid); |
| static word InstanceSize(); |
| static word NextFieldOffset(); |
| }; |
| |
| class Function : public AllStatic { |
| public: |
| static word code_offset(); |
| static word data_offset(); |
| static word entry_point_offset(CodeEntryKind kind = CodeEntryKind::kNormal); |
| static word kind_tag_offset(); |
| static word packed_fields_offset(); |
| static word signature_offset(); |
| static word usage_counter_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class CallSiteData : public AllStatic { |
| public: |
| static word arguments_descriptor_offset(); |
| }; |
| |
| class ICData : public AllStatic { |
| public: |
| static word owner_offset(); |
| static word entries_offset(); |
| static word receivers_static_type_offset(); |
| static word state_bits_offset(); |
| |
| static word CodeIndexFor(word num_args); |
| static word CountIndexFor(word num_args); |
| static word TargetIndexFor(word num_args); |
| static word ExactnessIndexFor(word num_args); |
| static word TestEntryLengthFor(word num_args, bool exactness_check); |
| static word EntryPointIndexFor(word num_args); |
| static word NumArgsTestedShift(); |
| static word NumArgsTestedMask(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class MegamorphicCache : public AllStatic { |
| public: |
| static const word kSpreadFactor; |
| static word mask_offset(); |
| static word buckets_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class SingleTargetCache : public AllStatic { |
| public: |
| static word lower_limit_offset(); |
| static word upper_limit_offset(); |
| static word entry_point_offset(); |
| static word target_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Array : public AllStatic { |
| public: |
| static word header_size(); |
| static word tags_offset(); |
| static word data_offset(); |
| static word type_arguments_offset(); |
| static word length_offset(); |
| static word element_offset(intptr_t index); |
| static intptr_t index_at_offset(intptr_t offset_in_bytes); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| |
| static const word kMaxElements; |
| static const word kMaxNewSpaceElements; |
| }; |
| |
| class GrowableObjectArray : public AllStatic { |
| public: |
| static word data_offset(); |
| static word type_arguments_offset(); |
| static word length_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class PointerBase : public AllStatic { |
| public: |
| static word data_offset(); |
| }; |
| |
| class TypedDataBase : public AllStatic { |
| public: |
| static word length_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TypedData : public AllStatic { |
| public: |
| static word payload_offset(); |
| static word HeaderSize(); |
| static word InstanceSize(); |
| static word InstanceSize(word lengthInBytes); |
| FINAL_CLASS(); |
| }; |
| |
| class ExternalTypedData : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TypedDataView : public AllStatic { |
| public: |
| static word offset_in_bytes_offset(); |
| static word typed_data_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class LinkedHashBase : public AllStatic { |
| public: |
| static word index_offset(); |
| static word data_offset(); |
| static word hash_mask_offset(); |
| static word used_data_offset(); |
| static word deleted_keys_offset(); |
| static word type_arguments_offset(); |
| static word InstanceSize(); |
| }; |
| |
| class ImmutableLinkedHashBase : public LinkedHashBase { |
| public: |
| // The data slot is an immutable list and final in immutable maps and sets. |
| static word data_offset(); |
| }; |
| |
| class LinkedHashMap : public LinkedHashBase { |
| public: |
| FINAL_CLASS(); |
| }; |
| |
| class LinkedHashSet : public LinkedHashBase { |
| public: |
| FINAL_CLASS(); |
| }; |
| |
| class FutureOr : public AllStatic { |
| public: |
| static word type_arguments_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class ArgumentsDescriptor : public AllStatic { |
| public: |
| static word first_named_entry_offset(); |
| static word named_entry_size(); |
| static word position_offset(); |
| static word name_offset(); |
| static word count_offset(); |
| static word size_offset(); |
| static word type_args_len_offset(); |
| static word positional_count_offset(); |
| }; |
| |
| class LocalHandle : public AllStatic { |
| public: |
| static word ptr_offset(); |
| }; |
| |
| class Pointer : public AllStatic { |
| public: |
| static word type_arguments_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class AbstractType : public AllStatic { |
| public: |
| static word type_test_stub_entry_point_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Type : public AllStatic { |
| public: |
| static word hash_offset(); |
| static word type_state_offset(); |
| static word arguments_offset(); |
| static word type_class_id_offset(); |
| static word nullability_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class FunctionType : public AllStatic { |
| public: |
| static word hash_offset(); |
| static word type_state_offset(); |
| static word packed_parameter_counts_offset(); |
| static word packed_type_parameter_counts_offset(); |
| static word named_parameter_names_offset(); |
| static word parameter_types_offset(); |
| static word type_parameters_offset(); |
| static word nullability_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TypeRef : public AllStatic { |
| public: |
| static word type_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Nullability : public AllStatic { |
| public: |
| static const uint8_t kNullable; |
| static const uint8_t kNonNullable; |
| static const uint8_t kLegacy; |
| }; |
| |
| class Double : public AllStatic { |
| public: |
| static word value_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Mint : public AllStatic { |
| public: |
| static word value_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class String : public AllStatic { |
| public: |
| static const word kHashBits; |
| static const word kMaxElements; |
| static word hash_offset(); |
| static word length_offset(); |
| static word InstanceSize(); |
| static word InstanceSize(word payload_size); |
| FINAL_CLASS(); |
| }; |
| |
| class OneByteString : public AllStatic { |
| public: |
| static word data_offset(); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| |
| private: |
| static word element_offset(intptr_t index); |
| }; |
| |
| class TwoByteString : public AllStatic { |
| public: |
| static word data_offset(); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| |
| private: |
| static word element_offset(intptr_t index); |
| }; |
| |
| class ExternalOneByteString : public AllStatic { |
| public: |
| static word external_data_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class ExternalTwoByteString : public AllStatic { |
| public: |
| static word external_data_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Int32x4 : public AllStatic { |
| public: |
| static word value_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Float32x4 : public AllStatic { |
| public: |
| static word value_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Float64x2 : public AllStatic { |
| public: |
| static word value_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class DynamicLibrary : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class PatchClass : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class FfiTrampolineData : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Script : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Library : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Namespace : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class KernelProgramInfo : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class PcDescriptors : public AllStatic { |
| public: |
| static word HeaderSize(); |
| static word InstanceSize(); |
| static word InstanceSize(word payload_size); |
| FINAL_CLASS(); |
| }; |
| |
| class CodeSourceMap : public AllStatic { |
| public: |
| static word HeaderSize(); |
| static word InstanceSize(); |
| static word InstanceSize(word payload_size); |
| FINAL_CLASS(); |
| }; |
| |
| class CompressedStackMaps : public AllStatic { |
| public: |
| static word HeaderSize() { return ObjectHeaderSize() + PayloadHeaderSize(); } |
| static word InstanceSize(); |
| static word InstanceSize(word payload_size); |
| FINAL_CLASS(); |
| |
| private: |
| static word ObjectHeaderSize(); |
| static word PayloadHeaderSize(); |
| }; |
| |
| class LocalVarDescriptors : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class ExceptionHandlers : public AllStatic { |
| public: |
| static word element_offset(intptr_t index); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class ContextScope : public AllStatic { |
| public: |
| static word element_offset(intptr_t index); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Sentinel : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class UnlinkedCall : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class ApiError : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class LanguageError : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class UnhandledException : public AllStatic { |
| public: |
| static word exception_offset(); |
| static word stacktrace_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class UnwindError : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Bool : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TypeParameter : public AllStatic { |
| public: |
| static word bound_offset(); |
| static word flags_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| static word parameterized_class_id_offset(); |
| static word index_offset(); |
| static word nullability_offset(); |
| }; |
| |
| class LibraryPrefix : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Capability : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class ReceivePort : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class SendPort : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TransferableTypedData : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class StackTrace : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Integer : public AllStatic { |
| public: |
| static word InstanceSize(); |
| static word NextFieldOffset(); |
| }; |
| |
| class Smi : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class WeakProperty : public AllStatic { |
| public: |
| static word key_offset(); |
| static word value_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class WeakReference : public AllStatic { |
| public: |
| static word target_offset(); |
| static word type_arguments_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class MirrorReference : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Number : public AllStatic { |
| public: |
| static word InstanceSize(); |
| static word NextFieldOffset(); |
| }; |
| |
| class TimelineStream : public AllStatic { |
| public: |
| static word enabled_offset(); |
| }; |
| |
| class VMHandles : public AllStatic { |
| public: |
| static constexpr intptr_t kOffsetOfRawPtrInHandle = kWordSize; |
| }; |
| |
| class MonomorphicSmiableCall : public AllStatic { |
| public: |
| static word expected_cid_offset(); |
| static word entrypoint_offset(); |
| static word target_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TsanUtils : public AllStatic { |
| public: |
| static word setjmp_function_offset(); |
| static word setjmp_buffer_offset(); |
| static word exception_pc_offset(); |
| static word exception_sp_offset(); |
| static word exception_fp_offset(); |
| }; |
| |
| class Thread : public AllStatic { |
| public: |
| static word api_top_scope_offset(); |
| static word double_truncate_round_supported_offset(); |
| static word exit_through_ffi_offset(); |
| static uword exit_through_runtime_call(); |
| static uword exit_through_ffi(); |
| static word dart_stream_offset(); |
| static word predefined_symbols_address_offset(); |
| static word optimize_entry_offset(); |
| static word deoptimize_entry_offset(); |
| static word megamorphic_call_checked_entry_offset(); |
| static word active_exception_offset(); |
| static word active_stacktrace_offset(); |
| static word resume_pc_offset(); |
| static word saved_shadow_call_stack_offset(); |
| static word marking_stack_block_offset(); |
| static word top_exit_frame_info_offset(); |
| static word top_resource_offset(); |
| static word global_object_pool_offset(); |
| static word object_null_offset(); |
| static word bool_true_offset(); |
| static word bool_false_offset(); |
| static word dispatch_table_array_offset(); |
| static word top_offset(); |
| static word end_offset(); |
| static word isolate_offset(); |
| static word isolate_group_offset(); |
| static word field_table_values_offset(); |
| static word store_buffer_block_offset(); |
| static word call_to_runtime_entry_point_offset(); |
| static word write_barrier_mask_offset(); |
| static word heap_base_offset(); |
| static word switchable_call_miss_entry_offset(); |
| static word write_barrier_wrappers_thread_offset(Register regno); |
| static word array_write_barrier_entry_point_offset(); |
| static word allocate_mint_with_fpu_regs_entry_point_offset(); |
| static word allocate_mint_without_fpu_regs_entry_point_offset(); |
| static word allocate_object_entry_point_offset(); |
| static word allocate_object_parameterized_entry_point_offset(); |
| static word allocate_object_slow_entry_point_offset(); |
| static word slow_type_test_entry_point_offset(); |
| static word write_barrier_entry_point_offset(); |
| static word vm_tag_offset(); |
| static uword vm_tag_dart_id(); |
| |
| static word safepoint_state_offset(); |
| static uword full_safepoint_state_unacquired(); |
| static uword full_safepoint_state_acquired(); |
| |
| static word execution_state_offset(); |
| static uword vm_execution_state(); |
| static uword native_execution_state(); |
| static uword generated_execution_state(); |
| static word stack_overflow_flags_offset(); |
| static word stack_overflow_shared_stub_entry_point_offset(bool fpu_regs); |
| static word stack_limit_offset(); |
| static word saved_stack_limit_offset(); |
| static word unboxed_int64_runtime_arg_offset(); |
| static word unboxed_double_runtime_arg_offset(); |
| |
| static word callback_code_offset(); |
| static word callback_stack_return_offset(); |
| static word tsan_utils_offset(); |
| static word jump_to_frame_entry_point_offset(); |
| |
| static word AllocateArray_entry_point_offset(); |
| static word write_barrier_code_offset(); |
| static word array_write_barrier_code_offset(); |
| static word fix_callers_target_code_offset(); |
| static word fix_allocation_stub_code_offset(); |
| |
| static word switchable_call_miss_stub_offset(); |
| static word lazy_specialize_type_test_stub_offset(); |
| static word slow_type_test_stub_offset(); |
| static word call_to_runtime_stub_offset(); |
| static word invoke_dart_code_stub_offset(); |
| static word late_initialization_error_shared_without_fpu_regs_stub_offset(); |
| static word late_initialization_error_shared_with_fpu_regs_stub_offset(); |
| static word null_error_shared_without_fpu_regs_stub_offset(); |
| static word null_error_shared_with_fpu_regs_stub_offset(); |
| static word null_arg_error_shared_without_fpu_regs_stub_offset(); |
| static word null_arg_error_shared_with_fpu_regs_stub_offset(); |
| static word null_cast_error_shared_without_fpu_regs_stub_offset(); |
| static word null_cast_error_shared_with_fpu_regs_stub_offset(); |
| static word range_error_shared_without_fpu_regs_stub_offset(); |
| static word range_error_shared_with_fpu_regs_stub_offset(); |
| static word stack_overflow_shared_without_fpu_regs_entry_point_offset(); |
| static word stack_overflow_shared_without_fpu_regs_stub_offset(); |
| static word stack_overflow_shared_with_fpu_regs_entry_point_offset(); |
| static word stack_overflow_shared_with_fpu_regs_stub_offset(); |
| static word lazy_deopt_from_return_stub_offset(); |
| static word lazy_deopt_from_throw_stub_offset(); |
| static word allocate_mint_with_fpu_regs_stub_offset(); |
| static word allocate_mint_without_fpu_regs_stub_offset(); |
| static word allocate_object_stub_offset(); |
| static word allocate_object_parameterized_stub_offset(); |
| static word allocate_object_slow_stub_offset(); |
| static word optimize_stub_offset(); |
| static word deoptimize_stub_offset(); |
| static word enter_safepoint_stub_offset(); |
| static word exit_safepoint_stub_offset(); |
| static word exit_safepoint_ignore_unwind_in_progress_stub_offset(); |
| static word call_native_through_safepoint_stub_offset(); |
| static word call_native_through_safepoint_entry_point_offset(); |
| |
| static word bootstrap_native_wrapper_entry_point_offset(); |
| static word no_scope_native_wrapper_entry_point_offset(); |
| static word auto_scope_native_wrapper_entry_point_offset(); |
| |
| #define THREAD_XMM_CONSTANT_LIST(V) \ |
| V(float_not) \ |
| V(float_negate) \ |
| V(float_absolute) \ |
| V(float_zerow) \ |
| V(double_negate) \ |
| V(double_abs) |
| |
| #define DECLARE_CONSTANT_OFFSET_GETTER(name) \ |
| static word name##_address_offset(); |
| THREAD_XMM_CONSTANT_LIST(DECLARE_CONSTANT_OFFSET_GETTER) |
| #undef DECLARE_CONSTANT_OFFSET_GETTER |
| |
| static word random_offset(); |
| |
| static word OffsetFromThread(const dart::Object& object); |
| static intptr_t OffsetFromThread(const dart::RuntimeEntry* runtime_entry); |
| }; |
| |
| class StoreBufferBlock : public AllStatic { |
| public: |
| static word top_offset(); |
| static word pointers_offset(); |
| static const word kSize; |
| }; |
| |
| class MarkingStackBlock : public AllStatic { |
| public: |
| static word top_offset(); |
| static word pointers_offset(); |
| static const word kSize; |
| }; |
| |
| class ObjectStore : public AllStatic { |
| public: |
| static word double_type_offset(); |
| static word int_type_offset(); |
| static word string_type_offset(); |
| static word type_type_offset(); |
| }; |
| |
| class Isolate : public AllStatic { |
| public: |
| static word default_tag_offset(); |
| static word current_tag_offset(); |
| static word user_tag_offset(); |
| static word ic_miss_code_offset(); |
| #if !defined(PRODUCT) |
| static word single_step_offset(); |
| #endif // !defined(PRODUCT) |
| }; |
| |
| class IsolateGroup : public AllStatic { |
| public: |
| static word object_store_offset(); |
| static word shared_class_table_offset(); |
| static word cached_class_table_table_offset(); |
| }; |
| |
| class SharedClassTable : public AllStatic { |
| public: |
| static word class_heap_stats_table_offset(); |
| }; |
| |
| class ClassTable : public AllStatic { |
| public: |
| #if !defined(PRODUCT) |
| static word ClassOffsetFor(intptr_t cid); |
| static word SharedTableOffsetFor(); |
| static word SizeOffsetFor(intptr_t cid, bool is_new); |
| #endif // !defined(PRODUCT) |
| static const word kSizeOfClassPairLog2; |
| }; |
| |
| class InstructionsSection : public AllStatic { |
| public: |
| static word UnalignedHeaderSize(); |
| static word HeaderSize(); |
| static word InstanceSize(); |
| static word InstanceSize(word payload_size); |
| FINAL_CLASS(); |
| }; |
| |
| class InstructionsTable : public AllStatic { |
| public: |
| static word HeaderSize(); |
| static word InstanceSize(); |
| static word InstanceSize(intptr_t length); |
| FINAL_CLASS(); |
| |
| private: |
| static word element_offset(intptr_t index); |
| }; |
| |
| class Instructions : public AllStatic { |
| public: |
| static const word kMonomorphicEntryOffsetJIT; |
| static const word kPolymorphicEntryOffsetJIT; |
| static const word kMonomorphicEntryOffsetAOT; |
| static const word kPolymorphicEntryOffsetAOT; |
| static const word kBarePayloadAlignment; |
| static const word kNonBarePayloadAlignment; |
| static word UnalignedHeaderSize(); |
| static word HeaderSize(); |
| static word InstanceSize(); |
| static word InstanceSize(word payload_size); |
| FINAL_CLASS(); |
| }; |
| |
| class Code : public AllStatic { |
| public: |
| #if defined(TARGET_ARCH_IA32) |
| static uword EntryPointOf(const dart::Code& code); |
| #endif // defined(TARGET_ARCH_IA32) |
| |
| static word object_pool_offset(); |
| static word entry_point_offset(CodeEntryKind kind = CodeEntryKind::kNormal); |
| static word saved_instructions_offset(); |
| static word owner_offset(); |
| static word HeaderSize(); |
| static word InstanceSize(); |
| static word InstanceSize(intptr_t length); |
| FINAL_CLASS(); |
| |
| private: |
| static word element_offset(intptr_t index); |
| }; |
| |
| class WeakSerializationReference : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class SubtypeTestCache : public AllStatic { |
| public: |
| static word cache_offset(); |
| |
| static const word kTestEntryLength; |
| static const word kInstanceCidOrSignature; |
| static const word kDestinationType; |
| static const word kInstanceTypeArguments; |
| static const word kInstantiatorTypeArguments; |
| static const word kFunctionTypeArguments; |
| static const word kInstanceParentFunctionTypeArguments; |
| static const word kInstanceDelayedFunctionTypeArguments; |
| static const word kTestResult; |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class LoadingUnit : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Context : public AllStatic { |
| public: |
| static word header_size(); |
| static word parent_offset(); |
| static word num_variables_offset(); |
| static word variable_offset(intptr_t index); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| |
| static const word kMaxElements; |
| }; |
| |
| class Closure : public AllStatic { |
| public: |
| static word context_offset(); |
| static word delayed_type_arguments_offset(); |
| static word entry_point_offset(); |
| static word function_offset(); |
| static word function_type_arguments_offset(); |
| static word instantiator_type_arguments_offset(); |
| static word hash_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class ClosureData : public AllStatic { |
| public: |
| static word default_type_arguments_kind_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class OldPage : public AllStatic { |
| public: |
| static const word kBytesPerCardLog2; |
| |
| static word card_table_offset(); |
| }; |
| |
| class Heap : public AllStatic { |
| public: |
| // Return true if an object with the given instance size is allocatable |
| // in new space on the target. |
| static bool IsAllocatableInNewSpace(intptr_t instance_size); |
| }; |
| |
| class NativeArguments { |
| public: |
| static word thread_offset(); |
| static word argc_tag_offset(); |
| static word argv_offset(); |
| static word retval_offset(); |
| |
| static word StructSize(); |
| }; |
| |
| class NativeEntry { |
| public: |
| static const word kNumCallWrapperArguments; |
| }; |
| |
| class RegExp : public AllStatic { |
| public: |
| static word function_offset(classid_t cid, bool sticky); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class UserTag : public AllStatic { |
| public: |
| static word tag_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class Symbols : public AllStatic { |
| public: |
| static const word kNumberOfOneCharCodeSymbols; |
| static const word kNullCharCodeSymbolOffset; |
| }; |
| |
| class Field : public AllStatic { |
| public: |
| static word OffsetOf(const dart::Field& field); |
| |
| static word guarded_cid_offset(); |
| static word guarded_list_length_in_object_offset_offset(); |
| static word guarded_list_length_offset(); |
| static word is_nullable_offset(); |
| static word kind_bits_offset(); |
| static word initializer_function_offset(); |
| static word host_offset_or_field_id_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TypeParameters : public AllStatic { |
| public: |
| static word names_offset(); |
| static word flags_offset(); |
| static word bounds_offset(); |
| static word defaults_offset(); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| |
| class TypeArguments : public AllStatic { |
| public: |
| static word instantiations_offset(); |
| static word length_offset(); |
| static word nullability_offset(); |
| static word type_at_offset(intptr_t i); |
| static word types_offset(); |
| static word InstanceSize(intptr_t length); |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| |
| static const word kMaxElements; |
| }; |
| |
| class FreeListElement : public AllStatic { |
| public: |
| class FakeInstance : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| }; |
| |
| class ForwardingCorpse : public AllStatic { |
| public: |
| class FakeInstance : public AllStatic { |
| public: |
| static word InstanceSize(); |
| FINAL_CLASS(); |
| }; |
| }; |
| |
| class FieldTable : public AllStatic { |
| public: |
| static word OffsetOf(const dart::Field& field); |
| }; |
| |
| } // namespace target |
| } // namespace compiler |
| } // namespace dart |
| |
| #endif // RUNTIME_VM_COMPILER_RUNTIME_API_H_ |