Alexander Markov
5129cff930
While deserializing AOT snapshot, Code objects which do not contain valuable information besides entry point and stack maps are discarded and not allocated on the heap (they are replaced with StubCode::UnknownDartCode()). PC -> Code/CompressedStackMaps lookup is implemented using a separate table (InstructionsTable). Flutter gallery in release-sizeopt mode: Heap size of snapshot objects: arm -26.89%, arm64 -27.68% Large Flutter application in release mode with --dwarf-stack-traces: Heap size of snapshot objects: -24.3%. Discarded Code objects: 72.5% of all Code objects. Issue: https://github.com/dart-lang/sdk/issues/44852. TEST=existing tests; "--dwarf_stack_traces --no-retain_function_objects --no-retain_code_objects" mode is enabled for a few tests. Change-Id: I5fe3e283630c8e8f4442319d5dcae38d174dd0d8 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/189560 Commit-Queue: Alexander Markov <alexmarkov@google.com> Reviewed-by: Ryan Macnak <rmacnak@google.com>
1241 lines
34 KiB
C++
1241 lines
34 KiB
C++
// 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.
|
|
|
|
#include "vm/compiler/runtime_api.h"
|
|
|
|
#include "vm/object.h"
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
#include "vm/compiler/runtime_offsets_list.h"
|
|
#include "vm/dart_api_state.h"
|
|
#include "vm/dart_entry.h"
|
|
#include "vm/longjump.h"
|
|
#include "vm/native_arguments.h"
|
|
#include "vm/native_entry.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/runtime_entry.h"
|
|
#include "vm/symbols.h"
|
|
#include "vm/timeline.h"
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
namespace dart {
|
|
namespace compiler {
|
|
namespace target {
|
|
|
|
#include "vm/compiler/runtime_offsets_extracted.h"
|
|
|
|
bool IsSmi(int64_t v) {
|
|
return Utils::IsInt(kSmiBits + 1, v);
|
|
}
|
|
|
|
bool WillAllocateNewOrRememberedContext(intptr_t num_context_variables) {
|
|
if (!dart::Context::IsValidLength(num_context_variables)) return false;
|
|
return dart::Heap::IsAllocatableInNewSpace(
|
|
dart::Context::InstanceSize(num_context_variables));
|
|
}
|
|
|
|
bool WillAllocateNewOrRememberedArray(intptr_t length) {
|
|
if (!dart::Array::IsValidLength(length)) return false;
|
|
return !dart::Array::UseCardMarkingForAllocation(length);
|
|
}
|
|
|
|
} // namespace target
|
|
} // namespace compiler
|
|
} // namespace dart
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
namespace dart {
|
|
namespace compiler {
|
|
|
|
bool IsSameObject(const Object& a, const Object& b) {
|
|
if (a.IsMint() && b.IsMint()) {
|
|
return Mint::Cast(a).value() == Mint::Cast(b).value();
|
|
} else if (a.IsDouble() && b.IsDouble()) {
|
|
return Double::Cast(a).value() == Double::Cast(b).value();
|
|
}
|
|
return a.ptr() == b.ptr();
|
|
}
|
|
|
|
bool IsEqualType(const AbstractType& a, const AbstractType& b) {
|
|
return a.Equals(b);
|
|
}
|
|
|
|
bool IsDoubleType(const AbstractType& type) {
|
|
return type.IsDoubleType();
|
|
}
|
|
|
|
bool IsBoolType(const AbstractType& type) {
|
|
return type.IsBoolType();
|
|
}
|
|
|
|
bool IsSubtypeOfInt(const AbstractType& type) {
|
|
return type.IsIntType() || type.IsIntegerImplementationType() ||
|
|
type.IsSmiType() || type.IsMintType();
|
|
}
|
|
|
|
bool IsSmiType(const AbstractType& type) {
|
|
return type.IsSmiType();
|
|
}
|
|
|
|
bool IsNotTemporaryScopedHandle(const Object& obj) {
|
|
return obj.IsNotTemporaryScopedHandle();
|
|
}
|
|
|
|
#define DO(clazz) \
|
|
bool Is##clazz##Handle(const Object& obj) { return obj.Is##clazz(); }
|
|
CLASS_LIST_FOR_HANDLES(DO)
|
|
#undef DO
|
|
|
|
bool IsInOldSpace(const Object& obj) {
|
|
return obj.IsSmi() || obj.IsOld();
|
|
}
|
|
|
|
intptr_t ObjectHash(const Object& obj) {
|
|
if (obj.IsNull()) {
|
|
return 2011;
|
|
}
|
|
if (obj.IsString() || obj.IsNumber()) {
|
|
return Instance::Cast(obj).CanonicalizeHash();
|
|
}
|
|
if (obj.IsCode()) {
|
|
// Instructions don't move during compaction.
|
|
return Code::Cast(obj).PayloadStart();
|
|
}
|
|
if (obj.IsFunction()) {
|
|
return Function::Cast(obj).Hash();
|
|
}
|
|
if (obj.IsField()) {
|
|
return dart::String::HashRawSymbol(Field::Cast(obj).name());
|
|
}
|
|
// Unlikely.
|
|
return obj.GetClassId();
|
|
}
|
|
|
|
void SetToNull(Object* obj) {
|
|
*obj = Object::null();
|
|
}
|
|
|
|
Object& NewZoneHandle(Zone* zone) {
|
|
return Object::ZoneHandle(zone, Object::null());
|
|
}
|
|
|
|
Object& NewZoneHandle(Zone* zone, const Object& obj) {
|
|
return Object::ZoneHandle(zone, obj.ptr());
|
|
}
|
|
|
|
const Object& NullObject() {
|
|
return Object::null_object();
|
|
}
|
|
|
|
const Object& SentinelObject() {
|
|
return Object::sentinel();
|
|
}
|
|
|
|
const Bool& TrueObject() {
|
|
return dart::Bool::True();
|
|
}
|
|
|
|
const Bool& FalseObject() {
|
|
return dart::Bool::False();
|
|
}
|
|
|
|
const Object& EmptyTypeArguments() {
|
|
return Object::empty_type_arguments();
|
|
}
|
|
|
|
const Type& DynamicType() {
|
|
return dart::Type::dynamic_type();
|
|
}
|
|
|
|
const Type& ObjectType() {
|
|
return Type::Handle(dart::Type::ObjectType());
|
|
}
|
|
|
|
const Type& VoidType() {
|
|
return dart::Type::void_type();
|
|
}
|
|
|
|
const Type& IntType() {
|
|
return Type::Handle(dart::Type::IntType());
|
|
}
|
|
|
|
const Class& GrowableObjectArrayClass() {
|
|
auto object_store = IsolateGroup::Current()->object_store();
|
|
return Class::Handle(object_store->growable_object_array_class());
|
|
}
|
|
|
|
const Class& MintClass() {
|
|
auto object_store = IsolateGroup::Current()->object_store();
|
|
return Class::Handle(object_store->mint_class());
|
|
}
|
|
|
|
const Class& DoubleClass() {
|
|
auto object_store = IsolateGroup::Current()->object_store();
|
|
return Class::Handle(object_store->double_class());
|
|
}
|
|
|
|
const Array& OneArgArgumentsDescriptor() {
|
|
return Array::ZoneHandle(
|
|
ArgumentsDescriptor::NewBoxed(/*type_args_len=*/0, /*num_arguments=*/1));
|
|
}
|
|
|
|
bool IsOriginalObject(const Object& object) {
|
|
if (object.IsICData()) {
|
|
return ICData::Cast(object).IsOriginal();
|
|
} else if (object.IsField()) {
|
|
return Field::Cast(object).IsOriginal();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const String& AllocateString(const char* buffer) {
|
|
return String::ZoneHandle(String::New(buffer, dart::Heap::kOld));
|
|
}
|
|
|
|
bool HasIntegerValue(const dart::Object& object, int64_t* value) {
|
|
if (object.IsInteger()) {
|
|
*value = Integer::Cast(object).AsInt64Value();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int32_t CreateJitCookie() {
|
|
return static_cast<int32_t>(IsolateGroup::Current()->random()->NextUInt32());
|
|
}
|
|
|
|
word TypedDataElementSizeInBytes(classid_t cid) {
|
|
return dart::TypedData::ElementSizeInBytes(cid);
|
|
}
|
|
|
|
word TypedDataMaxNewSpaceElements(classid_t cid) {
|
|
return (dart::Heap::kNewAllocatableSize - target::TypedData::InstanceSize()) /
|
|
TypedDataElementSizeInBytes(cid);
|
|
}
|
|
|
|
const Field& LookupMathRandomStateFieldOffset() {
|
|
const auto& math_lib = dart::Library::Handle(dart::Library::MathLibrary());
|
|
ASSERT(!math_lib.IsNull());
|
|
const auto& random_class = dart::Class::Handle(
|
|
math_lib.LookupClassAllowPrivate(dart::Symbols::_Random()));
|
|
ASSERT(!random_class.IsNull());
|
|
const auto& state_field = dart::Field::ZoneHandle(
|
|
random_class.LookupInstanceFieldAllowPrivate(dart::Symbols::_state()));
|
|
return state_field;
|
|
}
|
|
|
|
const Field& LookupConvertUtf8DecoderScanFlagsField() {
|
|
const auto& convert_lib =
|
|
dart::Library::Handle(dart::Library::ConvertLibrary());
|
|
ASSERT(!convert_lib.IsNull());
|
|
const auto& _utf8decoder_class = dart::Class::Handle(
|
|
convert_lib.LookupClassAllowPrivate(dart::Symbols::_Utf8Decoder()));
|
|
ASSERT(!_utf8decoder_class.IsNull());
|
|
const auto& scan_flags_field = dart::Field::ZoneHandle(
|
|
_utf8decoder_class.LookupInstanceFieldAllowPrivate(
|
|
dart::Symbols::_scanFlags()));
|
|
return scan_flags_field;
|
|
}
|
|
|
|
word LookupFieldOffsetInBytes(const Field& field) {
|
|
return field.TargetOffset();
|
|
}
|
|
|
|
#if defined(TARGET_ARCH_IA32)
|
|
uword SymbolsPredefinedAddress() {
|
|
return reinterpret_cast<uword>(dart::Symbols::PredefinedAddress());
|
|
}
|
|
#endif
|
|
|
|
const Code& StubCodeAllocateArray() {
|
|
return dart::StubCode::AllocateArray();
|
|
}
|
|
|
|
const Code& StubCodeSubtype3TestCache() {
|
|
return dart::StubCode::Subtype3TestCache();
|
|
}
|
|
|
|
const Code& StubCodeSubtype7TestCache() {
|
|
return dart::StubCode::Subtype7TestCache();
|
|
}
|
|
|
|
#define DEFINE_ALIAS(name) \
|
|
const RuntimeEntry& k##name##RuntimeEntry(dart::k##name##RuntimeEntry);
|
|
RUNTIME_ENTRY_LIST(DEFINE_ALIAS)
|
|
#undef DEFINE_ALIAS
|
|
|
|
#define DEFINE_ALIAS(type, name, ...) \
|
|
const RuntimeEntry& k##name##RuntimeEntry(dart::k##name##RuntimeEntry);
|
|
LEAF_RUNTIME_ENTRY_LIST(DEFINE_ALIAS)
|
|
#undef DEFINE_ALIAS
|
|
|
|
void BailoutWithBranchOffsetError() {
|
|
Thread::Current()->long_jump_base()->Jump(1, Object::branch_offset_error());
|
|
}
|
|
|
|
word RuntimeEntry::OffsetFromThread() const {
|
|
return target::Thread::OffsetFromThread(runtime_entry_);
|
|
}
|
|
|
|
bool RuntimeEntry::is_leaf() const {
|
|
return runtime_entry_->is_leaf();
|
|
}
|
|
|
|
namespace target {
|
|
|
|
const word kOldPageSize = dart::kOldPageSize;
|
|
const word kOldPageSizeInWords = dart::kOldPageSize / kWordSize;
|
|
const word kOldPageMask = dart::kOldPageMask;
|
|
|
|
static word TranslateOffsetInWordsToHost(word offset) {
|
|
RELEASE_ASSERT((offset % kWordSize) == 0);
|
|
return (offset / kWordSize) * dart::kWordSize;
|
|
}
|
|
|
|
bool SizeFitsInSizeTag(uword instance_size) {
|
|
return dart::UntaggedObject::SizeTag::SizeFits(
|
|
TranslateOffsetInWordsToHost(instance_size));
|
|
}
|
|
|
|
uword MakeTagWordForNewSpaceObject(classid_t cid, uword instance_size) {
|
|
return dart::UntaggedObject::SizeTag::encode(
|
|
TranslateOffsetInWordsToHost(instance_size)) |
|
|
dart::UntaggedObject::ClassIdTag::encode(cid) |
|
|
dart::UntaggedObject::NewBit::encode(true);
|
|
}
|
|
|
|
word Object::tags_offset() {
|
|
return 0;
|
|
}
|
|
|
|
const word UntaggedObject::kCardRememberedBit =
|
|
dart::UntaggedObject::kCardRememberedBit;
|
|
|
|
const word UntaggedObject::kOldAndNotRememberedBit =
|
|
dart::UntaggedObject::kOldAndNotRememberedBit;
|
|
|
|
const word UntaggedObject::kOldAndNotMarkedBit =
|
|
dart::UntaggedObject::kOldAndNotMarkedBit;
|
|
|
|
const word UntaggedObject::kSizeTagPos = dart::UntaggedObject::kSizeTagPos;
|
|
|
|
const word UntaggedObject::kSizeTagSize = dart::UntaggedObject::kSizeTagSize;
|
|
|
|
const word UntaggedObject::kClassIdTagPos =
|
|
dart::UntaggedObject::kClassIdTagPos;
|
|
|
|
const word UntaggedObject::kClassIdTagSize =
|
|
dart::UntaggedObject::kClassIdTagSize;
|
|
|
|
const word UntaggedObject::kHashTagPos = dart::UntaggedObject::kHashTagPos;
|
|
|
|
const word UntaggedObject::kHashTagSize = dart::UntaggedObject::kHashTagSize;
|
|
|
|
const word UntaggedObject::kSizeTagMaxSizeTag =
|
|
dart::UntaggedObject::SizeTag::kMaxSizeTagInUnitsOfAlignment *
|
|
ObjectAlignment::kObjectAlignment;
|
|
|
|
const word UntaggedObject::kTagBitsSizeTagPos =
|
|
dart::UntaggedObject::TagBits::kSizeTagPos;
|
|
|
|
const word UntaggedAbstractType::kTypeStateFinalizedInstantiated =
|
|
dart::UntaggedAbstractType::kFinalizedInstantiated;
|
|
|
|
const word UntaggedObject::kBarrierOverlapShift =
|
|
dart::UntaggedObject::kBarrierOverlapShift;
|
|
|
|
bool IsTypedDataClassId(intptr_t cid) {
|
|
return dart::IsTypedDataClassId(cid);
|
|
}
|
|
|
|
const word Class::kNoTypeArguments = dart::Class::kNoTypeArguments;
|
|
|
|
classid_t Class::GetId(const dart::Class& handle) {
|
|
return handle.id();
|
|
}
|
|
|
|
static word TranslateOffsetInWords(word offset) {
|
|
RELEASE_ASSERT((offset % dart::kWordSize) == 0);
|
|
return (offset / dart::kWordSize) * kWordSize;
|
|
}
|
|
|
|
static uword GetInstanceSizeImpl(const dart::Class& handle) {
|
|
switch (handle.id()) {
|
|
case kMintCid:
|
|
return Mint::InstanceSize();
|
|
case kDoubleCid:
|
|
return Double::InstanceSize();
|
|
case kInt32x4Cid:
|
|
return Int32x4::InstanceSize();
|
|
case kFloat32x4Cid:
|
|
return Float32x4::InstanceSize();
|
|
case kFloat64x2Cid:
|
|
return Float64x2::InstanceSize();
|
|
case kObjectCid:
|
|
return Object::InstanceSize();
|
|
case kInstanceCid:
|
|
return Instance::InstanceSize();
|
|
case kGrowableObjectArrayCid:
|
|
return GrowableObjectArray::InstanceSize();
|
|
case kClosureCid:
|
|
return Closure::InstanceSize();
|
|
case kTypedDataBaseCid:
|
|
return TypedDataBase::InstanceSize();
|
|
case kLinkedHashMapCid:
|
|
return LinkedHashMap::InstanceSize();
|
|
case kUnhandledExceptionCid:
|
|
return UnhandledException::InstanceSize();
|
|
case kWeakPropertyCid:
|
|
return WeakProperty::InstanceSize();
|
|
case kByteBufferCid:
|
|
case kByteDataViewCid:
|
|
case kFfiPointerCid:
|
|
case kFfiDynamicLibraryCid:
|
|
#define HANDLE_CASE(clazz) case kFfi##clazz##Cid:
|
|
CLASS_LIST_FFI_TYPE_MARKER(HANDLE_CASE)
|
|
#undef HANDLE_CASE
|
|
#define HANDLE_CASE(clazz) \
|
|
case kTypedData##clazz##Cid: \
|
|
case kTypedData##clazz##ViewCid: \
|
|
case kExternalTypedData##clazz##Cid:
|
|
CLASS_LIST_TYPED_DATA(HANDLE_CASE)
|
|
#undef HANDLE_CASE
|
|
return handle.target_instance_size();
|
|
default:
|
|
if (handle.id() >= kNumPredefinedCids) {
|
|
return handle.target_instance_size();
|
|
}
|
|
}
|
|
FATAL3("Unsupported class for size translation: %s (id=%" Pd
|
|
", kNumPredefinedCids=%" Pd ")\n",
|
|
handle.ToCString(), handle.id(), kNumPredefinedCids);
|
|
return -1;
|
|
}
|
|
|
|
uword Class::GetInstanceSize(const dart::Class& handle) {
|
|
return Utils::RoundUp(GetInstanceSizeImpl(handle),
|
|
ObjectAlignment::kObjectAlignment);
|
|
}
|
|
|
|
intptr_t Class::NumTypeArguments(const dart::Class& klass) {
|
|
return klass.NumTypeArguments();
|
|
}
|
|
|
|
bool Class::HasTypeArgumentsField(const dart::Class& klass) {
|
|
return klass.host_type_arguments_field_offset() !=
|
|
dart::Class::kNoTypeArguments;
|
|
}
|
|
|
|
intptr_t Class::TypeArgumentsFieldOffset(const dart::Class& klass) {
|
|
return klass.target_type_arguments_field_offset();
|
|
}
|
|
|
|
bool Class::TraceAllocation(const dart::Class& klass) {
|
|
return klass.TraceAllocation(dart::IsolateGroup::Current());
|
|
}
|
|
|
|
word Instance::first_field_offset() {
|
|
return TranslateOffsetInWords(dart::Instance::NextFieldOffset());
|
|
}
|
|
|
|
word Instance::DataOffsetFor(intptr_t cid) {
|
|
if (dart::IsExternalTypedDataClassId(cid) ||
|
|
dart::IsExternalStringClassId(cid)) {
|
|
// Elements start at offset 0 of the external data.
|
|
return 0;
|
|
}
|
|
if (dart::IsTypedDataClassId(cid)) {
|
|
return TypedData::data_offset();
|
|
}
|
|
switch (cid) {
|
|
case kArrayCid:
|
|
case kImmutableArrayCid:
|
|
return Array::data_offset();
|
|
case kTypeArgumentsCid:
|
|
return TypeArguments::types_offset();
|
|
case kOneByteStringCid:
|
|
return OneByteString::data_offset();
|
|
case kTwoByteStringCid:
|
|
return TwoByteString::data_offset();
|
|
default:
|
|
UNIMPLEMENTED();
|
|
return Array::data_offset();
|
|
}
|
|
}
|
|
|
|
word Instance::ElementSizeFor(intptr_t cid) {
|
|
if (dart::IsExternalTypedDataClassId(cid) || dart::IsTypedDataClassId(cid) ||
|
|
dart::IsTypedDataViewClassId(cid)) {
|
|
return dart::TypedDataBase::ElementSizeInBytes(cid);
|
|
}
|
|
switch (cid) {
|
|
case kArrayCid:
|
|
case kImmutableArrayCid:
|
|
case kTypeArgumentsCid:
|
|
return kWordSize;
|
|
case kOneByteStringCid:
|
|
return dart::OneByteString::kBytesPerElement;
|
|
case kTwoByteStringCid:
|
|
return dart::TwoByteString::kBytesPerElement;
|
|
case kExternalOneByteStringCid:
|
|
return dart::ExternalOneByteString::kBytesPerElement;
|
|
case kExternalTwoByteStringCid:
|
|
return dart::ExternalTwoByteString::kBytesPerElement;
|
|
default:
|
|
UNIMPLEMENTED();
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
word ICData::CodeIndexFor(word num_args) {
|
|
return dart::ICData::CodeIndexFor(num_args);
|
|
}
|
|
|
|
word ICData::CountIndexFor(word num_args) {
|
|
return dart::ICData::CountIndexFor(num_args);
|
|
}
|
|
|
|
word ICData::TargetIndexFor(word num_args) {
|
|
return dart::ICData::TargetIndexFor(num_args);
|
|
}
|
|
|
|
word ICData::ExactnessIndexFor(word num_args) {
|
|
return dart::ICData::ExactnessIndexFor(num_args);
|
|
}
|
|
|
|
word ICData::TestEntryLengthFor(word num_args, bool exactness_check) {
|
|
return dart::ICData::TestEntryLengthFor(num_args, exactness_check);
|
|
}
|
|
|
|
word ICData::EntryPointIndexFor(word num_args) {
|
|
return dart::ICData::EntryPointIndexFor(num_args);
|
|
}
|
|
|
|
const word MegamorphicCache::kSpreadFactor =
|
|
dart::MegamorphicCache::kSpreadFactor;
|
|
|
|
word Context::InstanceSize(word n) {
|
|
return TranslateOffsetInWords(dart::Context::InstanceSize(n));
|
|
}
|
|
|
|
word Context::variable_offset(word n) {
|
|
return TranslateOffsetInWords(dart::Context::variable_offset(n));
|
|
}
|
|
|
|
// Currently we have two different axes for offset generation:
|
|
//
|
|
// * Target architecture
|
|
// * DART_PRECOMPILED_RUNTIME (i.e, AOT vs. JIT)
|
|
//
|
|
// TODO(dartbug.com/43646): Add DART_PRECOMPILER as another axis.
|
|
|
|
#define DEFINE_CONSTANT(Class, Name) const word Class::Name = Class##_##Name;
|
|
|
|
#define DEFINE_PAYLOAD_SIZEOF(clazz, name, header) \
|
|
word clazz::name() { return 0; } \
|
|
word clazz::name(word payload_size) { \
|
|
return RoundedAllocationSize(clazz::header() + payload_size); \
|
|
}
|
|
|
|
#if defined(TARGET_ARCH_IA32)
|
|
|
|
#define DEFINE_FIELD(clazz, name) \
|
|
word clazz::name() { return clazz##_##name; }
|
|
|
|
#define DEFINE_ARRAY(clazz, name) \
|
|
word clazz::name(intptr_t index) { \
|
|
return clazz##_elements_start_offset + index * clazz##_element_size; \
|
|
}
|
|
|
|
#define DEFINE_SIZEOF(clazz, name, what) \
|
|
word clazz::name() { return clazz##_##name; }
|
|
|
|
#define DEFINE_RANGE(Class, Getter, Type, First, Last, Filter) \
|
|
word Class::Getter(Type index) { \
|
|
return Class##_##Getter[static_cast<intptr_t>(index) - \
|
|
static_cast<intptr_t>(First)]; \
|
|
}
|
|
|
|
JIT_OFFSETS_LIST(DEFINE_FIELD,
|
|
DEFINE_ARRAY,
|
|
DEFINE_SIZEOF,
|
|
DEFINE_PAYLOAD_SIZEOF,
|
|
DEFINE_RANGE,
|
|
DEFINE_CONSTANT)
|
|
|
|
COMMON_OFFSETS_LIST(DEFINE_FIELD,
|
|
DEFINE_ARRAY,
|
|
DEFINE_SIZEOF,
|
|
DEFINE_PAYLOAD_SIZEOF,
|
|
DEFINE_RANGE,
|
|
DEFINE_CONSTANT)
|
|
|
|
#else
|
|
|
|
#define DEFINE_JIT_FIELD(clazz, name) \
|
|
word clazz::name() { \
|
|
if (FLAG_precompiled_mode) { \
|
|
FATAL1("Use JIT-only field %s in precompiled mode", #clazz "::" #name); \
|
|
} \
|
|
return clazz##_##name; \
|
|
}
|
|
|
|
#define DEFINE_JIT_ARRAY(clazz, name) \
|
|
word clazz::name(intptr_t index) { \
|
|
if (FLAG_precompiled_mode) { \
|
|
FATAL1("Use of JIT-only array %s in precompiled mode", \
|
|
#clazz "::" #name); \
|
|
} \
|
|
return clazz##_elements_start_offset + index * clazz##_element_size; \
|
|
}
|
|
|
|
#define DEFINE_JIT_SIZEOF(clazz, name, what) \
|
|
word clazz::name() { \
|
|
if (FLAG_precompiled_mode) { \
|
|
FATAL1("Use of JIT-only sizeof %s in precompiled mode", \
|
|
#clazz "::" #name); \
|
|
} \
|
|
return clazz##_##name; \
|
|
}
|
|
|
|
#define DEFINE_JIT_RANGE(Class, Getter, Type, First, Last, Filter) \
|
|
word Class::Getter(Type index) { \
|
|
if (FLAG_precompiled_mode) { \
|
|
FATAL1("Use of JIT-only range %s in precompiled mode", \
|
|
#Class "::" #Getter); \
|
|
} \
|
|
return Class##_##Getter[static_cast<intptr_t>(index) - \
|
|
static_cast<intptr_t>(First)]; \
|
|
}
|
|
|
|
JIT_OFFSETS_LIST(DEFINE_JIT_FIELD,
|
|
DEFINE_JIT_ARRAY,
|
|
DEFINE_JIT_SIZEOF,
|
|
DEFINE_PAYLOAD_SIZEOF,
|
|
DEFINE_JIT_RANGE,
|
|
DEFINE_CONSTANT)
|
|
|
|
#undef DEFINE_JIT_FIELD
|
|
#undef DEFINE_JIT_ARRAY
|
|
#undef DEFINE_JIT_SIZEOF
|
|
#undef DEFINE_JIT_RANGE
|
|
|
|
#define DEFINE_FIELD(clazz, name) \
|
|
word clazz::name() { \
|
|
return FLAG_precompiled_mode ? AOT_##clazz##_##name : clazz##_##name; \
|
|
}
|
|
|
|
#define DEFINE_ARRAY(clazz, name) \
|
|
word clazz::name(intptr_t index) { \
|
|
if (FLAG_precompiled_mode) { \
|
|
return AOT_##clazz##_elements_start_offset + \
|
|
index * AOT_##clazz##_element_size; \
|
|
} else { \
|
|
return clazz##_elements_start_offset + index * clazz##_element_size; \
|
|
} \
|
|
}
|
|
|
|
#define DEFINE_SIZEOF(clazz, name, what) \
|
|
word clazz::name() { \
|
|
return FLAG_precompiled_mode ? AOT_##clazz##_##name : clazz##_##name; \
|
|
}
|
|
|
|
#define DEFINE_RANGE(Class, Getter, Type, First, Last, Filter) \
|
|
word Class::Getter(Type index) { \
|
|
if (FLAG_precompiled_mode) { \
|
|
return AOT_##Class##_##Getter[static_cast<intptr_t>(index) - \
|
|
static_cast<intptr_t>(First)]; \
|
|
} else { \
|
|
return Class##_##Getter[static_cast<intptr_t>(index) - \
|
|
static_cast<intptr_t>(First)]; \
|
|
} \
|
|
}
|
|
|
|
COMMON_OFFSETS_LIST(DEFINE_FIELD,
|
|
DEFINE_ARRAY,
|
|
DEFINE_SIZEOF,
|
|
DEFINE_PAYLOAD_SIZEOF,
|
|
DEFINE_RANGE,
|
|
DEFINE_CONSTANT)
|
|
|
|
#endif
|
|
|
|
#undef DEFINE_FIELD
|
|
#undef DEFINE_ARRAY
|
|
#undef DEFINE_SIZEOF
|
|
#undef DEFINE_RANGE
|
|
#undef DEFINE_PAYLOAD_SIZEOF
|
|
#undef DEFINE_CONSTANT
|
|
|
|
const word StoreBufferBlock::kSize = dart::StoreBufferBlock::kSize;
|
|
|
|
const word MarkingStackBlock::kSize = dart::MarkingStackBlock::kSize;
|
|
|
|
// For InstructionsSections and Instructions, we define these by hand, because
|
|
// they depend on flags or #defines.
|
|
|
|
// Used for InstructionsSection and Instructions methods, since we don't
|
|
// serialize Instructions objects in bare instructions mode, just payloads.
|
|
DART_FORCE_INLINE static bool BareInstructionsPayloads() {
|
|
return FLAG_precompiled_mode && FLAG_use_bare_instructions;
|
|
}
|
|
|
|
word InstructionsSection::HeaderSize() {
|
|
// We only create InstructionsSections in precompiled mode.
|
|
ASSERT(FLAG_precompiled_mode);
|
|
return Utils::RoundUp(InstructionsSection::UnalignedHeaderSize(),
|
|
Instructions::kBarePayloadAlignment);
|
|
}
|
|
|
|
word Instructions::HeaderSize() {
|
|
return BareInstructionsPayloads()
|
|
? 0
|
|
: Utils::RoundUp(UnalignedHeaderSize(), kNonBarePayloadAlignment);
|
|
}
|
|
|
|
word Instructions::InstanceSize() {
|
|
return 0;
|
|
}
|
|
|
|
word Instructions::InstanceSize(word payload_size) {
|
|
const intptr_t alignment = BareInstructionsPayloads()
|
|
? kBarePayloadAlignment
|
|
: ObjectAlignment::kObjectAlignment;
|
|
return Utils::RoundUp(Instructions::HeaderSize() + payload_size, alignment);
|
|
}
|
|
|
|
word Thread::stack_overflow_shared_stub_entry_point_offset(bool fpu_regs) {
|
|
return fpu_regs ? stack_overflow_shared_with_fpu_regs_entry_point_offset()
|
|
: stack_overflow_shared_without_fpu_regs_entry_point_offset();
|
|
}
|
|
|
|
uword Thread::safepoint_state_unacquired() {
|
|
return dart::Thread::safepoint_state_unacquired();
|
|
}
|
|
|
|
uword Thread::safepoint_state_acquired() {
|
|
return dart::Thread::safepoint_state_acquired();
|
|
}
|
|
|
|
intptr_t Thread::safepoint_state_inside_bit() {
|
|
COMPILE_ASSERT(dart::Thread::AtSafepointField::bitsize() == 1);
|
|
return dart::Thread::AtSafepointField::shift();
|
|
}
|
|
|
|
uword Thread::generated_execution_state() {
|
|
return dart::Thread::ExecutionState::kThreadInGenerated;
|
|
}
|
|
|
|
uword Thread::native_execution_state() {
|
|
return dart::Thread::ExecutionState::kThreadInNative;
|
|
}
|
|
|
|
uword Thread::vm_execution_state() {
|
|
return dart::Thread::ExecutionState::kThreadInVM;
|
|
}
|
|
|
|
uword Thread::vm_tag_dart_id() {
|
|
return dart::VMTag::kDartTagId;
|
|
}
|
|
|
|
uword Thread::exit_through_runtime_call() {
|
|
return dart::Thread::kExitThroughRuntimeCall;
|
|
}
|
|
|
|
uword Thread::exit_through_ffi() {
|
|
return dart::Thread::kExitThroughFfi;
|
|
}
|
|
|
|
word Thread::OffsetFromThread(const dart::Object& object) {
|
|
auto host_offset = dart::Thread::OffsetFromThread(object);
|
|
return object_null_offset() +
|
|
TranslateOffsetInWords(host_offset -
|
|
dart::Thread::object_null_offset());
|
|
}
|
|
|
|
intptr_t Thread::OffsetFromThread(const dart::RuntimeEntry* runtime_entry) {
|
|
auto host_offset = dart::Thread::OffsetFromThread(runtime_entry);
|
|
return AllocateArray_entry_point_offset() +
|
|
TranslateOffsetInWords(
|
|
host_offset - dart::Thread::AllocateArray_entry_point_offset());
|
|
}
|
|
|
|
bool CanLoadFromThread(const dart::Object& object,
|
|
intptr_t* offset /* = nullptr */) {
|
|
if (dart::Thread::CanLoadFromThread(object)) {
|
|
if (offset != nullptr) {
|
|
*offset = Thread::OffsetFromThread(object);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static_assert(
|
|
kSmiBits <= dart::kSmiBits,
|
|
"Expected that size of Smi on HOST is at least as large as on target.");
|
|
|
|
bool IsSmi(const dart::Object& a) {
|
|
return a.IsSmi() && IsSmi(dart::Smi::Cast(a).Value());
|
|
}
|
|
|
|
word ToRawSmi(const dart::Object& a) {
|
|
RELEASE_ASSERT(IsSmi(a));
|
|
return static_cast<word>(static_cast<intptr_t>(a.ptr()));
|
|
}
|
|
|
|
word ToRawSmi(intptr_t value) {
|
|
return dart::Smi::RawValue(value);
|
|
}
|
|
|
|
word SmiValue(const dart::Object& a) {
|
|
RELEASE_ASSERT(IsSmi(a));
|
|
return static_cast<word>(dart::Smi::Cast(a).Value());
|
|
}
|
|
|
|
#if defined(TARGET_ARCH_IA32)
|
|
uword Code::EntryPointOf(const dart::Code& code) {
|
|
static_assert(kHostWordSize == kWordSize,
|
|
"Can't embed raw pointers to runtime objects when host and "
|
|
"target word sizes are different");
|
|
return code.EntryPoint();
|
|
}
|
|
|
|
bool CanEmbedAsRawPointerInGeneratedCode(const dart::Object& obj) {
|
|
return obj.IsSmi() || obj.InVMIsolateHeap();
|
|
}
|
|
|
|
word ToRawPointer(const dart::Object& a) {
|
|
static_assert(kHostWordSize == kWordSize,
|
|
"Can't embed raw pointers to runtime objects when host and "
|
|
"target word sizes are different");
|
|
return static_cast<word>(a.ptr());
|
|
}
|
|
#endif // defined(TARGET_ARCH_IA32)
|
|
|
|
word RegExp::function_offset(classid_t cid, bool sticky) {
|
|
#if !defined(DART_COMPRESSED_POINTERS)
|
|
return TranslateOffsetInWords(dart::RegExp::function_offset(cid, sticky));
|
|
#else
|
|
// TODO(rmacnak): TranslateOffsetInWords doesn't account for, say, header
|
|
// being 1 word and slots being half words.
|
|
return dart::RegExp::function_offset(cid, sticky);
|
|
#endif
|
|
}
|
|
|
|
const word Symbols::kNumberOfOneCharCodeSymbols =
|
|
dart::Symbols::kNumberOfOneCharCodeSymbols;
|
|
const word Symbols::kNullCharCodeSymbolOffset =
|
|
dart::Symbols::kNullCharCodeSymbolOffset;
|
|
|
|
const word String::kHashBits = dart::String::kHashBits;
|
|
|
|
const uint8_t Nullability::kNullable =
|
|
static_cast<uint8_t>(dart::Nullability::kNullable);
|
|
const uint8_t Nullability::kNonNullable =
|
|
static_cast<uint8_t>(dart::Nullability::kNonNullable);
|
|
const uint8_t Nullability::kLegacy =
|
|
static_cast<uint8_t>(dart::Nullability::kLegacy);
|
|
|
|
bool Heap::IsAllocatableInNewSpace(intptr_t instance_size) {
|
|
return dart::Heap::IsAllocatableInNewSpace(instance_size);
|
|
}
|
|
|
|
word Field::OffsetOf(const dart::Field& field) {
|
|
return field.TargetOffset();
|
|
}
|
|
|
|
word FieldTable::OffsetOf(const dart::Field& field) {
|
|
return TranslateOffsetInWords(
|
|
dart::FieldTable::FieldOffsetFor(field.field_id()));
|
|
}
|
|
|
|
word FreeListElement::FakeInstance::InstanceSize() {
|
|
return 0;
|
|
}
|
|
|
|
word ForwardingCorpse::FakeInstance::InstanceSize() {
|
|
return 0;
|
|
}
|
|
|
|
word Instance::NextFieldOffset() {
|
|
return TranslateOffsetInWords(dart::Instance::NextFieldOffset());
|
|
}
|
|
|
|
word Pointer::NextFieldOffset() {
|
|
return TranslateOffsetInWords(dart::Pointer::NextFieldOffset());
|
|
}
|
|
|
|
word WeakSerializationReference::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ObjectPool::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ObjectPool::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(ObjectPool::element_offset(length));
|
|
}
|
|
|
|
word Class::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Function::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ICData::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word MegamorphicCache::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word SingleTargetCache::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Array::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
intptr_t Array::index_at_offset(intptr_t offset_in_bytes) {
|
|
return dart::Array::index_at_offset(
|
|
TranslateOffsetInWordsToHost(offset_in_bytes));
|
|
}
|
|
|
|
word Array::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(Array::element_offset(length));
|
|
}
|
|
|
|
word GrowableObjectArray::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypedDataBase::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypedData::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypedData::InstanceSize(intptr_t lengthInBytes) {
|
|
return RoundedAllocationSize(TypedData::InstanceSize() + lengthInBytes);
|
|
}
|
|
|
|
word ExternalTypedData::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypedDataView::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word LinkedHashMap::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word AbstractType::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Type::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word FunctionType::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypeRef::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Double::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Mint::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word String::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word String::InstanceSize(word payload_size) {
|
|
return RoundedAllocationSize(String::InstanceSize() + payload_size);
|
|
}
|
|
|
|
word OneByteString::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word OneByteString::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(OneByteString::InstanceSize() +
|
|
length * dart::OneByteString::kBytesPerElement);
|
|
}
|
|
|
|
word TwoByteString::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TwoByteString::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(TwoByteString::InstanceSize() +
|
|
length * dart::TwoByteString::kBytesPerElement);
|
|
}
|
|
|
|
word ExternalOneByteString::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ExternalTwoByteString::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Int32x4::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Float32x4::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Float64x2::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word DynamicLibrary::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word PatchClass::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word FfiTrampolineData::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Script::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Library::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Namespace::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word KernelProgramInfo::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word PcDescriptors::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word CodeSourceMap::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word CompressedStackMaps::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word LocalVarDescriptors::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ExceptionHandlers::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ExceptionHandlers::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(ExceptionHandlers::element_offset(length));
|
|
}
|
|
|
|
word ContextScope::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ContextScope::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(ContextScope::element_offset(length));
|
|
}
|
|
|
|
word UnlinkedCall::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ApiError::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word LanguageError::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word UnhandledException::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word UnwindError::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Bool::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypeParameter::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word LibraryPrefix::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Capability::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ReceivePort::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word SendPort::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TransferableTypedData::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word StackTrace::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Integer::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Smi::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word WeakProperty::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word MirrorReference::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Number::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word MonomorphicSmiableCall::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word InstructionsSection::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word InstructionsTable::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(InstructionsTable::InstanceSize() +
|
|
length *
|
|
dart::InstructionsTable::kBytesPerElement);
|
|
}
|
|
|
|
word InstructionsTable::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Instructions::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Code::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word SubtypeTestCache::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word LoadingUnit::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Context::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Closure::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ClosureData::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word RegExp::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word UserTag::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word FutureOr::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word Field::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypeArguments::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word TypeArguments::InstanceSize(intptr_t length) {
|
|
return RoundedAllocationSize(TypeArguments::type_at_offset(length));
|
|
}
|
|
|
|
word FreeListElement::FakeInstance::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
word ForwardingCorpse::FakeInstance::NextFieldOffset() {
|
|
return -kWordSize;
|
|
}
|
|
|
|
} // namespace target
|
|
} // namespace compiler
|
|
} // namespace dart
|
|
|
|
#else
|
|
|
|
namespace dart {
|
|
namespace compiler {
|
|
namespace target {
|
|
|
|
const word Array::kMaxElements = Array_kMaxElements;
|
|
|
|
} // namespace target
|
|
} // namespace compiler
|
|
} // namespace dart
|
|
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|